vulkan_rust_sys/

builders.rs

use super::structs::*;
use super::enums::*;
use super::handles::*;
use super::bitmasks::*;
use super::constants::*;
///Builder for [`Offset2D`].
pub struct Offset2DBuilder {
    inner: Offset2D,
}
impl Offset2D {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> Offset2DBuilder {
        Offset2DBuilder {
            inner: Offset2D { ..Default::default() },
        }
    }
}
impl Offset2DBuilder {
    #[inline]
    pub fn x(mut self, value: i32) -> Self {
        self.inner.x = value;
        self
    }
    #[inline]
    pub fn y(mut self, value: i32) -> Self {
        self.inner.y = value;
        self
    }
}
impl core::ops::Deref for Offset2DBuilder {
    type Target = Offset2D;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for Offset2DBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`Offset3D`].
pub struct Offset3DBuilder {
    inner: Offset3D,
}
impl Offset3D {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> Offset3DBuilder {
        Offset3DBuilder {
            inner: Offset3D { ..Default::default() },
        }
    }
}
impl Offset3DBuilder {
    #[inline]
    pub fn x(mut self, value: i32) -> Self {
        self.inner.x = value;
        self
    }
    #[inline]
    pub fn y(mut self, value: i32) -> Self {
        self.inner.y = value;
        self
    }
    #[inline]
    pub fn z(mut self, value: i32) -> Self {
        self.inner.z = value;
        self
    }
}
impl core::ops::Deref for Offset3DBuilder {
    type Target = Offset3D;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for Offset3DBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`Extent2D`].
pub struct Extent2DBuilder {
    inner: Extent2D,
}
impl Extent2D {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> Extent2DBuilder {
        Extent2DBuilder {
            inner: Extent2D { ..Default::default() },
        }
    }
}
impl Extent2DBuilder {
    #[inline]
    pub fn width(mut self, value: u32) -> Self {
        self.inner.width = value;
        self
    }
    #[inline]
    pub fn height(mut self, value: u32) -> Self {
        self.inner.height = value;
        self
    }
}
impl core::ops::Deref for Extent2DBuilder {
    type Target = Extent2D;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for Extent2DBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`Extent3D`].
pub struct Extent3DBuilder {
    inner: Extent3D,
}
impl Extent3D {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> Extent3DBuilder {
        Extent3DBuilder {
            inner: Extent3D { ..Default::default() },
        }
    }
}
impl Extent3DBuilder {
    #[inline]
    pub fn width(mut self, value: u32) -> Self {
        self.inner.width = value;
        self
    }
    #[inline]
    pub fn height(mut self, value: u32) -> Self {
        self.inner.height = value;
        self
    }
    #[inline]
    pub fn depth(mut self, value: u32) -> Self {
        self.inner.depth = value;
        self
    }
}
impl core::ops::Deref for Extent3DBuilder {
    type Target = Extent3D;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for Extent3DBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`Viewport`].
pub struct ViewportBuilder {
    inner: Viewport,
}
impl Viewport {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> ViewportBuilder {
        ViewportBuilder {
            inner: Viewport { ..Default::default() },
        }
    }
}
impl ViewportBuilder {
    #[inline]
    pub fn x(mut self, value: f32) -> Self {
        self.inner.x = value;
        self
    }
    #[inline]
    pub fn y(mut self, value: f32) -> Self {
        self.inner.y = value;
        self
    }
    #[inline]
    pub fn width(mut self, value: f32) -> Self {
        self.inner.width = value;
        self
    }
    #[inline]
    pub fn height(mut self, value: f32) -> Self {
        self.inner.height = value;
        self
    }
    #[inline]
    pub fn min_depth(mut self, value: f32) -> Self {
        self.inner.min_depth = value;
        self
    }
    #[inline]
    pub fn max_depth(mut self, value: f32) -> Self {
        self.inner.max_depth = value;
        self
    }
}
impl core::ops::Deref for ViewportBuilder {
    type Target = Viewport;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for ViewportBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`Rect2D`].
pub struct Rect2DBuilder {
    inner: Rect2D,
}
impl Rect2D {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> Rect2DBuilder {
        Rect2DBuilder {
            inner: Rect2D { ..Default::default() },
        }
    }
}
impl Rect2DBuilder {
    #[inline]
    pub fn offset(mut self, value: Offset2D) -> Self {
        self.inner.offset = value;
        self
    }
    #[inline]
    pub fn extent(mut self, value: Extent2D) -> Self {
        self.inner.extent = value;
        self
    }
}
impl core::ops::Deref for Rect2DBuilder {
    type Target = Rect2D;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for Rect2DBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ClearRect`].
pub struct ClearRectBuilder {
    inner: ClearRect,
}
impl ClearRect {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> ClearRectBuilder {
        ClearRectBuilder {
            inner: ClearRect { ..Default::default() },
        }
    }
}
impl ClearRectBuilder {
    #[inline]
    pub fn rect(mut self, value: Rect2D) -> Self {
        self.inner.rect = value;
        self
    }
    #[inline]
    pub fn base_array_layer(mut self, value: u32) -> Self {
        self.inner.base_array_layer = value;
        self
    }
    #[inline]
    pub fn layer_count(mut self, value: u32) -> Self {
        self.inner.layer_count = value;
        self
    }
}
impl core::ops::Deref for ClearRectBuilder {
    type Target = ClearRect;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for ClearRectBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ComponentMapping`].
pub struct ComponentMappingBuilder {
    inner: ComponentMapping,
}
impl ComponentMapping {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> ComponentMappingBuilder {
        ComponentMappingBuilder {
            inner: ComponentMapping {
                ..Default::default()
            },
        }
    }
}
impl ComponentMappingBuilder {
    #[inline]
    pub fn r(mut self, value: ComponentSwizzle) -> Self {
        self.inner.r = value;
        self
    }
    #[inline]
    pub fn g(mut self, value: ComponentSwizzle) -> Self {
        self.inner.g = value;
        self
    }
    #[inline]
    pub fn b(mut self, value: ComponentSwizzle) -> Self {
        self.inner.b = value;
        self
    }
    #[inline]
    pub fn a(mut self, value: ComponentSwizzle) -> Self {
        self.inner.a = value;
        self
    }
}
impl core::ops::Deref for ComponentMappingBuilder {
    type Target = ComponentMapping;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for ComponentMappingBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceProperties`].
pub struct PhysicalDevicePropertiesBuilder {
    inner: PhysicalDeviceProperties,
}
impl PhysicalDeviceProperties {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> PhysicalDevicePropertiesBuilder {
        PhysicalDevicePropertiesBuilder {
            inner: PhysicalDeviceProperties {
                ..Default::default()
            },
        }
    }
}
impl PhysicalDevicePropertiesBuilder {
    #[inline]
    pub fn api_version(mut self, value: u32) -> Self {
        self.inner.api_version = value;
        self
    }
    #[inline]
    pub fn driver_version(mut self, value: u32) -> Self {
        self.inner.driver_version = value;
        self
    }
    #[inline]
    pub fn vendor_id(mut self, value: u32) -> Self {
        self.inner.vendor_id = value;
        self
    }
    #[inline]
    pub fn device_id(mut self, value: u32) -> Self {
        self.inner.device_id = value;
        self
    }
    #[inline]
    pub fn device_type(mut self, value: PhysicalDeviceType) -> Self {
        self.inner.device_type = value;
        self
    }
    #[inline]
    pub fn device_name(
        mut self,
        value: crate::StringArray<{ MAX_PHYSICAL_DEVICE_NAME_SIZE as usize }>,
    ) -> Self {
        self.inner.device_name = value;
        self
    }
    #[inline]
    pub fn pipeline_cache_uuid(mut self, value: [u8; UUID_SIZE as usize]) -> Self {
        self.inner.pipeline_cache_uuid = value;
        self
    }
    #[inline]
    pub fn limits(mut self, value: PhysicalDeviceLimits) -> Self {
        self.inner.limits = value;
        self
    }
    #[inline]
    pub fn sparse_properties(mut self, value: PhysicalDeviceSparseProperties) -> Self {
        self.inner.sparse_properties = value;
        self
    }
}
impl core::ops::Deref for PhysicalDevicePropertiesBuilder {
    type Target = PhysicalDeviceProperties;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for PhysicalDevicePropertiesBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ExtensionProperties`].
pub struct ExtensionPropertiesBuilder {
    inner: ExtensionProperties,
}
impl ExtensionProperties {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> ExtensionPropertiesBuilder {
        ExtensionPropertiesBuilder {
            inner: ExtensionProperties {
                ..Default::default()
            },
        }
    }
}
impl ExtensionPropertiesBuilder {
    #[inline]
    pub fn extension_name(
        mut self,
        value: crate::StringArray<{ MAX_EXTENSION_NAME_SIZE as usize }>,
    ) -> Self {
        self.inner.extension_name = value;
        self
    }
    #[inline]
    pub fn spec_version(mut self, value: u32) -> Self {
        self.inner.spec_version = value;
        self
    }
}
impl core::ops::Deref for ExtensionPropertiesBuilder {
    type Target = ExtensionProperties;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for ExtensionPropertiesBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`LayerProperties`].
pub struct LayerPropertiesBuilder {
    inner: LayerProperties,
}
impl LayerProperties {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> LayerPropertiesBuilder {
        LayerPropertiesBuilder {
            inner: LayerProperties {
                ..Default::default()
            },
        }
    }
}
impl LayerPropertiesBuilder {
    #[inline]
    pub fn layer_name(
        mut self,
        value: crate::StringArray<{ MAX_EXTENSION_NAME_SIZE as usize }>,
    ) -> Self {
        self.inner.layer_name = value;
        self
    }
    #[inline]
    pub fn spec_version(mut self, value: u32) -> Self {
        self.inner.spec_version = value;
        self
    }
    #[inline]
    pub fn implementation_version(mut self, value: u32) -> Self {
        self.inner.implementation_version = value;
        self
    }
    #[inline]
    pub fn description(
        mut self,
        value: crate::StringArray<{ MAX_DESCRIPTION_SIZE as usize }>,
    ) -> Self {
        self.inner.description = value;
        self
    }
}
impl core::ops::Deref for LayerPropertiesBuilder {
    type Target = LayerProperties;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for LayerPropertiesBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ApplicationInfo`] with lifetime-tied pNext safety.
pub struct ApplicationInfoBuilder<'a> {
    inner: ApplicationInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ApplicationInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ApplicationInfoBuilder<'a> {
        ApplicationInfoBuilder {
            inner: ApplicationInfo {
                s_type: StructureType::from_raw(0i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ApplicationInfoBuilder<'a> {
    #[inline]
    pub fn application_name(mut self, value: &'a core::ffi::CStr) -> Self {
        self.inner.p_application_name = value.as_ptr();
        self
    }
    #[inline]
    pub fn application_version(mut self, value: u32) -> Self {
        self.inner.application_version = value;
        self
    }
    #[inline]
    pub fn engine_name(mut self, value: &'a core::ffi::CStr) -> Self {
        self.inner.p_engine_name = value.as_ptr();
        self
    }
    #[inline]
    pub fn engine_version(mut self, value: u32) -> Self {
        self.inner.engine_version = value;
        self
    }
    #[inline]
    pub fn api_version(mut self, value: u32) -> Self {
        self.inner.api_version = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`ApplicationInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsApplicationInfo>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for ApplicationInfoBuilder<'a> {
    type Target = ApplicationInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ApplicationInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`AllocationCallbacks`].
pub struct AllocationCallbacksBuilder<'a> {
    inner: AllocationCallbacks,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl AllocationCallbacks {
    /// Start building this struct.
    #[inline]
    pub fn builder<'a>() -> AllocationCallbacksBuilder<'a> {
        AllocationCallbacksBuilder {
            inner: AllocationCallbacks {
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> AllocationCallbacksBuilder<'a> {
    #[inline]
    pub fn user_data(mut self, value: *mut core::ffi::c_void) -> Self {
        self.inner.p_user_data = value;
        self
    }
    #[inline]
    pub fn pfn_allocation(mut self, value: PFN_vkAllocationFunction) -> Self {
        self.inner.pfn_allocation = value;
        self
    }
    #[inline]
    pub fn pfn_reallocation(mut self, value: PFN_vkReallocationFunction) -> Self {
        self.inner.pfn_reallocation = value;
        self
    }
    #[inline]
    pub fn pfn_free(mut self, value: PFN_vkFreeFunction) -> Self {
        self.inner.pfn_free = value;
        self
    }
    #[inline]
    pub fn pfn_internal_allocation(
        mut self,
        value: PFN_vkInternalAllocationNotification,
    ) -> Self {
        self.inner.pfn_internal_allocation = value;
        self
    }
    #[inline]
    pub fn pfn_internal_free(mut self, value: PFN_vkInternalFreeNotification) -> Self {
        self.inner.pfn_internal_free = value;
        self
    }
}
impl<'a> core::ops::Deref for AllocationCallbacksBuilder<'a> {
    type Target = AllocationCallbacks;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for AllocationCallbacksBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DeviceQueueCreateInfo`] with lifetime-tied pNext safety.
pub struct DeviceQueueCreateInfoBuilder<'a> {
    inner: DeviceQueueCreateInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DeviceQueueCreateInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> DeviceQueueCreateInfoBuilder<'a> {
        DeviceQueueCreateInfoBuilder {
            inner: DeviceQueueCreateInfo {
                s_type: StructureType::from_raw(2i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DeviceQueueCreateInfoBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: DeviceQueueCreateFlags) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn queue_family_index(mut self, value: u32) -> Self {
        self.inner.queue_family_index = value;
        self
    }
    #[inline]
    pub fn queue_priorities(mut self, slice: &'a [f32]) -> Self {
        self.inner.queue_count = slice.len() as u32;
        self.inner.p_queue_priorities = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`DeviceQueueCreateInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsDeviceQueueCreateInfo>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for DeviceQueueCreateInfoBuilder<'a> {
    type Target = DeviceQueueCreateInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for DeviceQueueCreateInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DeviceCreateInfo`] with lifetime-tied pNext safety.
pub struct DeviceCreateInfoBuilder<'a> {
    inner: DeviceCreateInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DeviceCreateInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> DeviceCreateInfoBuilder<'a> {
        DeviceCreateInfoBuilder {
            inner: DeviceCreateInfo {
                s_type: StructureType::from_raw(3i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DeviceCreateInfoBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: DeviceCreateFlags) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn queue_create_infos(mut self, slice: &'a [DeviceQueueCreateInfo]) -> Self {
        self.inner.queue_create_info_count = slice.len() as u32;
        self.inner.p_queue_create_infos = slice.as_ptr();
        self
    }
    #[inline]
    pub fn enabled_layer_names(mut self, slice: &'a [*const core::ffi::c_char]) -> Self {
        self.inner.enabled_layer_count = slice.len() as u32;
        self.inner.pp_enabled_layer_names = slice.as_ptr();
        self
    }
    #[inline]
    pub fn enabled_extension_names(
        mut self,
        slice: &'a [*const core::ffi::c_char],
    ) -> Self {
        self.inner.enabled_extension_count = slice.len() as u32;
        self.inner.pp_enabled_extension_names = slice.as_ptr();
        self
    }
    #[inline]
    pub fn enabled_features(mut self, value: &'a PhysicalDeviceFeatures) -> Self {
        self.inner.p_enabled_features = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`DeviceCreateInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsDeviceCreateInfo>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for DeviceCreateInfoBuilder<'a> {
    type Target = DeviceCreateInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for DeviceCreateInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`InstanceCreateInfo`] with lifetime-tied pNext safety.
pub struct InstanceCreateInfoBuilder<'a> {
    inner: InstanceCreateInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl InstanceCreateInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> InstanceCreateInfoBuilder<'a> {
        InstanceCreateInfoBuilder {
            inner: InstanceCreateInfo {
                s_type: StructureType::from_raw(1i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> InstanceCreateInfoBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: InstanceCreateFlags) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn application_info(mut self, value: &'a ApplicationInfo) -> Self {
        self.inner.p_application_info = value;
        self
    }
    #[inline]
    pub fn enabled_layer_names(mut self, slice: &'a [*const core::ffi::c_char]) -> Self {
        self.inner.enabled_layer_count = slice.len() as u32;
        self.inner.pp_enabled_layer_names = slice.as_ptr();
        self
    }
    #[inline]
    pub fn enabled_extension_names(
        mut self,
        slice: &'a [*const core::ffi::c_char],
    ) -> Self {
        self.inner.enabled_extension_count = slice.len() as u32;
        self.inner.pp_enabled_extension_names = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`InstanceCreateInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsInstanceCreateInfo>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for InstanceCreateInfoBuilder<'a> {
    type Target = InstanceCreateInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for InstanceCreateInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`QueueFamilyProperties`].
pub struct QueueFamilyPropertiesBuilder {
    inner: QueueFamilyProperties,
}
impl QueueFamilyProperties {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> QueueFamilyPropertiesBuilder {
        QueueFamilyPropertiesBuilder {
            inner: QueueFamilyProperties {
                ..Default::default()
            },
        }
    }
}
impl QueueFamilyPropertiesBuilder {
    #[inline]
    pub fn queue_flags(mut self, value: QueueFlags) -> Self {
        self.inner.queue_flags = value;
        self
    }
    #[inline]
    pub fn queue_count(mut self, value: u32) -> Self {
        self.inner.queue_count = value;
        self
    }
    #[inline]
    pub fn timestamp_valid_bits(mut self, value: u32) -> Self {
        self.inner.timestamp_valid_bits = value;
        self
    }
    #[inline]
    pub fn min_image_transfer_granularity(mut self, value: Extent3D) -> Self {
        self.inner.min_image_transfer_granularity = value;
        self
    }
}
impl core::ops::Deref for QueueFamilyPropertiesBuilder {
    type Target = QueueFamilyProperties;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for QueueFamilyPropertiesBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceMemoryProperties`].
pub struct PhysicalDeviceMemoryPropertiesBuilder {
    inner: PhysicalDeviceMemoryProperties,
}
impl PhysicalDeviceMemoryProperties {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> PhysicalDeviceMemoryPropertiesBuilder {
        PhysicalDeviceMemoryPropertiesBuilder {
            inner: PhysicalDeviceMemoryProperties {
                ..Default::default()
            },
        }
    }
}
impl PhysicalDeviceMemoryPropertiesBuilder {
    #[inline]
    pub fn memory_type_count(mut self, value: u32) -> Self {
        self.inner.memory_type_count = value;
        self
    }
    #[inline]
    pub fn memory_types(
        mut self,
        value: [MemoryType; MAX_MEMORY_TYPES as usize],
    ) -> Self {
        self.inner.memory_types = value;
        self
    }
    #[inline]
    pub fn memory_heap_count(mut self, value: u32) -> Self {
        self.inner.memory_heap_count = value;
        self
    }
    #[inline]
    pub fn memory_heaps(
        mut self,
        value: [MemoryHeap; MAX_MEMORY_HEAPS as usize],
    ) -> Self {
        self.inner.memory_heaps = value;
        self
    }
}
impl core::ops::Deref for PhysicalDeviceMemoryPropertiesBuilder {
    type Target = PhysicalDeviceMemoryProperties;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for PhysicalDeviceMemoryPropertiesBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`MemoryAllocateInfo`] with lifetime-tied pNext safety.
pub struct MemoryAllocateInfoBuilder<'a> {
    inner: MemoryAllocateInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl MemoryAllocateInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> MemoryAllocateInfoBuilder<'a> {
        MemoryAllocateInfoBuilder {
            inner: MemoryAllocateInfo {
                s_type: StructureType::from_raw(5i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> MemoryAllocateInfoBuilder<'a> {
    #[inline]
    pub fn allocation_size(mut self, value: u64) -> Self {
        self.inner.allocation_size = value;
        self
    }
    #[inline]
    pub fn memory_type_index(mut self, value: u32) -> Self {
        self.inner.memory_type_index = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`MemoryAllocateInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsMemoryAllocateInfo>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for MemoryAllocateInfoBuilder<'a> {
    type Target = MemoryAllocateInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for MemoryAllocateInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`MemoryRequirements`].
pub struct MemoryRequirementsBuilder {
    inner: MemoryRequirements,
}
impl MemoryRequirements {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> MemoryRequirementsBuilder {
        MemoryRequirementsBuilder {
            inner: MemoryRequirements {
                ..Default::default()
            },
        }
    }
}
impl MemoryRequirementsBuilder {
    #[inline]
    pub fn size(mut self, value: u64) -> Self {
        self.inner.size = value;
        self
    }
    #[inline]
    pub fn alignment(mut self, value: u64) -> Self {
        self.inner.alignment = value;
        self
    }
    #[inline]
    pub fn memory_type_bits(mut self, value: u32) -> Self {
        self.inner.memory_type_bits = value;
        self
    }
}
impl core::ops::Deref for MemoryRequirementsBuilder {
    type Target = MemoryRequirements;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for MemoryRequirementsBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`SparseImageFormatProperties`].
pub struct SparseImageFormatPropertiesBuilder {
    inner: SparseImageFormatProperties,
}
impl SparseImageFormatProperties {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> SparseImageFormatPropertiesBuilder {
        SparseImageFormatPropertiesBuilder {
            inner: SparseImageFormatProperties {
                ..Default::default()
            },
        }
    }
}
impl SparseImageFormatPropertiesBuilder {
    #[inline]
    pub fn aspect_mask(mut self, value: ImageAspectFlags) -> Self {
        self.inner.aspect_mask = value;
        self
    }
    #[inline]
    pub fn image_granularity(mut self, value: Extent3D) -> Self {
        self.inner.image_granularity = value;
        self
    }
    #[inline]
    pub fn flags(mut self, value: SparseImageFormatFlags) -> Self {
        self.inner.flags = value;
        self
    }
}
impl core::ops::Deref for SparseImageFormatPropertiesBuilder {
    type Target = SparseImageFormatProperties;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for SparseImageFormatPropertiesBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`SparseImageMemoryRequirements`].
pub struct SparseImageMemoryRequirementsBuilder {
    inner: SparseImageMemoryRequirements,
}
impl SparseImageMemoryRequirements {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> SparseImageMemoryRequirementsBuilder {
        SparseImageMemoryRequirementsBuilder {
            inner: SparseImageMemoryRequirements {
                ..Default::default()
            },
        }
    }
}
impl SparseImageMemoryRequirementsBuilder {
    #[inline]
    pub fn format_properties(mut self, value: SparseImageFormatProperties) -> Self {
        self.inner.format_properties = value;
        self
    }
    #[inline]
    pub fn image_mip_tail_first_lod(mut self, value: u32) -> Self {
        self.inner.image_mip_tail_first_lod = value;
        self
    }
    #[inline]
    pub fn image_mip_tail_size(mut self, value: u64) -> Self {
        self.inner.image_mip_tail_size = value;
        self
    }
    #[inline]
    pub fn image_mip_tail_offset(mut self, value: u64) -> Self {
        self.inner.image_mip_tail_offset = value;
        self
    }
    #[inline]
    pub fn image_mip_tail_stride(mut self, value: u64) -> Self {
        self.inner.image_mip_tail_stride = value;
        self
    }
}
impl core::ops::Deref for SparseImageMemoryRequirementsBuilder {
    type Target = SparseImageMemoryRequirements;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for SparseImageMemoryRequirementsBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`MemoryType`].
pub struct MemoryTypeBuilder {
    inner: MemoryType,
}
impl MemoryType {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> MemoryTypeBuilder {
        MemoryTypeBuilder {
            inner: MemoryType { ..Default::default() },
        }
    }
}
impl MemoryTypeBuilder {
    #[inline]
    pub fn property_flags(mut self, value: MemoryPropertyFlags) -> Self {
        self.inner.property_flags = value;
        self
    }
    #[inline]
    pub fn heap_index(mut self, value: u32) -> Self {
        self.inner.heap_index = value;
        self
    }
}
impl core::ops::Deref for MemoryTypeBuilder {
    type Target = MemoryType;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for MemoryTypeBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`MemoryHeap`].
pub struct MemoryHeapBuilder {
    inner: MemoryHeap,
}
impl MemoryHeap {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> MemoryHeapBuilder {
        MemoryHeapBuilder {
            inner: MemoryHeap { ..Default::default() },
        }
    }
}
impl MemoryHeapBuilder {
    #[inline]
    pub fn size(mut self, value: u64) -> Self {
        self.inner.size = value;
        self
    }
    #[inline]
    pub fn flags(mut self, value: MemoryHeapFlags) -> Self {
        self.inner.flags = value;
        self
    }
}
impl core::ops::Deref for MemoryHeapBuilder {
    type Target = MemoryHeap;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for MemoryHeapBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`MappedMemoryRange`] with lifetime-tied pNext safety.
pub struct MappedMemoryRangeBuilder<'a> {
    inner: MappedMemoryRange,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl MappedMemoryRange {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> MappedMemoryRangeBuilder<'a> {
        MappedMemoryRangeBuilder {
            inner: MappedMemoryRange {
                s_type: StructureType::from_raw(6i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> MappedMemoryRangeBuilder<'a> {
    #[inline]
    pub fn memory(mut self, value: DeviceMemory) -> Self {
        self.inner.memory = value;
        self
    }
    #[inline]
    pub fn offset(mut self, value: u64) -> Self {
        self.inner.offset = value;
        self
    }
    #[inline]
    pub fn size(mut self, value: u64) -> Self {
        self.inner.size = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`MappedMemoryRange`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsMappedMemoryRange>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for MappedMemoryRangeBuilder<'a> {
    type Target = MappedMemoryRange;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for MappedMemoryRangeBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`FormatProperties`].
pub struct FormatPropertiesBuilder {
    inner: FormatProperties,
}
impl FormatProperties {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> FormatPropertiesBuilder {
        FormatPropertiesBuilder {
            inner: FormatProperties {
                ..Default::default()
            },
        }
    }
}
impl FormatPropertiesBuilder {
    #[inline]
    pub fn linear_tiling_features(mut self, value: FormatFeatureFlags) -> Self {
        self.inner.linear_tiling_features = value;
        self
    }
    #[inline]
    pub fn optimal_tiling_features(mut self, value: FormatFeatureFlags) -> Self {
        self.inner.optimal_tiling_features = value;
        self
    }
    #[inline]
    pub fn buffer_features(mut self, value: FormatFeatureFlags) -> Self {
        self.inner.buffer_features = value;
        self
    }
}
impl core::ops::Deref for FormatPropertiesBuilder {
    type Target = FormatProperties;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for FormatPropertiesBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ImageFormatProperties`].
pub struct ImageFormatPropertiesBuilder {
    inner: ImageFormatProperties,
}
impl ImageFormatProperties {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> ImageFormatPropertiesBuilder {
        ImageFormatPropertiesBuilder {
            inner: ImageFormatProperties {
                ..Default::default()
            },
        }
    }
}
impl ImageFormatPropertiesBuilder {
    #[inline]
    pub fn max_extent(mut self, value: Extent3D) -> Self {
        self.inner.max_extent = value;
        self
    }
    #[inline]
    pub fn max_mip_levels(mut self, value: u32) -> Self {
        self.inner.max_mip_levels = value;
        self
    }
    #[inline]
    pub fn max_array_layers(mut self, value: u32) -> Self {
        self.inner.max_array_layers = value;
        self
    }
    #[inline]
    pub fn sample_counts(mut self, value: SampleCountFlags) -> Self {
        self.inner.sample_counts = value;
        self
    }
    #[inline]
    pub fn max_resource_size(mut self, value: u64) -> Self {
        self.inner.max_resource_size = value;
        self
    }
}
impl core::ops::Deref for ImageFormatPropertiesBuilder {
    type Target = ImageFormatProperties;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for ImageFormatPropertiesBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DescriptorBufferInfo`].
pub struct DescriptorBufferInfoBuilder {
    inner: DescriptorBufferInfo,
}
impl DescriptorBufferInfo {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> DescriptorBufferInfoBuilder {
        DescriptorBufferInfoBuilder {
            inner: DescriptorBufferInfo {
                ..Default::default()
            },
        }
    }
}
impl DescriptorBufferInfoBuilder {
    #[inline]
    pub fn buffer(mut self, value: Buffer) -> Self {
        self.inner.buffer = value;
        self
    }
    #[inline]
    pub fn offset(mut self, value: u64) -> Self {
        self.inner.offset = value;
        self
    }
    #[inline]
    pub fn range(mut self, value: u64) -> Self {
        self.inner.range = value;
        self
    }
}
impl core::ops::Deref for DescriptorBufferInfoBuilder {
    type Target = DescriptorBufferInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for DescriptorBufferInfoBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DescriptorImageInfo`].
pub struct DescriptorImageInfoBuilder {
    inner: DescriptorImageInfo,
}
impl DescriptorImageInfo {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> DescriptorImageInfoBuilder {
        DescriptorImageInfoBuilder {
            inner: DescriptorImageInfo {
                ..Default::default()
            },
        }
    }
}
impl DescriptorImageInfoBuilder {
    #[inline]
    pub fn sampler(mut self, value: Sampler) -> Self {
        self.inner.sampler = value;
        self
    }
    #[inline]
    pub fn image_view(mut self, value: ImageView) -> Self {
        self.inner.image_view = value;
        self
    }
    #[inline]
    pub fn image_layout(mut self, value: ImageLayout) -> Self {
        self.inner.image_layout = value;
        self
    }
}
impl core::ops::Deref for DescriptorImageInfoBuilder {
    type Target = DescriptorImageInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for DescriptorImageInfoBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`WriteDescriptorSet`] with lifetime-tied pNext safety.
pub struct WriteDescriptorSetBuilder<'a> {
    inner: WriteDescriptorSet,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl WriteDescriptorSet {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> WriteDescriptorSetBuilder<'a> {
        WriteDescriptorSetBuilder {
            inner: WriteDescriptorSet {
                s_type: StructureType::from_raw(35i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> WriteDescriptorSetBuilder<'a> {
    #[inline]
    pub fn dst_set(mut self, value: DescriptorSet) -> Self {
        self.inner.dst_set = value;
        self
    }
    #[inline]
    pub fn dst_binding(mut self, value: u32) -> Self {
        self.inner.dst_binding = value;
        self
    }
    #[inline]
    pub fn dst_array_element(mut self, value: u32) -> Self {
        self.inner.dst_array_element = value;
        self
    }
    #[inline]
    pub fn descriptor_type(mut self, value: DescriptorType) -> Self {
        self.inner.descriptor_type = value;
        self
    }
    #[inline]
    pub fn image_info(mut self, slice: &'a [DescriptorImageInfo]) -> Self {
        self.inner.descriptor_count = slice.len() as u32;
        self.inner.p_image_info = slice.as_ptr();
        self
    }
    #[inline]
    pub fn buffer_info(mut self, slice: &'a [DescriptorBufferInfo]) -> Self {
        self.inner.descriptor_count = slice.len() as u32;
        self.inner.p_buffer_info = slice.as_ptr();
        self
    }
    #[inline]
    pub fn texel_buffer_view(mut self, slice: &'a [BufferView]) -> Self {
        self.inner.descriptor_count = slice.len() as u32;
        self.inner.p_texel_buffer_view = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`WriteDescriptorSet`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsWriteDescriptorSet>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for WriteDescriptorSetBuilder<'a> {
    type Target = WriteDescriptorSet;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for WriteDescriptorSetBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`CopyDescriptorSet`] with lifetime-tied pNext safety.
pub struct CopyDescriptorSetBuilder<'a> {
    inner: CopyDescriptorSet,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl CopyDescriptorSet {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> CopyDescriptorSetBuilder<'a> {
        CopyDescriptorSetBuilder {
            inner: CopyDescriptorSet {
                s_type: StructureType::from_raw(36i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> CopyDescriptorSetBuilder<'a> {
    #[inline]
    pub fn src_set(mut self, value: DescriptorSet) -> Self {
        self.inner.src_set = value;
        self
    }
    #[inline]
    pub fn src_binding(mut self, value: u32) -> Self {
        self.inner.src_binding = value;
        self
    }
    #[inline]
    pub fn src_array_element(mut self, value: u32) -> Self {
        self.inner.src_array_element = value;
        self
    }
    #[inline]
    pub fn dst_set(mut self, value: DescriptorSet) -> Self {
        self.inner.dst_set = value;
        self
    }
    #[inline]
    pub fn dst_binding(mut self, value: u32) -> Self {
        self.inner.dst_binding = value;
        self
    }
    #[inline]
    pub fn dst_array_element(mut self, value: u32) -> Self {
        self.inner.dst_array_element = value;
        self
    }
    #[inline]
    pub fn descriptor_count(mut self, value: u32) -> Self {
        self.inner.descriptor_count = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`CopyDescriptorSet`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsCopyDescriptorSet>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for CopyDescriptorSetBuilder<'a> {
    type Target = CopyDescriptorSet;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for CopyDescriptorSetBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`BufferUsageFlags2CreateInfo`] with lifetime-tied pNext safety.
pub struct BufferUsageFlags2CreateInfoBuilder<'a> {
    inner: BufferUsageFlags2CreateInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl BufferUsageFlags2CreateInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> BufferUsageFlags2CreateInfoBuilder<'a> {
        BufferUsageFlags2CreateInfoBuilder {
            inner: BufferUsageFlags2CreateInfo {
                s_type: StructureType::from_raw(1000470006i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> BufferUsageFlags2CreateInfoBuilder<'a> {
    #[inline]
    pub fn usage(mut self, value: BufferUsageFlags2) -> Self {
        self.inner.usage = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`BufferUsageFlags2CreateInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsBufferUsageFlags2CreateInfo>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for BufferUsageFlags2CreateInfoBuilder<'a> {
    type Target = BufferUsageFlags2CreateInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for BufferUsageFlags2CreateInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`BufferCreateInfo`] with lifetime-tied pNext safety.
pub struct BufferCreateInfoBuilder<'a> {
    inner: BufferCreateInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl BufferCreateInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> BufferCreateInfoBuilder<'a> {
        BufferCreateInfoBuilder {
            inner: BufferCreateInfo {
                s_type: StructureType::from_raw(12i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> BufferCreateInfoBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: BufferCreateFlags) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn size(mut self, value: u64) -> Self {
        self.inner.size = value;
        self
    }
    #[inline]
    pub fn usage(mut self, value: BufferUsageFlags) -> Self {
        self.inner.usage = value;
        self
    }
    #[inline]
    pub fn sharing_mode(mut self, value: SharingMode) -> Self {
        self.inner.sharing_mode = value;
        self
    }
    #[inline]
    pub fn queue_family_indices(mut self, slice: &'a [u32]) -> Self {
        self.inner.queue_family_index_count = slice.len() as u32;
        self.inner.p_queue_family_indices = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`BufferCreateInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsBufferCreateInfo>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for BufferCreateInfoBuilder<'a> {
    type Target = BufferCreateInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for BufferCreateInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`BufferViewCreateInfo`] with lifetime-tied pNext safety.
pub struct BufferViewCreateInfoBuilder<'a> {
    inner: BufferViewCreateInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl BufferViewCreateInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> BufferViewCreateInfoBuilder<'a> {
        BufferViewCreateInfoBuilder {
            inner: BufferViewCreateInfo {
                s_type: StructureType::from_raw(13i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> BufferViewCreateInfoBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: BufferViewCreateFlags) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn buffer(mut self, value: Buffer) -> Self {
        self.inner.buffer = value;
        self
    }
    #[inline]
    pub fn format(mut self, value: Format) -> Self {
        self.inner.format = value;
        self
    }
    #[inline]
    pub fn offset(mut self, value: u64) -> Self {
        self.inner.offset = value;
        self
    }
    #[inline]
    pub fn range(mut self, value: u64) -> Self {
        self.inner.range = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`BufferViewCreateInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsBufferViewCreateInfo>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for BufferViewCreateInfoBuilder<'a> {
    type Target = BufferViewCreateInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for BufferViewCreateInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ImageSubresource`].
pub struct ImageSubresourceBuilder {
    inner: ImageSubresource,
}
impl ImageSubresource {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> ImageSubresourceBuilder {
        ImageSubresourceBuilder {
            inner: ImageSubresource {
                ..Default::default()
            },
        }
    }
}
impl ImageSubresourceBuilder {
    #[inline]
    pub fn aspect_mask(mut self, value: ImageAspectFlags) -> Self {
        self.inner.aspect_mask = value;
        self
    }
    #[inline]
    pub fn mip_level(mut self, value: u32) -> Self {
        self.inner.mip_level = value;
        self
    }
    #[inline]
    pub fn array_layer(mut self, value: u32) -> Self {
        self.inner.array_layer = value;
        self
    }
}
impl core::ops::Deref for ImageSubresourceBuilder {
    type Target = ImageSubresource;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for ImageSubresourceBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ImageSubresourceLayers`].
pub struct ImageSubresourceLayersBuilder {
    inner: ImageSubresourceLayers,
}
impl ImageSubresourceLayers {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> ImageSubresourceLayersBuilder {
        ImageSubresourceLayersBuilder {
            inner: ImageSubresourceLayers {
                ..Default::default()
            },
        }
    }
}
impl ImageSubresourceLayersBuilder {
    #[inline]
    pub fn aspect_mask(mut self, value: ImageAspectFlags) -> Self {
        self.inner.aspect_mask = value;
        self
    }
    #[inline]
    pub fn mip_level(mut self, value: u32) -> Self {
        self.inner.mip_level = value;
        self
    }
    #[inline]
    pub fn base_array_layer(mut self, value: u32) -> Self {
        self.inner.base_array_layer = value;
        self
    }
    #[inline]
    pub fn layer_count(mut self, value: u32) -> Self {
        self.inner.layer_count = value;
        self
    }
}
impl core::ops::Deref for ImageSubresourceLayersBuilder {
    type Target = ImageSubresourceLayers;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for ImageSubresourceLayersBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ImageSubresourceRange`].
pub struct ImageSubresourceRangeBuilder {
    inner: ImageSubresourceRange,
}
impl ImageSubresourceRange {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> ImageSubresourceRangeBuilder {
        ImageSubresourceRangeBuilder {
            inner: ImageSubresourceRange {
                ..Default::default()
            },
        }
    }
}
impl ImageSubresourceRangeBuilder {
    #[inline]
    pub fn aspect_mask(mut self, value: ImageAspectFlags) -> Self {
        self.inner.aspect_mask = value;
        self
    }
    #[inline]
    pub fn base_mip_level(mut self, value: u32) -> Self {
        self.inner.base_mip_level = value;
        self
    }
    #[inline]
    pub fn level_count(mut self, value: u32) -> Self {
        self.inner.level_count = value;
        self
    }
    #[inline]
    pub fn base_array_layer(mut self, value: u32) -> Self {
        self.inner.base_array_layer = value;
        self
    }
    #[inline]
    pub fn layer_count(mut self, value: u32) -> Self {
        self.inner.layer_count = value;
        self
    }
}
impl core::ops::Deref for ImageSubresourceRangeBuilder {
    type Target = ImageSubresourceRange;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for ImageSubresourceRangeBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`MemoryBarrier`] with lifetime-tied pNext safety.
pub struct MemoryBarrierBuilder<'a> {
    inner: MemoryBarrier,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl MemoryBarrier {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> MemoryBarrierBuilder<'a> {
        MemoryBarrierBuilder {
            inner: MemoryBarrier {
                s_type: StructureType::from_raw(46i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> MemoryBarrierBuilder<'a> {
    #[inline]
    pub fn src_access_mask(mut self, value: AccessFlags) -> Self {
        self.inner.src_access_mask = value;
        self
    }
    #[inline]
    pub fn dst_access_mask(mut self, value: AccessFlags) -> Self {
        self.inner.dst_access_mask = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`MemoryBarrier`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsMemoryBarrier>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for MemoryBarrierBuilder<'a> {
    type Target = MemoryBarrier;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for MemoryBarrierBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`BufferMemoryBarrier`] with lifetime-tied pNext safety.
pub struct BufferMemoryBarrierBuilder<'a> {
    inner: BufferMemoryBarrier,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl BufferMemoryBarrier {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> BufferMemoryBarrierBuilder<'a> {
        BufferMemoryBarrierBuilder {
            inner: BufferMemoryBarrier {
                s_type: StructureType::from_raw(44i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> BufferMemoryBarrierBuilder<'a> {
    #[inline]
    pub fn src_access_mask(mut self, value: AccessFlags) -> Self {
        self.inner.src_access_mask = value;
        self
    }
    #[inline]
    pub fn dst_access_mask(mut self, value: AccessFlags) -> Self {
        self.inner.dst_access_mask = value;
        self
    }
    #[inline]
    pub fn src_queue_family_index(mut self, value: u32) -> Self {
        self.inner.src_queue_family_index = value;
        self
    }
    #[inline]
    pub fn dst_queue_family_index(mut self, value: u32) -> Self {
        self.inner.dst_queue_family_index = value;
        self
    }
    #[inline]
    pub fn buffer(mut self, value: Buffer) -> Self {
        self.inner.buffer = value;
        self
    }
    #[inline]
    pub fn offset(mut self, value: u64) -> Self {
        self.inner.offset = value;
        self
    }
    #[inline]
    pub fn size(mut self, value: u64) -> Self {
        self.inner.size = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`BufferMemoryBarrier`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsBufferMemoryBarrier>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for BufferMemoryBarrierBuilder<'a> {
    type Target = BufferMemoryBarrier;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for BufferMemoryBarrierBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ImageMemoryBarrier`] with lifetime-tied pNext safety.
pub struct ImageMemoryBarrierBuilder<'a> {
    inner: ImageMemoryBarrier,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ImageMemoryBarrier {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ImageMemoryBarrierBuilder<'a> {
        ImageMemoryBarrierBuilder {
            inner: ImageMemoryBarrier {
                s_type: StructureType::from_raw(45i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ImageMemoryBarrierBuilder<'a> {
    #[inline]
    pub fn src_access_mask(mut self, value: AccessFlags) -> Self {
        self.inner.src_access_mask = value;
        self
    }
    #[inline]
    pub fn dst_access_mask(mut self, value: AccessFlags) -> Self {
        self.inner.dst_access_mask = value;
        self
    }
    #[inline]
    pub fn old_layout(mut self, value: ImageLayout) -> Self {
        self.inner.old_layout = value;
        self
    }
    #[inline]
    pub fn new_layout(mut self, value: ImageLayout) -> Self {
        self.inner.new_layout = value;
        self
    }
    #[inline]
    pub fn src_queue_family_index(mut self, value: u32) -> Self {
        self.inner.src_queue_family_index = value;
        self
    }
    #[inline]
    pub fn dst_queue_family_index(mut self, value: u32) -> Self {
        self.inner.dst_queue_family_index = value;
        self
    }
    #[inline]
    pub fn image(mut self, value: Image) -> Self {
        self.inner.image = value;
        self
    }
    #[inline]
    pub fn subresource_range(mut self, value: ImageSubresourceRange) -> Self {
        self.inner.subresource_range = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`ImageMemoryBarrier`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsImageMemoryBarrier>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for ImageMemoryBarrierBuilder<'a> {
    type Target = ImageMemoryBarrier;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ImageMemoryBarrierBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ImageCreateInfo`] with lifetime-tied pNext safety.
pub struct ImageCreateInfoBuilder<'a> {
    inner: ImageCreateInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ImageCreateInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ImageCreateInfoBuilder<'a> {
        ImageCreateInfoBuilder {
            inner: ImageCreateInfo {
                s_type: StructureType::from_raw(14i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ImageCreateInfoBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: ImageCreateFlags) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn image_type(mut self, value: ImageType) -> Self {
        self.inner.image_type = value;
        self
    }
    #[inline]
    pub fn format(mut self, value: Format) -> Self {
        self.inner.format = value;
        self
    }
    #[inline]
    pub fn extent(mut self, value: Extent3D) -> Self {
        self.inner.extent = value;
        self
    }
    #[inline]
    pub fn mip_levels(mut self, value: u32) -> Self {
        self.inner.mip_levels = value;
        self
    }
    #[inline]
    pub fn array_layers(mut self, value: u32) -> Self {
        self.inner.array_layers = value;
        self
    }
    #[inline]
    pub fn samples(mut self, value: SampleCountFlagBits) -> Self {
        self.inner.samples = value;
        self
    }
    #[inline]
    pub fn tiling(mut self, value: ImageTiling) -> Self {
        self.inner.tiling = value;
        self
    }
    #[inline]
    pub fn usage(mut self, value: ImageUsageFlags) -> Self {
        self.inner.usage = value;
        self
    }
    #[inline]
    pub fn sharing_mode(mut self, value: SharingMode) -> Self {
        self.inner.sharing_mode = value;
        self
    }
    #[inline]
    pub fn queue_family_indices(mut self, slice: &'a [u32]) -> Self {
        self.inner.queue_family_index_count = slice.len() as u32;
        self.inner.p_queue_family_indices = slice.as_ptr();
        self
    }
    #[inline]
    pub fn initial_layout(mut self, value: ImageLayout) -> Self {
        self.inner.initial_layout = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`ImageCreateInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsImageCreateInfo>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for ImageCreateInfoBuilder<'a> {
    type Target = ImageCreateInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ImageCreateInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`SubresourceLayout`].
pub struct SubresourceLayoutBuilder {
    inner: SubresourceLayout,
}
impl SubresourceLayout {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> SubresourceLayoutBuilder {
        SubresourceLayoutBuilder {
            inner: SubresourceLayout {
                ..Default::default()
            },
        }
    }
}
impl SubresourceLayoutBuilder {
    #[inline]
    pub fn offset(mut self, value: u64) -> Self {
        self.inner.offset = value;
        self
    }
    #[inline]
    pub fn size(mut self, value: u64) -> Self {
        self.inner.size = value;
        self
    }
    #[inline]
    pub fn row_pitch(mut self, value: u64) -> Self {
        self.inner.row_pitch = value;
        self
    }
    #[inline]
    pub fn array_pitch(mut self, value: u64) -> Self {
        self.inner.array_pitch = value;
        self
    }
    #[inline]
    pub fn depth_pitch(mut self, value: u64) -> Self {
        self.inner.depth_pitch = value;
        self
    }
}
impl core::ops::Deref for SubresourceLayoutBuilder {
    type Target = SubresourceLayout;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for SubresourceLayoutBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ImageViewCreateInfo`] with lifetime-tied pNext safety.
pub struct ImageViewCreateInfoBuilder<'a> {
    inner: ImageViewCreateInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ImageViewCreateInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ImageViewCreateInfoBuilder<'a> {
        ImageViewCreateInfoBuilder {
            inner: ImageViewCreateInfo {
                s_type: StructureType::from_raw(15i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ImageViewCreateInfoBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: ImageViewCreateFlags) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn image(mut self, value: Image) -> Self {
        self.inner.image = value;
        self
    }
    #[inline]
    pub fn view_type(mut self, value: ImageViewType) -> Self {
        self.inner.view_type = value;
        self
    }
    #[inline]
    pub fn format(mut self, value: Format) -> Self {
        self.inner.format = value;
        self
    }
    #[inline]
    pub fn components(mut self, value: ComponentMapping) -> Self {
        self.inner.components = value;
        self
    }
    #[inline]
    pub fn subresource_range(mut self, value: ImageSubresourceRange) -> Self {
        self.inner.subresource_range = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`ImageViewCreateInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsImageViewCreateInfo>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for ImageViewCreateInfoBuilder<'a> {
    type Target = ImageViewCreateInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ImageViewCreateInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`BufferCopy`].
pub struct BufferCopyBuilder {
    inner: BufferCopy,
}
impl BufferCopy {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> BufferCopyBuilder {
        BufferCopyBuilder {
            inner: BufferCopy { ..Default::default() },
        }
    }
}
impl BufferCopyBuilder {
    #[inline]
    pub fn src_offset(mut self, value: u64) -> Self {
        self.inner.src_offset = value;
        self
    }
    #[inline]
    pub fn dst_offset(mut self, value: u64) -> Self {
        self.inner.dst_offset = value;
        self
    }
    #[inline]
    pub fn size(mut self, value: u64) -> Self {
        self.inner.size = value;
        self
    }
}
impl core::ops::Deref for BufferCopyBuilder {
    type Target = BufferCopy;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for BufferCopyBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`SparseMemoryBind`].
pub struct SparseMemoryBindBuilder {
    inner: SparseMemoryBind,
}
impl SparseMemoryBind {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> SparseMemoryBindBuilder {
        SparseMemoryBindBuilder {
            inner: SparseMemoryBind {
                ..Default::default()
            },
        }
    }
}
impl SparseMemoryBindBuilder {
    #[inline]
    pub fn resource_offset(mut self, value: u64) -> Self {
        self.inner.resource_offset = value;
        self
    }
    #[inline]
    pub fn size(mut self, value: u64) -> Self {
        self.inner.size = value;
        self
    }
    #[inline]
    pub fn memory(mut self, value: DeviceMemory) -> Self {
        self.inner.memory = value;
        self
    }
    #[inline]
    pub fn memory_offset(mut self, value: u64) -> Self {
        self.inner.memory_offset = value;
        self
    }
    #[inline]
    pub fn flags(mut self, value: SparseMemoryBindFlags) -> Self {
        self.inner.flags = value;
        self
    }
}
impl core::ops::Deref for SparseMemoryBindBuilder {
    type Target = SparseMemoryBind;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for SparseMemoryBindBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`SparseImageMemoryBind`].
pub struct SparseImageMemoryBindBuilder {
    inner: SparseImageMemoryBind,
}
impl SparseImageMemoryBind {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> SparseImageMemoryBindBuilder {
        SparseImageMemoryBindBuilder {
            inner: SparseImageMemoryBind {
                ..Default::default()
            },
        }
    }
}
impl SparseImageMemoryBindBuilder {
    #[inline]
    pub fn subresource(mut self, value: ImageSubresource) -> Self {
        self.inner.subresource = value;
        self
    }
    #[inline]
    pub fn offset(mut self, value: Offset3D) -> Self {
        self.inner.offset = value;
        self
    }
    #[inline]
    pub fn extent(mut self, value: Extent3D) -> Self {
        self.inner.extent = value;
        self
    }
    #[inline]
    pub fn memory(mut self, value: DeviceMemory) -> Self {
        self.inner.memory = value;
        self
    }
    #[inline]
    pub fn memory_offset(mut self, value: u64) -> Self {
        self.inner.memory_offset = value;
        self
    }
    #[inline]
    pub fn flags(mut self, value: SparseMemoryBindFlags) -> Self {
        self.inner.flags = value;
        self
    }
}
impl core::ops::Deref for SparseImageMemoryBindBuilder {
    type Target = SparseImageMemoryBind;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for SparseImageMemoryBindBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`SparseBufferMemoryBindInfo`].
pub struct SparseBufferMemoryBindInfoBuilder<'a> {
    inner: SparseBufferMemoryBindInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl SparseBufferMemoryBindInfo {
    /// Start building this struct.
    #[inline]
    pub fn builder<'a>() -> SparseBufferMemoryBindInfoBuilder<'a> {
        SparseBufferMemoryBindInfoBuilder {
            inner: SparseBufferMemoryBindInfo {
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> SparseBufferMemoryBindInfoBuilder<'a> {
    #[inline]
    pub fn buffer(mut self, value: Buffer) -> Self {
        self.inner.buffer = value;
        self
    }
    #[inline]
    pub fn binds(mut self, slice: &'a [SparseMemoryBind]) -> Self {
        self.inner.bind_count = slice.len() as u32;
        self.inner.p_binds = slice.as_ptr();
        self
    }
}
impl<'a> core::ops::Deref for SparseBufferMemoryBindInfoBuilder<'a> {
    type Target = SparseBufferMemoryBindInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for SparseBufferMemoryBindInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`SparseImageOpaqueMemoryBindInfo`].
pub struct SparseImageOpaqueMemoryBindInfoBuilder<'a> {
    inner: SparseImageOpaqueMemoryBindInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl SparseImageOpaqueMemoryBindInfo {
    /// Start building this struct.
    #[inline]
    pub fn builder<'a>() -> SparseImageOpaqueMemoryBindInfoBuilder<'a> {
        SparseImageOpaqueMemoryBindInfoBuilder {
            inner: SparseImageOpaqueMemoryBindInfo {
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> SparseImageOpaqueMemoryBindInfoBuilder<'a> {
    #[inline]
    pub fn image(mut self, value: Image) -> Self {
        self.inner.image = value;
        self
    }
    #[inline]
    pub fn binds(mut self, slice: &'a [SparseMemoryBind]) -> Self {
        self.inner.bind_count = slice.len() as u32;
        self.inner.p_binds = slice.as_ptr();
        self
    }
}
impl<'a> core::ops::Deref for SparseImageOpaqueMemoryBindInfoBuilder<'a> {
    type Target = SparseImageOpaqueMemoryBindInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for SparseImageOpaqueMemoryBindInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`SparseImageMemoryBindInfo`].
pub struct SparseImageMemoryBindInfoBuilder<'a> {
    inner: SparseImageMemoryBindInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl SparseImageMemoryBindInfo {
    /// Start building this struct.
    #[inline]
    pub fn builder<'a>() -> SparseImageMemoryBindInfoBuilder<'a> {
        SparseImageMemoryBindInfoBuilder {
            inner: SparseImageMemoryBindInfo {
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> SparseImageMemoryBindInfoBuilder<'a> {
    #[inline]
    pub fn image(mut self, value: Image) -> Self {
        self.inner.image = value;
        self
    }
    #[inline]
    pub fn binds(mut self, slice: &'a [SparseImageMemoryBind]) -> Self {
        self.inner.bind_count = slice.len() as u32;
        self.inner.p_binds = slice.as_ptr();
        self
    }
}
impl<'a> core::ops::Deref for SparseImageMemoryBindInfoBuilder<'a> {
    type Target = SparseImageMemoryBindInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for SparseImageMemoryBindInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`BindSparseInfo`] with lifetime-tied pNext safety.
pub struct BindSparseInfoBuilder<'a> {
    inner: BindSparseInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl BindSparseInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> BindSparseInfoBuilder<'a> {
        BindSparseInfoBuilder {
            inner: BindSparseInfo {
                s_type: StructureType::from_raw(7i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> BindSparseInfoBuilder<'a> {
    #[inline]
    pub fn wait_semaphores(mut self, slice: &'a [Semaphore]) -> Self {
        self.inner.wait_semaphore_count = slice.len() as u32;
        self.inner.p_wait_semaphores = slice.as_ptr();
        self
    }
    #[inline]
    pub fn buffer_binds(mut self, slice: &'a [SparseBufferMemoryBindInfo]) -> Self {
        self.inner.buffer_bind_count = slice.len() as u32;
        self.inner.p_buffer_binds = slice.as_ptr();
        self
    }
    #[inline]
    pub fn image_opaque_binds(
        mut self,
        slice: &'a [SparseImageOpaqueMemoryBindInfo],
    ) -> Self {
        self.inner.image_opaque_bind_count = slice.len() as u32;
        self.inner.p_image_opaque_binds = slice.as_ptr();
        self
    }
    #[inline]
    pub fn image_binds(mut self, slice: &'a [SparseImageMemoryBindInfo]) -> Self {
        self.inner.image_bind_count = slice.len() as u32;
        self.inner.p_image_binds = slice.as_ptr();
        self
    }
    #[inline]
    pub fn signal_semaphores(mut self, slice: &'a [Semaphore]) -> Self {
        self.inner.signal_semaphore_count = slice.len() as u32;
        self.inner.p_signal_semaphores = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`BindSparseInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsBindSparseInfo>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for BindSparseInfoBuilder<'a> {
    type Target = BindSparseInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for BindSparseInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ImageCopy`].
pub struct ImageCopyBuilder {
    inner: ImageCopy,
}
impl ImageCopy {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> ImageCopyBuilder {
        ImageCopyBuilder {
            inner: ImageCopy { ..Default::default() },
        }
    }
}
impl ImageCopyBuilder {
    #[inline]
    pub fn src_subresource(mut self, value: ImageSubresourceLayers) -> Self {
        self.inner.src_subresource = value;
        self
    }
    #[inline]
    pub fn src_offset(mut self, value: Offset3D) -> Self {
        self.inner.src_offset = value;
        self
    }
    #[inline]
    pub fn dst_subresource(mut self, value: ImageSubresourceLayers) -> Self {
        self.inner.dst_subresource = value;
        self
    }
    #[inline]
    pub fn dst_offset(mut self, value: Offset3D) -> Self {
        self.inner.dst_offset = value;
        self
    }
    #[inline]
    pub fn extent(mut self, value: Extent3D) -> Self {
        self.inner.extent = value;
        self
    }
}
impl core::ops::Deref for ImageCopyBuilder {
    type Target = ImageCopy;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for ImageCopyBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ImageBlit`].
pub struct ImageBlitBuilder {
    inner: ImageBlit,
}
impl ImageBlit {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> ImageBlitBuilder {
        ImageBlitBuilder {
            inner: ImageBlit { ..Default::default() },
        }
    }
}
impl ImageBlitBuilder {
    #[inline]
    pub fn src_subresource(mut self, value: ImageSubresourceLayers) -> Self {
        self.inner.src_subresource = value;
        self
    }
    #[inline]
    pub fn src_offsets(mut self, value: [Offset3D; 2usize]) -> Self {
        self.inner.src_offsets = value;
        self
    }
    #[inline]
    pub fn dst_subresource(mut self, value: ImageSubresourceLayers) -> Self {
        self.inner.dst_subresource = value;
        self
    }
    #[inline]
    pub fn dst_offsets(mut self, value: [Offset3D; 2usize]) -> Self {
        self.inner.dst_offsets = value;
        self
    }
}
impl core::ops::Deref for ImageBlitBuilder {
    type Target = ImageBlit;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for ImageBlitBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`BufferImageCopy`].
pub struct BufferImageCopyBuilder {
    inner: BufferImageCopy,
}
impl BufferImageCopy {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> BufferImageCopyBuilder {
        BufferImageCopyBuilder {
            inner: BufferImageCopy {
                ..Default::default()
            },
        }
    }
}
impl BufferImageCopyBuilder {
    #[inline]
    pub fn buffer_offset(mut self, value: u64) -> Self {
        self.inner.buffer_offset = value;
        self
    }
    #[inline]
    pub fn buffer_row_length(mut self, value: u32) -> Self {
        self.inner.buffer_row_length = value;
        self
    }
    #[inline]
    pub fn buffer_image_height(mut self, value: u32) -> Self {
        self.inner.buffer_image_height = value;
        self
    }
    #[inline]
    pub fn image_subresource(mut self, value: ImageSubresourceLayers) -> Self {
        self.inner.image_subresource = value;
        self
    }
    #[inline]
    pub fn image_offset(mut self, value: Offset3D) -> Self {
        self.inner.image_offset = value;
        self
    }
    #[inline]
    pub fn image_extent(mut self, value: Extent3D) -> Self {
        self.inner.image_extent = value;
        self
    }
}
impl core::ops::Deref for BufferImageCopyBuilder {
    type Target = BufferImageCopy;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for BufferImageCopyBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`StridedDeviceAddressRangeKHR`].
pub struct StridedDeviceAddressRangeKHRBuilder {
    inner: StridedDeviceAddressRangeKHR,
}
impl StridedDeviceAddressRangeKHR {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> StridedDeviceAddressRangeKHRBuilder {
        StridedDeviceAddressRangeKHRBuilder {
            inner: StridedDeviceAddressRangeKHR {
                ..Default::default()
            },
        }
    }
}
impl StridedDeviceAddressRangeKHRBuilder {
    #[inline]
    pub fn address(mut self, value: u64) -> Self {
        self.inner.address = value;
        self
    }
    #[inline]
    pub fn size(mut self, value: u64) -> Self {
        self.inner.size = value;
        self
    }
    #[inline]
    pub fn stride(mut self, value: u64) -> Self {
        self.inner.stride = value;
        self
    }
}
impl core::ops::Deref for StridedDeviceAddressRangeKHRBuilder {
    type Target = StridedDeviceAddressRangeKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for StridedDeviceAddressRangeKHRBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`CopyMemoryIndirectCommandKHR`].
pub struct CopyMemoryIndirectCommandKHRBuilder {
    inner: CopyMemoryIndirectCommandKHR,
}
impl CopyMemoryIndirectCommandKHR {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> CopyMemoryIndirectCommandKHRBuilder {
        CopyMemoryIndirectCommandKHRBuilder {
            inner: CopyMemoryIndirectCommandKHR {
                ..Default::default()
            },
        }
    }
}
impl CopyMemoryIndirectCommandKHRBuilder {
    #[inline]
    pub fn src_address(mut self, value: u64) -> Self {
        self.inner.src_address = value;
        self
    }
    #[inline]
    pub fn dst_address(mut self, value: u64) -> Self {
        self.inner.dst_address = value;
        self
    }
    #[inline]
    pub fn size(mut self, value: u64) -> Self {
        self.inner.size = value;
        self
    }
}
impl core::ops::Deref for CopyMemoryIndirectCommandKHRBuilder {
    type Target = CopyMemoryIndirectCommandKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for CopyMemoryIndirectCommandKHRBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`CopyMemoryIndirectInfoKHR`] with lifetime-tied pNext safety.
pub struct CopyMemoryIndirectInfoKHRBuilder<'a> {
    inner: CopyMemoryIndirectInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl CopyMemoryIndirectInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> CopyMemoryIndirectInfoKHRBuilder<'a> {
        CopyMemoryIndirectInfoKHRBuilder {
            inner: CopyMemoryIndirectInfoKHR {
                s_type: StructureType::from_raw(1000549002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> CopyMemoryIndirectInfoKHRBuilder<'a> {
    #[inline]
    pub fn src_copy_flags(mut self, value: AddressCopyFlagsKHR) -> Self {
        self.inner.src_copy_flags = value;
        self
    }
    #[inline]
    pub fn dst_copy_flags(mut self, value: AddressCopyFlagsKHR) -> Self {
        self.inner.dst_copy_flags = value;
        self
    }
    #[inline]
    pub fn copy_count(mut self, value: u32) -> Self {
        self.inner.copy_count = value;
        self
    }
    #[inline]
    pub fn copy_address_range(mut self, value: StridedDeviceAddressRangeKHR) -> Self {
        self.inner.copy_address_range = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`CopyMemoryIndirectInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsCopyMemoryIndirectInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for CopyMemoryIndirectInfoKHRBuilder<'a> {
    type Target = CopyMemoryIndirectInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for CopyMemoryIndirectInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`CopyMemoryToImageIndirectCommandKHR`].
pub struct CopyMemoryToImageIndirectCommandKHRBuilder {
    inner: CopyMemoryToImageIndirectCommandKHR,
}
impl CopyMemoryToImageIndirectCommandKHR {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> CopyMemoryToImageIndirectCommandKHRBuilder {
        CopyMemoryToImageIndirectCommandKHRBuilder {
            inner: CopyMemoryToImageIndirectCommandKHR {
                ..Default::default()
            },
        }
    }
}
impl CopyMemoryToImageIndirectCommandKHRBuilder {
    #[inline]
    pub fn src_address(mut self, value: u64) -> Self {
        self.inner.src_address = value;
        self
    }
    #[inline]
    pub fn buffer_row_length(mut self, value: u32) -> Self {
        self.inner.buffer_row_length = value;
        self
    }
    #[inline]
    pub fn buffer_image_height(mut self, value: u32) -> Self {
        self.inner.buffer_image_height = value;
        self
    }
    #[inline]
    pub fn image_subresource(mut self, value: ImageSubresourceLayers) -> Self {
        self.inner.image_subresource = value;
        self
    }
    #[inline]
    pub fn image_offset(mut self, value: Offset3D) -> Self {
        self.inner.image_offset = value;
        self
    }
    #[inline]
    pub fn image_extent(mut self, value: Extent3D) -> Self {
        self.inner.image_extent = value;
        self
    }
}
impl core::ops::Deref for CopyMemoryToImageIndirectCommandKHRBuilder {
    type Target = CopyMemoryToImageIndirectCommandKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for CopyMemoryToImageIndirectCommandKHRBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`CopyMemoryToImageIndirectInfoKHR`] with lifetime-tied pNext safety.
pub struct CopyMemoryToImageIndirectInfoKHRBuilder<'a> {
    inner: CopyMemoryToImageIndirectInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl CopyMemoryToImageIndirectInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> CopyMemoryToImageIndirectInfoKHRBuilder<'a> {
        CopyMemoryToImageIndirectInfoKHRBuilder {
            inner: CopyMemoryToImageIndirectInfoKHR {
                s_type: StructureType::from_raw(1000549003i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> CopyMemoryToImageIndirectInfoKHRBuilder<'a> {
    #[inline]
    pub fn src_copy_flags(mut self, value: AddressCopyFlagsKHR) -> Self {
        self.inner.src_copy_flags = value;
        self
    }
    #[inline]
    pub fn copy_address_range(mut self, value: StridedDeviceAddressRangeKHR) -> Self {
        self.inner.copy_address_range = value;
        self
    }
    #[inline]
    pub fn dst_image(mut self, value: Image) -> Self {
        self.inner.dst_image = value;
        self
    }
    #[inline]
    pub fn dst_image_layout(mut self, value: ImageLayout) -> Self {
        self.inner.dst_image_layout = value;
        self
    }
    #[inline]
    pub fn image_subresources(mut self, slice: &'a [ImageSubresourceLayers]) -> Self {
        self.inner.copy_count = slice.len() as u32;
        self.inner.p_image_subresources = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`CopyMemoryToImageIndirectInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsCopyMemoryToImageIndirectInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for CopyMemoryToImageIndirectInfoKHRBuilder<'a> {
    type Target = CopyMemoryToImageIndirectInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for CopyMemoryToImageIndirectInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ImageResolve`].
pub struct ImageResolveBuilder {
    inner: ImageResolve,
}
impl ImageResolve {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> ImageResolveBuilder {
        ImageResolveBuilder {
            inner: ImageResolve {
                ..Default::default()
            },
        }
    }
}
impl ImageResolveBuilder {
    #[inline]
    pub fn src_subresource(mut self, value: ImageSubresourceLayers) -> Self {
        self.inner.src_subresource = value;
        self
    }
    #[inline]
    pub fn src_offset(mut self, value: Offset3D) -> Self {
        self.inner.src_offset = value;
        self
    }
    #[inline]
    pub fn dst_subresource(mut self, value: ImageSubresourceLayers) -> Self {
        self.inner.dst_subresource = value;
        self
    }
    #[inline]
    pub fn dst_offset(mut self, value: Offset3D) -> Self {
        self.inner.dst_offset = value;
        self
    }
    #[inline]
    pub fn extent(mut self, value: Extent3D) -> Self {
        self.inner.extent = value;
        self
    }
}
impl core::ops::Deref for ImageResolveBuilder {
    type Target = ImageResolve;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for ImageResolveBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ShaderModuleCreateInfo`] with lifetime-tied pNext safety.
pub struct ShaderModuleCreateInfoBuilder<'a> {
    inner: ShaderModuleCreateInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ShaderModuleCreateInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ShaderModuleCreateInfoBuilder<'a> {
        ShaderModuleCreateInfoBuilder {
            inner: ShaderModuleCreateInfo {
                s_type: StructureType::from_raw(16i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ShaderModuleCreateInfoBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: ShaderModuleCreateFlags) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn code(mut self, slice: &'a [u32]) -> Self {
        self.inner.code_size = core::mem::size_of_val(slice);
        self.inner.p_code = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`ShaderModuleCreateInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsShaderModuleCreateInfo>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for ShaderModuleCreateInfoBuilder<'a> {
    type Target = ShaderModuleCreateInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ShaderModuleCreateInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DescriptorSetLayoutBinding`].
pub struct DescriptorSetLayoutBindingBuilder<'a> {
    inner: DescriptorSetLayoutBinding,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DescriptorSetLayoutBinding {
    /// Start building this struct.
    #[inline]
    pub fn builder<'a>() -> DescriptorSetLayoutBindingBuilder<'a> {
        DescriptorSetLayoutBindingBuilder {
            inner: DescriptorSetLayoutBinding {
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DescriptorSetLayoutBindingBuilder<'a> {
    #[inline]
    pub fn binding(mut self, value: u32) -> Self {
        self.inner.binding = value;
        self
    }
    #[inline]
    pub fn descriptor_type(mut self, value: DescriptorType) -> Self {
        self.inner.descriptor_type = value;
        self
    }
    #[inline]
    pub fn descriptor_count(mut self, value: u32) -> Self {
        self.inner.descriptor_count = value;
        self
    }
    #[inline]
    pub fn stage_flags(mut self, value: ShaderStageFlags) -> Self {
        self.inner.stage_flags = value;
        self
    }
    #[inline]
    pub fn immutable_samplers(mut self, slice: &'a [Sampler]) -> Self {
        self.inner.descriptor_count = slice.len() as u32;
        self.inner.p_immutable_samplers = slice.as_ptr();
        self
    }
}
impl<'a> core::ops::Deref for DescriptorSetLayoutBindingBuilder<'a> {
    type Target = DescriptorSetLayoutBinding;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for DescriptorSetLayoutBindingBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DescriptorSetLayoutCreateInfo`] with lifetime-tied pNext safety.
pub struct DescriptorSetLayoutCreateInfoBuilder<'a> {
    inner: DescriptorSetLayoutCreateInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DescriptorSetLayoutCreateInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> DescriptorSetLayoutCreateInfoBuilder<'a> {
        DescriptorSetLayoutCreateInfoBuilder {
            inner: DescriptorSetLayoutCreateInfo {
                s_type: StructureType::from_raw(32i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DescriptorSetLayoutCreateInfoBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: DescriptorSetLayoutCreateFlags) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn bindings(mut self, slice: &'a [DescriptorSetLayoutBinding]) -> Self {
        self.inner.binding_count = slice.len() as u32;
        self.inner.p_bindings = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`DescriptorSetLayoutCreateInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsDescriptorSetLayoutCreateInfo>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for DescriptorSetLayoutCreateInfoBuilder<'a> {
    type Target = DescriptorSetLayoutCreateInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for DescriptorSetLayoutCreateInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DescriptorPoolSize`].
pub struct DescriptorPoolSizeBuilder {
    inner: DescriptorPoolSize,
}
impl DescriptorPoolSize {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> DescriptorPoolSizeBuilder {
        DescriptorPoolSizeBuilder {
            inner: DescriptorPoolSize {
                ..Default::default()
            },
        }
    }
}
impl DescriptorPoolSizeBuilder {
    #[inline]
    pub fn r#type(mut self, value: DescriptorType) -> Self {
        self.inner.r#type = value;
        self
    }
    #[inline]
    pub fn descriptor_count(mut self, value: u32) -> Self {
        self.inner.descriptor_count = value;
        self
    }
}
impl core::ops::Deref for DescriptorPoolSizeBuilder {
    type Target = DescriptorPoolSize;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for DescriptorPoolSizeBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DescriptorPoolCreateInfo`] with lifetime-tied pNext safety.
pub struct DescriptorPoolCreateInfoBuilder<'a> {
    inner: DescriptorPoolCreateInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DescriptorPoolCreateInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> DescriptorPoolCreateInfoBuilder<'a> {
        DescriptorPoolCreateInfoBuilder {
            inner: DescriptorPoolCreateInfo {
                s_type: StructureType::from_raw(33i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DescriptorPoolCreateInfoBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: DescriptorPoolCreateFlags) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn max_sets(mut self, value: u32) -> Self {
        self.inner.max_sets = value;
        self
    }
    #[inline]
    pub fn pool_sizes(mut self, slice: &'a [DescriptorPoolSize]) -> Self {
        self.inner.pool_size_count = slice.len() as u32;
        self.inner.p_pool_sizes = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`DescriptorPoolCreateInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsDescriptorPoolCreateInfo>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for DescriptorPoolCreateInfoBuilder<'a> {
    type Target = DescriptorPoolCreateInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for DescriptorPoolCreateInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DescriptorSetAllocateInfo`] with lifetime-tied pNext safety.
pub struct DescriptorSetAllocateInfoBuilder<'a> {
    inner: DescriptorSetAllocateInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DescriptorSetAllocateInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> DescriptorSetAllocateInfoBuilder<'a> {
        DescriptorSetAllocateInfoBuilder {
            inner: DescriptorSetAllocateInfo {
                s_type: StructureType::from_raw(34i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DescriptorSetAllocateInfoBuilder<'a> {
    #[inline]
    pub fn descriptor_pool(mut self, value: DescriptorPool) -> Self {
        self.inner.descriptor_pool = value;
        self
    }
    #[inline]
    pub fn set_layouts(mut self, slice: &'a [DescriptorSetLayout]) -> Self {
        self.inner.descriptor_set_count = slice.len() as u32;
        self.inner.p_set_layouts = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`DescriptorSetAllocateInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsDescriptorSetAllocateInfo>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for DescriptorSetAllocateInfoBuilder<'a> {
    type Target = DescriptorSetAllocateInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for DescriptorSetAllocateInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`SpecializationMapEntry`].
pub struct SpecializationMapEntryBuilder {
    inner: SpecializationMapEntry,
}
impl SpecializationMapEntry {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> SpecializationMapEntryBuilder {
        SpecializationMapEntryBuilder {
            inner: SpecializationMapEntry {
                ..Default::default()
            },
        }
    }
}
impl SpecializationMapEntryBuilder {
    #[inline]
    pub fn constant_id(mut self, value: u32) -> Self {
        self.inner.constant_id = value;
        self
    }
    #[inline]
    pub fn offset(mut self, value: u32) -> Self {
        self.inner.offset = value;
        self
    }
    #[inline]
    pub fn size(mut self, value: usize) -> Self {
        self.inner.size = value;
        self
    }
}
impl core::ops::Deref for SpecializationMapEntryBuilder {
    type Target = SpecializationMapEntry;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for SpecializationMapEntryBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`SpecializationInfo`].
pub struct SpecializationInfoBuilder<'a> {
    inner: SpecializationInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl SpecializationInfo {
    /// Start building this struct.
    #[inline]
    pub fn builder<'a>() -> SpecializationInfoBuilder<'a> {
        SpecializationInfoBuilder {
            inner: SpecializationInfo {
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> SpecializationInfoBuilder<'a> {
    #[inline]
    pub fn map_entries(mut self, slice: &'a [SpecializationMapEntry]) -> Self {
        self.inner.map_entry_count = slice.len() as u32;
        self.inner.p_map_entries = slice.as_ptr();
        self
    }
    #[inline]
    pub fn data(mut self, slice: &'a [core::ffi::c_void]) -> Self {
        self.inner.data_size = slice.len();
        self.inner.p_data = slice.as_ptr();
        self
    }
}
impl<'a> core::ops::Deref for SpecializationInfoBuilder<'a> {
    type Target = SpecializationInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for SpecializationInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PipelineShaderStageCreateInfo`] with lifetime-tied pNext safety.
pub struct PipelineShaderStageCreateInfoBuilder<'a> {
    inner: PipelineShaderStageCreateInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PipelineShaderStageCreateInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PipelineShaderStageCreateInfoBuilder<'a> {
        PipelineShaderStageCreateInfoBuilder {
            inner: PipelineShaderStageCreateInfo {
                s_type: StructureType::from_raw(18i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PipelineShaderStageCreateInfoBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: PipelineShaderStageCreateFlags) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn stage(mut self, value: ShaderStageFlagBits) -> Self {
        self.inner.stage = value;
        self
    }
    #[inline]
    pub fn module(mut self, value: ShaderModule) -> Self {
        self.inner.module = value;
        self
    }
    #[inline]
    pub fn name(mut self, value: &'a core::ffi::CStr) -> Self {
        self.inner.p_name = value.as_ptr();
        self
    }
    #[inline]
    pub fn specialization_info(mut self, value: &'a SpecializationInfo) -> Self {
        self.inner.p_specialization_info = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PipelineShaderStageCreateInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPipelineShaderStageCreateInfo>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for PipelineShaderStageCreateInfoBuilder<'a> {
    type Target = PipelineShaderStageCreateInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PipelineShaderStageCreateInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ComputePipelineCreateInfo`] with lifetime-tied pNext safety.
pub struct ComputePipelineCreateInfoBuilder<'a> {
    inner: ComputePipelineCreateInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ComputePipelineCreateInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ComputePipelineCreateInfoBuilder<'a> {
        ComputePipelineCreateInfoBuilder {
            inner: ComputePipelineCreateInfo {
                s_type: StructureType::from_raw(29i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ComputePipelineCreateInfoBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: PipelineCreateFlags) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn stage(mut self, value: PipelineShaderStageCreateInfo) -> Self {
        self.inner.stage = value;
        self
    }
    #[inline]
    pub fn layout(mut self, value: PipelineLayout) -> Self {
        self.inner.layout = value;
        self
    }
    #[inline]
    pub fn base_pipeline_handle(mut self, value: Pipeline) -> Self {
        self.inner.base_pipeline_handle = value;
        self
    }
    #[inline]
    pub fn base_pipeline_index(mut self, value: i32) -> Self {
        self.inner.base_pipeline_index = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`ComputePipelineCreateInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsComputePipelineCreateInfo>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for ComputePipelineCreateInfoBuilder<'a> {
    type Target = ComputePipelineCreateInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ComputePipelineCreateInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ComputePipelineIndirectBufferInfoNV`] with lifetime-tied pNext safety.
pub struct ComputePipelineIndirectBufferInfoNVBuilder<'a> {
    inner: ComputePipelineIndirectBufferInfoNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ComputePipelineIndirectBufferInfoNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ComputePipelineIndirectBufferInfoNVBuilder<'a> {
        ComputePipelineIndirectBufferInfoNVBuilder {
            inner: ComputePipelineIndirectBufferInfoNV {
                s_type: StructureType::from_raw(1000428001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ComputePipelineIndirectBufferInfoNVBuilder<'a> {
    #[inline]
    pub fn device_address(mut self, value: u64) -> Self {
        self.inner.device_address = value;
        self
    }
    #[inline]
    pub fn size(mut self, value: u64) -> Self {
        self.inner.size = value;
        self
    }
    #[inline]
    pub fn pipeline_device_address_capture_replay(mut self, value: u64) -> Self {
        self.inner.pipeline_device_address_capture_replay = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`ComputePipelineIndirectBufferInfoNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsComputePipelineIndirectBufferInfoNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for ComputePipelineIndirectBufferInfoNVBuilder<'a> {
    type Target = ComputePipelineIndirectBufferInfoNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ComputePipelineIndirectBufferInfoNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PipelineCreateFlags2CreateInfo`] with lifetime-tied pNext safety.
pub struct PipelineCreateFlags2CreateInfoBuilder<'a> {
    inner: PipelineCreateFlags2CreateInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PipelineCreateFlags2CreateInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PipelineCreateFlags2CreateInfoBuilder<'a> {
        PipelineCreateFlags2CreateInfoBuilder {
            inner: PipelineCreateFlags2CreateInfo {
                s_type: StructureType::from_raw(1000470005i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PipelineCreateFlags2CreateInfoBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: PipelineCreateFlags2) -> Self {
        self.inner.flags = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PipelineCreateFlags2CreateInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPipelineCreateFlags2CreateInfo>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for PipelineCreateFlags2CreateInfoBuilder<'a> {
    type Target = PipelineCreateFlags2CreateInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PipelineCreateFlags2CreateInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VertexInputBindingDescription`].
pub struct VertexInputBindingDescriptionBuilder {
    inner: VertexInputBindingDescription,
}
impl VertexInputBindingDescription {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> VertexInputBindingDescriptionBuilder {
        VertexInputBindingDescriptionBuilder {
            inner: VertexInputBindingDescription {
                ..Default::default()
            },
        }
    }
}
impl VertexInputBindingDescriptionBuilder {
    #[inline]
    pub fn binding(mut self, value: u32) -> Self {
        self.inner.binding = value;
        self
    }
    #[inline]
    pub fn stride(mut self, value: u32) -> Self {
        self.inner.stride = value;
        self
    }
    #[inline]
    pub fn input_rate(mut self, value: VertexInputRate) -> Self {
        self.inner.input_rate = value;
        self
    }
}
impl core::ops::Deref for VertexInputBindingDescriptionBuilder {
    type Target = VertexInputBindingDescription;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for VertexInputBindingDescriptionBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VertexInputAttributeDescription`].
pub struct VertexInputAttributeDescriptionBuilder {
    inner: VertexInputAttributeDescription,
}
impl VertexInputAttributeDescription {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> VertexInputAttributeDescriptionBuilder {
        VertexInputAttributeDescriptionBuilder {
            inner: VertexInputAttributeDescription {
                ..Default::default()
            },
        }
    }
}
impl VertexInputAttributeDescriptionBuilder {
    #[inline]
    pub fn location(mut self, value: u32) -> Self {
        self.inner.location = value;
        self
    }
    #[inline]
    pub fn binding(mut self, value: u32) -> Self {
        self.inner.binding = value;
        self
    }
    #[inline]
    pub fn format(mut self, value: Format) -> Self {
        self.inner.format = value;
        self
    }
    #[inline]
    pub fn offset(mut self, value: u32) -> Self {
        self.inner.offset = value;
        self
    }
}
impl core::ops::Deref for VertexInputAttributeDescriptionBuilder {
    type Target = VertexInputAttributeDescription;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for VertexInputAttributeDescriptionBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PipelineVertexInputStateCreateInfo`] with lifetime-tied pNext safety.
pub struct PipelineVertexInputStateCreateInfoBuilder<'a> {
    inner: PipelineVertexInputStateCreateInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PipelineVertexInputStateCreateInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PipelineVertexInputStateCreateInfoBuilder<'a> {
        PipelineVertexInputStateCreateInfoBuilder {
            inner: PipelineVertexInputStateCreateInfo {
                s_type: StructureType::from_raw(19i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PipelineVertexInputStateCreateInfoBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: PipelineVertexInputStateCreateFlags) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn vertex_binding_descriptions(
        mut self,
        slice: &'a [VertexInputBindingDescription],
    ) -> Self {
        self.inner.vertex_binding_description_count = slice.len() as u32;
        self.inner.p_vertex_binding_descriptions = slice.as_ptr();
        self
    }
    #[inline]
    pub fn vertex_attribute_descriptions(
        mut self,
        slice: &'a [VertexInputAttributeDescription],
    ) -> Self {
        self.inner.vertex_attribute_description_count = slice.len() as u32;
        self.inner.p_vertex_attribute_descriptions = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`PipelineVertexInputStateCreateInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPipelineVertexInputStateCreateInfo>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for PipelineVertexInputStateCreateInfoBuilder<'a> {
    type Target = PipelineVertexInputStateCreateInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PipelineVertexInputStateCreateInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PipelineInputAssemblyStateCreateInfo`] with lifetime-tied pNext safety.
pub struct PipelineInputAssemblyStateCreateInfoBuilder<'a> {
    inner: PipelineInputAssemblyStateCreateInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PipelineInputAssemblyStateCreateInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PipelineInputAssemblyStateCreateInfoBuilder<'a> {
        PipelineInputAssemblyStateCreateInfoBuilder {
            inner: PipelineInputAssemblyStateCreateInfo {
                s_type: StructureType::from_raw(20i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PipelineInputAssemblyStateCreateInfoBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: PipelineInputAssemblyStateCreateFlags) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn topology(mut self, value: PrimitiveTopology) -> Self {
        self.inner.topology = value;
        self
    }
    #[inline]
    pub fn primitive_restart_enable(mut self, value: bool) -> Self {
        self.inner.primitive_restart_enable = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PipelineInputAssemblyStateCreateInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPipelineInputAssemblyStateCreateInfo>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for PipelineInputAssemblyStateCreateInfoBuilder<'a> {
    type Target = PipelineInputAssemblyStateCreateInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PipelineInputAssemblyStateCreateInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PipelineTessellationStateCreateInfo`] with lifetime-tied pNext safety.
pub struct PipelineTessellationStateCreateInfoBuilder<'a> {
    inner: PipelineTessellationStateCreateInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PipelineTessellationStateCreateInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PipelineTessellationStateCreateInfoBuilder<'a> {
        PipelineTessellationStateCreateInfoBuilder {
            inner: PipelineTessellationStateCreateInfo {
                s_type: StructureType::from_raw(21i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PipelineTessellationStateCreateInfoBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: PipelineTessellationStateCreateFlags) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn patch_control_points(mut self, value: u32) -> Self {
        self.inner.patch_control_points = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PipelineTessellationStateCreateInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPipelineTessellationStateCreateInfo>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for PipelineTessellationStateCreateInfoBuilder<'a> {
    type Target = PipelineTessellationStateCreateInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PipelineTessellationStateCreateInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PipelineViewportStateCreateInfo`] with lifetime-tied pNext safety.
pub struct PipelineViewportStateCreateInfoBuilder<'a> {
    inner: PipelineViewportStateCreateInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PipelineViewportStateCreateInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PipelineViewportStateCreateInfoBuilder<'a> {
        PipelineViewportStateCreateInfoBuilder {
            inner: PipelineViewportStateCreateInfo {
                s_type: StructureType::from_raw(22i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PipelineViewportStateCreateInfoBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: PipelineViewportStateCreateFlags) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn viewport_count(mut self, value: u32) -> Self {
        self.inner.viewport_count = value;
        self
    }
    #[inline]
    pub fn viewports(mut self, slice: &'a [Viewport]) -> Self {
        self.inner.viewport_count = slice.len() as u32;
        self.inner.p_viewports = slice.as_ptr();
        self
    }
    #[inline]
    pub fn scissor_count(mut self, value: u32) -> Self {
        self.inner.scissor_count = value;
        self
    }
    #[inline]
    pub fn scissors(mut self, slice: &'a [Rect2D]) -> Self {
        self.inner.scissor_count = slice.len() as u32;
        self.inner.p_scissors = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`PipelineViewportStateCreateInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPipelineViewportStateCreateInfo>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for PipelineViewportStateCreateInfoBuilder<'a> {
    type Target = PipelineViewportStateCreateInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PipelineViewportStateCreateInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PipelineRasterizationStateCreateInfo`] with lifetime-tied pNext safety.
pub struct PipelineRasterizationStateCreateInfoBuilder<'a> {
    inner: PipelineRasterizationStateCreateInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PipelineRasterizationStateCreateInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PipelineRasterizationStateCreateInfoBuilder<'a> {
        PipelineRasterizationStateCreateInfoBuilder {
            inner: PipelineRasterizationStateCreateInfo {
                s_type: StructureType::from_raw(23i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PipelineRasterizationStateCreateInfoBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: PipelineRasterizationStateCreateFlags) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn depth_clamp_enable(mut self, value: bool) -> Self {
        self.inner.depth_clamp_enable = value as u32;
        self
    }
    #[inline]
    pub fn rasterizer_discard_enable(mut self, value: bool) -> Self {
        self.inner.rasterizer_discard_enable = value as u32;
        self
    }
    #[inline]
    pub fn polygon_mode(mut self, value: PolygonMode) -> Self {
        self.inner.polygon_mode = value;
        self
    }
    #[inline]
    pub fn cull_mode(mut self, value: CullModeFlags) -> Self {
        self.inner.cull_mode = value;
        self
    }
    #[inline]
    pub fn front_face(mut self, value: FrontFace) -> Self {
        self.inner.front_face = value;
        self
    }
    #[inline]
    pub fn depth_bias_enable(mut self, value: bool) -> Self {
        self.inner.depth_bias_enable = value as u32;
        self
    }
    #[inline]
    pub fn depth_bias_constant_factor(mut self, value: f32) -> Self {
        self.inner.depth_bias_constant_factor = value;
        self
    }
    #[inline]
    pub fn depth_bias_clamp(mut self, value: f32) -> Self {
        self.inner.depth_bias_clamp = value;
        self
    }
    #[inline]
    pub fn depth_bias_slope_factor(mut self, value: f32) -> Self {
        self.inner.depth_bias_slope_factor = value;
        self
    }
    #[inline]
    pub fn line_width(mut self, value: f32) -> Self {
        self.inner.line_width = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PipelineRasterizationStateCreateInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPipelineRasterizationStateCreateInfo>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for PipelineRasterizationStateCreateInfoBuilder<'a> {
    type Target = PipelineRasterizationStateCreateInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PipelineRasterizationStateCreateInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PipelineMultisampleStateCreateInfo`] with lifetime-tied pNext safety.
pub struct PipelineMultisampleStateCreateInfoBuilder<'a> {
    inner: PipelineMultisampleStateCreateInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PipelineMultisampleStateCreateInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PipelineMultisampleStateCreateInfoBuilder<'a> {
        PipelineMultisampleStateCreateInfoBuilder {
            inner: PipelineMultisampleStateCreateInfo {
                s_type: StructureType::from_raw(24i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PipelineMultisampleStateCreateInfoBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: PipelineMultisampleStateCreateFlags) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn rasterization_samples(mut self, value: SampleCountFlagBits) -> Self {
        self.inner.rasterization_samples = value;
        self
    }
    #[inline]
    pub fn sample_shading_enable(mut self, value: bool) -> Self {
        self.inner.sample_shading_enable = value as u32;
        self
    }
    #[inline]
    pub fn min_sample_shading(mut self, value: f32) -> Self {
        self.inner.min_sample_shading = value;
        self
    }
    #[inline]
    pub fn sample_mask(mut self, value: &'a u32) -> Self {
        self.inner.p_sample_mask = value;
        self
    }
    #[inline]
    pub fn alpha_to_coverage_enable(mut self, value: bool) -> Self {
        self.inner.alpha_to_coverage_enable = value as u32;
        self
    }
    #[inline]
    pub fn alpha_to_one_enable(mut self, value: bool) -> Self {
        self.inner.alpha_to_one_enable = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PipelineMultisampleStateCreateInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPipelineMultisampleStateCreateInfo>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for PipelineMultisampleStateCreateInfoBuilder<'a> {
    type Target = PipelineMultisampleStateCreateInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PipelineMultisampleStateCreateInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PipelineColorBlendAttachmentState`].
pub struct PipelineColorBlendAttachmentStateBuilder {
    inner: PipelineColorBlendAttachmentState,
}
impl PipelineColorBlendAttachmentState {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> PipelineColorBlendAttachmentStateBuilder {
        PipelineColorBlendAttachmentStateBuilder {
            inner: PipelineColorBlendAttachmentState {
                ..Default::default()
            },
        }
    }
}
impl PipelineColorBlendAttachmentStateBuilder {
    #[inline]
    pub fn blend_enable(mut self, value: bool) -> Self {
        self.inner.blend_enable = value as u32;
        self
    }
    #[inline]
    pub fn src_color_blend_factor(mut self, value: BlendFactor) -> Self {
        self.inner.src_color_blend_factor = value;
        self
    }
    #[inline]
    pub fn dst_color_blend_factor(mut self, value: BlendFactor) -> Self {
        self.inner.dst_color_blend_factor = value;
        self
    }
    #[inline]
    pub fn color_blend_op(mut self, value: BlendOp) -> Self {
        self.inner.color_blend_op = value;
        self
    }
    #[inline]
    pub fn src_alpha_blend_factor(mut self, value: BlendFactor) -> Self {
        self.inner.src_alpha_blend_factor = value;
        self
    }
    #[inline]
    pub fn dst_alpha_blend_factor(mut self, value: BlendFactor) -> Self {
        self.inner.dst_alpha_blend_factor = value;
        self
    }
    #[inline]
    pub fn alpha_blend_op(mut self, value: BlendOp) -> Self {
        self.inner.alpha_blend_op = value;
        self
    }
    #[inline]
    pub fn color_write_mask(mut self, value: ColorComponentFlags) -> Self {
        self.inner.color_write_mask = value;
        self
    }
}
impl core::ops::Deref for PipelineColorBlendAttachmentStateBuilder {
    type Target = PipelineColorBlendAttachmentState;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for PipelineColorBlendAttachmentStateBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PipelineColorBlendStateCreateInfo`] with lifetime-tied pNext safety.
pub struct PipelineColorBlendStateCreateInfoBuilder<'a> {
    inner: PipelineColorBlendStateCreateInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PipelineColorBlendStateCreateInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PipelineColorBlendStateCreateInfoBuilder<'a> {
        PipelineColorBlendStateCreateInfoBuilder {
            inner: PipelineColorBlendStateCreateInfo {
                s_type: StructureType::from_raw(26i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PipelineColorBlendStateCreateInfoBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: PipelineColorBlendStateCreateFlags) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn logic_op_enable(mut self, value: bool) -> Self {
        self.inner.logic_op_enable = value as u32;
        self
    }
    #[inline]
    pub fn logic_op(mut self, value: LogicOp) -> Self {
        self.inner.logic_op = value;
        self
    }
    #[inline]
    pub fn attachment_count(mut self, value: u32) -> Self {
        self.inner.attachment_count = value;
        self
    }
    #[inline]
    pub fn attachments(
        mut self,
        slice: &'a [PipelineColorBlendAttachmentState],
    ) -> Self {
        self.inner.attachment_count = slice.len() as u32;
        self.inner.p_attachments = slice.as_ptr();
        self
    }
    #[inline]
    pub fn blend_constants(mut self, value: [f32; 4usize]) -> Self {
        self.inner.blend_constants = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PipelineColorBlendStateCreateInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPipelineColorBlendStateCreateInfo>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for PipelineColorBlendStateCreateInfoBuilder<'a> {
    type Target = PipelineColorBlendStateCreateInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PipelineColorBlendStateCreateInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PipelineDynamicStateCreateInfo`] with lifetime-tied pNext safety.
pub struct PipelineDynamicStateCreateInfoBuilder<'a> {
    inner: PipelineDynamicStateCreateInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PipelineDynamicStateCreateInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PipelineDynamicStateCreateInfoBuilder<'a> {
        PipelineDynamicStateCreateInfoBuilder {
            inner: PipelineDynamicStateCreateInfo {
                s_type: StructureType::from_raw(27i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PipelineDynamicStateCreateInfoBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: PipelineDynamicStateCreateFlags) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn dynamic_states(mut self, slice: &'a [DynamicState]) -> Self {
        self.inner.dynamic_state_count = slice.len() as u32;
        self.inner.p_dynamic_states = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`PipelineDynamicStateCreateInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPipelineDynamicStateCreateInfo>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for PipelineDynamicStateCreateInfoBuilder<'a> {
    type Target = PipelineDynamicStateCreateInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PipelineDynamicStateCreateInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`StencilOpState`].
pub struct StencilOpStateBuilder {
    inner: StencilOpState,
}
impl StencilOpState {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> StencilOpStateBuilder {
        StencilOpStateBuilder {
            inner: StencilOpState {
                ..Default::default()
            },
        }
    }
}
impl StencilOpStateBuilder {
    #[inline]
    pub fn fail_op(mut self, value: StencilOp) -> Self {
        self.inner.fail_op = value;
        self
    }
    #[inline]
    pub fn pass_op(mut self, value: StencilOp) -> Self {
        self.inner.pass_op = value;
        self
    }
    #[inline]
    pub fn depth_fail_op(mut self, value: StencilOp) -> Self {
        self.inner.depth_fail_op = value;
        self
    }
    #[inline]
    pub fn compare_op(mut self, value: CompareOp) -> Self {
        self.inner.compare_op = value;
        self
    }
    #[inline]
    pub fn compare_mask(mut self, value: u32) -> Self {
        self.inner.compare_mask = value;
        self
    }
    #[inline]
    pub fn write_mask(mut self, value: u32) -> Self {
        self.inner.write_mask = value;
        self
    }
    #[inline]
    pub fn reference(mut self, value: u32) -> Self {
        self.inner.reference = value;
        self
    }
}
impl core::ops::Deref for StencilOpStateBuilder {
    type Target = StencilOpState;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for StencilOpStateBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PipelineDepthStencilStateCreateInfo`] with lifetime-tied pNext safety.
pub struct PipelineDepthStencilStateCreateInfoBuilder<'a> {
    inner: PipelineDepthStencilStateCreateInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PipelineDepthStencilStateCreateInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PipelineDepthStencilStateCreateInfoBuilder<'a> {
        PipelineDepthStencilStateCreateInfoBuilder {
            inner: PipelineDepthStencilStateCreateInfo {
                s_type: StructureType::from_raw(25i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PipelineDepthStencilStateCreateInfoBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: PipelineDepthStencilStateCreateFlags) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn depth_test_enable(mut self, value: bool) -> Self {
        self.inner.depth_test_enable = value as u32;
        self
    }
    #[inline]
    pub fn depth_write_enable(mut self, value: bool) -> Self {
        self.inner.depth_write_enable = value as u32;
        self
    }
    #[inline]
    pub fn depth_compare_op(mut self, value: CompareOp) -> Self {
        self.inner.depth_compare_op = value;
        self
    }
    #[inline]
    pub fn depth_bounds_test_enable(mut self, value: bool) -> Self {
        self.inner.depth_bounds_test_enable = value as u32;
        self
    }
    #[inline]
    pub fn stencil_test_enable(mut self, value: bool) -> Self {
        self.inner.stencil_test_enable = value as u32;
        self
    }
    #[inline]
    pub fn front(mut self, value: StencilOpState) -> Self {
        self.inner.front = value;
        self
    }
    #[inline]
    pub fn back(mut self, value: StencilOpState) -> Self {
        self.inner.back = value;
        self
    }
    #[inline]
    pub fn min_depth_bounds(mut self, value: f32) -> Self {
        self.inner.min_depth_bounds = value;
        self
    }
    #[inline]
    pub fn max_depth_bounds(mut self, value: f32) -> Self {
        self.inner.max_depth_bounds = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PipelineDepthStencilStateCreateInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPipelineDepthStencilStateCreateInfo>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for PipelineDepthStencilStateCreateInfoBuilder<'a> {
    type Target = PipelineDepthStencilStateCreateInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PipelineDepthStencilStateCreateInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`GraphicsPipelineCreateInfo`] with lifetime-tied pNext safety.
pub struct GraphicsPipelineCreateInfoBuilder<'a> {
    inner: GraphicsPipelineCreateInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl GraphicsPipelineCreateInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> GraphicsPipelineCreateInfoBuilder<'a> {
        GraphicsPipelineCreateInfoBuilder {
            inner: GraphicsPipelineCreateInfo {
                s_type: StructureType::from_raw(28i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> GraphicsPipelineCreateInfoBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: PipelineCreateFlags) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn stages(mut self, slice: &'a [PipelineShaderStageCreateInfo]) -> Self {
        self.inner.stage_count = slice.len() as u32;
        self.inner.p_stages = slice.as_ptr();
        self
    }
    #[inline]
    pub fn vertex_input_state(
        mut self,
        value: &'a PipelineVertexInputStateCreateInfo,
    ) -> Self {
        self.inner.p_vertex_input_state = value;
        self
    }
    #[inline]
    pub fn input_assembly_state(
        mut self,
        value: &'a PipelineInputAssemblyStateCreateInfo,
    ) -> Self {
        self.inner.p_input_assembly_state = value;
        self
    }
    #[inline]
    pub fn tessellation_state(
        mut self,
        value: &'a PipelineTessellationStateCreateInfo,
    ) -> Self {
        self.inner.p_tessellation_state = value;
        self
    }
    #[inline]
    pub fn viewport_state(mut self, value: &'a PipelineViewportStateCreateInfo) -> Self {
        self.inner.p_viewport_state = value;
        self
    }
    #[inline]
    pub fn rasterization_state(
        mut self,
        value: &'a PipelineRasterizationStateCreateInfo,
    ) -> Self {
        self.inner.p_rasterization_state = value;
        self
    }
    #[inline]
    pub fn multisample_state(
        mut self,
        value: &'a PipelineMultisampleStateCreateInfo,
    ) -> Self {
        self.inner.p_multisample_state = value;
        self
    }
    #[inline]
    pub fn depth_stencil_state(
        mut self,
        value: &'a PipelineDepthStencilStateCreateInfo,
    ) -> Self {
        self.inner.p_depth_stencil_state = value;
        self
    }
    #[inline]
    pub fn color_blend_state(
        mut self,
        value: &'a PipelineColorBlendStateCreateInfo,
    ) -> Self {
        self.inner.p_color_blend_state = value;
        self
    }
    #[inline]
    pub fn dynamic_state(mut self, value: &'a PipelineDynamicStateCreateInfo) -> Self {
        self.inner.p_dynamic_state = value;
        self
    }
    #[inline]
    pub fn layout(mut self, value: PipelineLayout) -> Self {
        self.inner.layout = value;
        self
    }
    #[inline]
    pub fn render_pass(mut self, value: RenderPass) -> Self {
        self.inner.render_pass = value;
        self
    }
    #[inline]
    pub fn subpass(mut self, value: u32) -> Self {
        self.inner.subpass = value;
        self
    }
    #[inline]
    pub fn base_pipeline_handle(mut self, value: Pipeline) -> Self {
        self.inner.base_pipeline_handle = value;
        self
    }
    #[inline]
    pub fn base_pipeline_index(mut self, value: i32) -> Self {
        self.inner.base_pipeline_index = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`GraphicsPipelineCreateInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsGraphicsPipelineCreateInfo>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for GraphicsPipelineCreateInfoBuilder<'a> {
    type Target = GraphicsPipelineCreateInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for GraphicsPipelineCreateInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PipelineCacheCreateInfo`] with lifetime-tied pNext safety.
pub struct PipelineCacheCreateInfoBuilder<'a> {
    inner: PipelineCacheCreateInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PipelineCacheCreateInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PipelineCacheCreateInfoBuilder<'a> {
        PipelineCacheCreateInfoBuilder {
            inner: PipelineCacheCreateInfo {
                s_type: StructureType::from_raw(17i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PipelineCacheCreateInfoBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: PipelineCacheCreateFlags) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn initial_data(mut self, slice: &'a [core::ffi::c_void]) -> Self {
        self.inner.initial_data_size = slice.len();
        self.inner.p_initial_data = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`PipelineCacheCreateInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPipelineCacheCreateInfo>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for PipelineCacheCreateInfoBuilder<'a> {
    type Target = PipelineCacheCreateInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PipelineCacheCreateInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PipelineCacheHeaderVersionOne`].
pub struct PipelineCacheHeaderVersionOneBuilder {
    inner: PipelineCacheHeaderVersionOne,
}
impl PipelineCacheHeaderVersionOne {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> PipelineCacheHeaderVersionOneBuilder {
        PipelineCacheHeaderVersionOneBuilder {
            inner: PipelineCacheHeaderVersionOne {
                ..Default::default()
            },
        }
    }
}
impl PipelineCacheHeaderVersionOneBuilder {
    #[inline]
    pub fn header_size(mut self, value: u32) -> Self {
        self.inner.header_size = value;
        self
    }
    #[inline]
    pub fn header_version(mut self, value: PipelineCacheHeaderVersion) -> Self {
        self.inner.header_version = value;
        self
    }
    #[inline]
    pub fn vendor_id(mut self, value: u32) -> Self {
        self.inner.vendor_id = value;
        self
    }
    #[inline]
    pub fn device_id(mut self, value: u32) -> Self {
        self.inner.device_id = value;
        self
    }
    #[inline]
    pub fn pipeline_cache_uuid(mut self, value: [u8; UUID_SIZE as usize]) -> Self {
        self.inner.pipeline_cache_uuid = value;
        self
    }
}
impl core::ops::Deref for PipelineCacheHeaderVersionOneBuilder {
    type Target = PipelineCacheHeaderVersionOne;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for PipelineCacheHeaderVersionOneBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PipelineCacheStageValidationIndexEntry`].
pub struct PipelineCacheStageValidationIndexEntryBuilder {
    inner: PipelineCacheStageValidationIndexEntry,
}
impl PipelineCacheStageValidationIndexEntry {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> PipelineCacheStageValidationIndexEntryBuilder {
        PipelineCacheStageValidationIndexEntryBuilder {
            inner: PipelineCacheStageValidationIndexEntry {
                ..Default::default()
            },
        }
    }
}
impl PipelineCacheStageValidationIndexEntryBuilder {
    #[inline]
    pub fn code_size(mut self, value: u64) -> Self {
        self.inner.code_size = value;
        self
    }
    #[inline]
    pub fn code_offset(mut self, value: u64) -> Self {
        self.inner.code_offset = value;
        self
    }
}
impl core::ops::Deref for PipelineCacheStageValidationIndexEntryBuilder {
    type Target = PipelineCacheStageValidationIndexEntry;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for PipelineCacheStageValidationIndexEntryBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PipelineCacheSafetyCriticalIndexEntry`].
pub struct PipelineCacheSafetyCriticalIndexEntryBuilder {
    inner: PipelineCacheSafetyCriticalIndexEntry,
}
impl PipelineCacheSafetyCriticalIndexEntry {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> PipelineCacheSafetyCriticalIndexEntryBuilder {
        PipelineCacheSafetyCriticalIndexEntryBuilder {
            inner: PipelineCacheSafetyCriticalIndexEntry {
                ..Default::default()
            },
        }
    }
}
impl PipelineCacheSafetyCriticalIndexEntryBuilder {
    #[inline]
    pub fn pipeline_identifier(mut self, value: [u8; UUID_SIZE as usize]) -> Self {
        self.inner.pipeline_identifier = value;
        self
    }
    #[inline]
    pub fn pipeline_memory_size(mut self, value: u64) -> Self {
        self.inner.pipeline_memory_size = value;
        self
    }
    #[inline]
    pub fn json_size(mut self, value: u64) -> Self {
        self.inner.json_size = value;
        self
    }
    #[inline]
    pub fn json_offset(mut self, value: u64) -> Self {
        self.inner.json_offset = value;
        self
    }
    #[inline]
    pub fn stage_index_count(mut self, value: u32) -> Self {
        self.inner.stage_index_count = value;
        self
    }
    #[inline]
    pub fn stage_index_stride(mut self, value: u32) -> Self {
        self.inner.stage_index_stride = value;
        self
    }
    #[inline]
    pub fn stage_index_offset(mut self, value: u64) -> Self {
        self.inner.stage_index_offset = value;
        self
    }
}
impl core::ops::Deref for PipelineCacheSafetyCriticalIndexEntryBuilder {
    type Target = PipelineCacheSafetyCriticalIndexEntry;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for PipelineCacheSafetyCriticalIndexEntryBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PipelineCacheHeaderVersionSafetyCriticalOne`].
pub struct PipelineCacheHeaderVersionSafetyCriticalOneBuilder {
    inner: PipelineCacheHeaderVersionSafetyCriticalOne,
}
impl PipelineCacheHeaderVersionSafetyCriticalOne {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> PipelineCacheHeaderVersionSafetyCriticalOneBuilder {
        PipelineCacheHeaderVersionSafetyCriticalOneBuilder {
            inner: PipelineCacheHeaderVersionSafetyCriticalOne {
                ..Default::default()
            },
        }
    }
}
impl PipelineCacheHeaderVersionSafetyCriticalOneBuilder {
    #[inline]
    pub fn header_version_one(mut self, value: PipelineCacheHeaderVersionOne) -> Self {
        self.inner.header_version_one = value;
        self
    }
    #[inline]
    pub fn validation_version(mut self, value: PipelineCacheValidationVersion) -> Self {
        self.inner.validation_version = value;
        self
    }
    #[inline]
    pub fn implementation_data(mut self, value: u32) -> Self {
        self.inner.implementation_data = value;
        self
    }
    #[inline]
    pub fn pipeline_index_count(mut self, value: u32) -> Self {
        self.inner.pipeline_index_count = value;
        self
    }
    #[inline]
    pub fn pipeline_index_stride(mut self, value: u32) -> Self {
        self.inner.pipeline_index_stride = value;
        self
    }
    #[inline]
    pub fn pipeline_index_offset(mut self, value: u64) -> Self {
        self.inner.pipeline_index_offset = value;
        self
    }
}
impl core::ops::Deref for PipelineCacheHeaderVersionSafetyCriticalOneBuilder {
    type Target = PipelineCacheHeaderVersionSafetyCriticalOne;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for PipelineCacheHeaderVersionSafetyCriticalOneBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PipelineCacheHeaderVersionDataGraphQCOM`].
pub struct PipelineCacheHeaderVersionDataGraphQCOMBuilder {
    inner: PipelineCacheHeaderVersionDataGraphQCOM,
}
impl PipelineCacheHeaderVersionDataGraphQCOM {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> PipelineCacheHeaderVersionDataGraphQCOMBuilder {
        PipelineCacheHeaderVersionDataGraphQCOMBuilder {
            inner: PipelineCacheHeaderVersionDataGraphQCOM {
                ..Default::default()
            },
        }
    }
}
impl PipelineCacheHeaderVersionDataGraphQCOMBuilder {
    #[inline]
    pub fn header_size(mut self, value: u32) -> Self {
        self.inner.header_size = value;
        self
    }
    #[inline]
    pub fn header_version(mut self, value: PipelineCacheHeaderVersion) -> Self {
        self.inner.header_version = value;
        self
    }
    #[inline]
    pub fn cache_type(mut self, value: DataGraphModelCacheTypeQCOM) -> Self {
        self.inner.cache_type = value;
        self
    }
    #[inline]
    pub fn cache_version(mut self, value: u32) -> Self {
        self.inner.cache_version = value;
        self
    }
    #[inline]
    pub fn toolchain_version(
        mut self,
        value: [u32; DATA_GRAPH_MODEL_TOOLCHAIN_VERSION_LENGTH_QCOM as usize],
    ) -> Self {
        self.inner.toolchain_version = value;
        self
    }
}
impl core::ops::Deref for PipelineCacheHeaderVersionDataGraphQCOMBuilder {
    type Target = PipelineCacheHeaderVersionDataGraphQCOM;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for PipelineCacheHeaderVersionDataGraphQCOMBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PushConstantRange`].
pub struct PushConstantRangeBuilder {
    inner: PushConstantRange,
}
impl PushConstantRange {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> PushConstantRangeBuilder {
        PushConstantRangeBuilder {
            inner: PushConstantRange {
                ..Default::default()
            },
        }
    }
}
impl PushConstantRangeBuilder {
    #[inline]
    pub fn stage_flags(mut self, value: ShaderStageFlags) -> Self {
        self.inner.stage_flags = value;
        self
    }
    #[inline]
    pub fn offset(mut self, value: u32) -> Self {
        self.inner.offset = value;
        self
    }
    #[inline]
    pub fn size(mut self, value: u32) -> Self {
        self.inner.size = value;
        self
    }
}
impl core::ops::Deref for PushConstantRangeBuilder {
    type Target = PushConstantRange;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for PushConstantRangeBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PipelineBinaryCreateInfoKHR`] with lifetime-tied pNext safety.
pub struct PipelineBinaryCreateInfoKHRBuilder<'a> {
    inner: PipelineBinaryCreateInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PipelineBinaryCreateInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PipelineBinaryCreateInfoKHRBuilder<'a> {
        PipelineBinaryCreateInfoKHRBuilder {
            inner: PipelineBinaryCreateInfoKHR {
                s_type: StructureType::from_raw(1000483001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PipelineBinaryCreateInfoKHRBuilder<'a> {
    #[inline]
    pub fn keys_and_data_info(
        mut self,
        value: &'a PipelineBinaryKeysAndDataKHR,
    ) -> Self {
        self.inner.p_keys_and_data_info = value;
        self
    }
    #[inline]
    pub fn pipeline(mut self, value: Pipeline) -> Self {
        self.inner.pipeline = value;
        self
    }
    #[inline]
    pub fn pipeline_create_info(mut self, value: &'a PipelineCreateInfoKHR) -> Self {
        self.inner.p_pipeline_create_info = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PipelineBinaryCreateInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPipelineBinaryCreateInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for PipelineBinaryCreateInfoKHRBuilder<'a> {
    type Target = PipelineBinaryCreateInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PipelineBinaryCreateInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PipelineBinaryHandlesInfoKHR`] with lifetime-tied pNext safety.
pub struct PipelineBinaryHandlesInfoKHRBuilder<'a> {
    inner: PipelineBinaryHandlesInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PipelineBinaryHandlesInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PipelineBinaryHandlesInfoKHRBuilder<'a> {
        PipelineBinaryHandlesInfoKHRBuilder {
            inner: PipelineBinaryHandlesInfoKHR {
                s_type: StructureType::from_raw(1000483009i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PipelineBinaryHandlesInfoKHRBuilder<'a> {
    #[inline]
    pub fn pipeline_binary_count(mut self, value: u32) -> Self {
        self.inner.pipeline_binary_count = value;
        self
    }
    #[inline]
    pub fn pipeline_binaries(mut self, slice: &'a mut [PipelineBinaryKHR]) -> Self {
        self.inner.pipeline_binary_count = slice.len() as u32;
        self.inner.p_pipeline_binaries = slice.as_mut_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`PipelineBinaryHandlesInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPipelineBinaryHandlesInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for PipelineBinaryHandlesInfoKHRBuilder<'a> {
    type Target = PipelineBinaryHandlesInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PipelineBinaryHandlesInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PipelineBinaryDataKHR`].
pub struct PipelineBinaryDataKHRBuilder<'a> {
    inner: PipelineBinaryDataKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PipelineBinaryDataKHR {
    /// Start building this struct.
    #[inline]
    pub fn builder<'a>() -> PipelineBinaryDataKHRBuilder<'a> {
        PipelineBinaryDataKHRBuilder {
            inner: PipelineBinaryDataKHR {
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PipelineBinaryDataKHRBuilder<'a> {
    #[inline]
    pub fn data(mut self, slice: &'a mut [core::ffi::c_void]) -> Self {
        self.inner.data_size = slice.len();
        self.inner.p_data = slice.as_mut_ptr();
        self
    }
}
impl<'a> core::ops::Deref for PipelineBinaryDataKHRBuilder<'a> {
    type Target = PipelineBinaryDataKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PipelineBinaryDataKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PipelineBinaryKeysAndDataKHR`].
pub struct PipelineBinaryKeysAndDataKHRBuilder<'a> {
    inner: PipelineBinaryKeysAndDataKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PipelineBinaryKeysAndDataKHR {
    /// Start building this struct.
    #[inline]
    pub fn builder<'a>() -> PipelineBinaryKeysAndDataKHRBuilder<'a> {
        PipelineBinaryKeysAndDataKHRBuilder {
            inner: PipelineBinaryKeysAndDataKHR {
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PipelineBinaryKeysAndDataKHRBuilder<'a> {
    #[inline]
    pub fn pipeline_binary_keys(mut self, slice: &'a [PipelineBinaryKeyKHR]) -> Self {
        self.inner.binary_count = slice.len() as u32;
        self.inner.p_pipeline_binary_keys = slice.as_ptr();
        self
    }
    #[inline]
    pub fn pipeline_binary_data(mut self, slice: &'a [PipelineBinaryDataKHR]) -> Self {
        self.inner.binary_count = slice.len() as u32;
        self.inner.p_pipeline_binary_data = slice.as_ptr();
        self
    }
}
impl<'a> core::ops::Deref for PipelineBinaryKeysAndDataKHRBuilder<'a> {
    type Target = PipelineBinaryKeysAndDataKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PipelineBinaryKeysAndDataKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PipelineBinaryKeyKHR`] with lifetime-tied pNext safety.
pub struct PipelineBinaryKeyKHRBuilder<'a> {
    inner: PipelineBinaryKeyKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PipelineBinaryKeyKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PipelineBinaryKeyKHRBuilder<'a> {
        PipelineBinaryKeyKHRBuilder {
            inner: PipelineBinaryKeyKHR {
                s_type: StructureType::from_raw(1000483003i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PipelineBinaryKeyKHRBuilder<'a> {
    #[inline]
    pub fn key_size(mut self, value: u32) -> Self {
        self.inner.key_size = value;
        self
    }
    #[inline]
    pub fn key(
        mut self,
        value: [u8; MAX_PIPELINE_BINARY_KEY_SIZE_KHR as usize],
    ) -> Self {
        self.inner.key = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PipelineBinaryKeyKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPipelineBinaryKeyKHR>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PipelineBinaryKeyKHRBuilder<'a> {
    type Target = PipelineBinaryKeyKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PipelineBinaryKeyKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PipelineBinaryInfoKHR`] with lifetime-tied pNext safety.
pub struct PipelineBinaryInfoKHRBuilder<'a> {
    inner: PipelineBinaryInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PipelineBinaryInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PipelineBinaryInfoKHRBuilder<'a> {
        PipelineBinaryInfoKHRBuilder {
            inner: PipelineBinaryInfoKHR {
                s_type: StructureType::from_raw(1000483002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PipelineBinaryInfoKHRBuilder<'a> {
    #[inline]
    pub fn pipeline_binaries(mut self, slice: &'a [PipelineBinaryKHR]) -> Self {
        self.inner.binary_count = slice.len() as u32;
        self.inner.p_pipeline_binaries = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`PipelineBinaryInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPipelineBinaryInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for PipelineBinaryInfoKHRBuilder<'a> {
    type Target = PipelineBinaryInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PipelineBinaryInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ReleaseCapturedPipelineDataInfoKHR`] with lifetime-tied pNext safety.
pub struct ReleaseCapturedPipelineDataInfoKHRBuilder<'a> {
    inner: ReleaseCapturedPipelineDataInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ReleaseCapturedPipelineDataInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ReleaseCapturedPipelineDataInfoKHRBuilder<'a> {
        ReleaseCapturedPipelineDataInfoKHRBuilder {
            inner: ReleaseCapturedPipelineDataInfoKHR {
                s_type: StructureType::from_raw(1000483005i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ReleaseCapturedPipelineDataInfoKHRBuilder<'a> {
    #[inline]
    pub fn pipeline(mut self, value: Pipeline) -> Self {
        self.inner.pipeline = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`ReleaseCapturedPipelineDataInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsReleaseCapturedPipelineDataInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for ReleaseCapturedPipelineDataInfoKHRBuilder<'a> {
    type Target = ReleaseCapturedPipelineDataInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ReleaseCapturedPipelineDataInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PipelineBinaryDataInfoKHR`] with lifetime-tied pNext safety.
pub struct PipelineBinaryDataInfoKHRBuilder<'a> {
    inner: PipelineBinaryDataInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PipelineBinaryDataInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PipelineBinaryDataInfoKHRBuilder<'a> {
        PipelineBinaryDataInfoKHRBuilder {
            inner: PipelineBinaryDataInfoKHR {
                s_type: StructureType::from_raw(1000483006i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PipelineBinaryDataInfoKHRBuilder<'a> {
    #[inline]
    pub fn pipeline_binary(mut self, value: PipelineBinaryKHR) -> Self {
        self.inner.pipeline_binary = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PipelineBinaryDataInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPipelineBinaryDataInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PipelineBinaryDataInfoKHRBuilder<'a> {
    type Target = PipelineBinaryDataInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PipelineBinaryDataInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PipelineCreateInfoKHR`] with lifetime-tied pNext safety.
pub struct PipelineCreateInfoKHRBuilder<'a> {
    inner: PipelineCreateInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PipelineCreateInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PipelineCreateInfoKHRBuilder<'a> {
        PipelineCreateInfoKHRBuilder {
            inner: PipelineCreateInfoKHR {
                s_type: StructureType::from_raw(1000483007i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PipelineCreateInfoKHRBuilder<'a> {
    ///Prepend a struct to the pNext chain. See [`PipelineCreateInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPipelineCreateInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PipelineCreateInfoKHRBuilder<'a> {
    type Target = PipelineCreateInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PipelineCreateInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PipelineLayoutCreateInfo`] with lifetime-tied pNext safety.
pub struct PipelineLayoutCreateInfoBuilder<'a> {
    inner: PipelineLayoutCreateInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PipelineLayoutCreateInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PipelineLayoutCreateInfoBuilder<'a> {
        PipelineLayoutCreateInfoBuilder {
            inner: PipelineLayoutCreateInfo {
                s_type: StructureType::from_raw(30i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PipelineLayoutCreateInfoBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: PipelineLayoutCreateFlags) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn set_layout_count(mut self, value: u32) -> Self {
        self.inner.set_layout_count = value;
        self
    }
    #[inline]
    pub fn set_layouts(mut self, slice: &'a [DescriptorSetLayout]) -> Self {
        self.inner.set_layout_count = slice.len() as u32;
        self.inner.p_set_layouts = slice.as_ptr();
        self
    }
    #[inline]
    pub fn push_constant_ranges(mut self, slice: &'a [PushConstantRange]) -> Self {
        self.inner.push_constant_range_count = slice.len() as u32;
        self.inner.p_push_constant_ranges = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`PipelineLayoutCreateInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPipelineLayoutCreateInfo>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for PipelineLayoutCreateInfoBuilder<'a> {
    type Target = PipelineLayoutCreateInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PipelineLayoutCreateInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`SamplerCreateInfo`] with lifetime-tied pNext safety.
pub struct SamplerCreateInfoBuilder<'a> {
    inner: SamplerCreateInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl SamplerCreateInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> SamplerCreateInfoBuilder<'a> {
        SamplerCreateInfoBuilder {
            inner: SamplerCreateInfo {
                s_type: StructureType::from_raw(31i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> SamplerCreateInfoBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: SamplerCreateFlags) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn mag_filter(mut self, value: Filter) -> Self {
        self.inner.mag_filter = value;
        self
    }
    #[inline]
    pub fn min_filter(mut self, value: Filter) -> Self {
        self.inner.min_filter = value;
        self
    }
    #[inline]
    pub fn mipmap_mode(mut self, value: SamplerMipmapMode) -> Self {
        self.inner.mipmap_mode = value;
        self
    }
    #[inline]
    pub fn address_mode_u(mut self, value: SamplerAddressMode) -> Self {
        self.inner.address_mode_u = value;
        self
    }
    #[inline]
    pub fn address_mode_v(mut self, value: SamplerAddressMode) -> Self {
        self.inner.address_mode_v = value;
        self
    }
    #[inline]
    pub fn address_mode_w(mut self, value: SamplerAddressMode) -> Self {
        self.inner.address_mode_w = value;
        self
    }
    #[inline]
    pub fn mip_lod_bias(mut self, value: f32) -> Self {
        self.inner.mip_lod_bias = value;
        self
    }
    #[inline]
    pub fn anisotropy_enable(mut self, value: bool) -> Self {
        self.inner.anisotropy_enable = value as u32;
        self
    }
    #[inline]
    pub fn max_anisotropy(mut self, value: f32) -> Self {
        self.inner.max_anisotropy = value;
        self
    }
    #[inline]
    pub fn compare_enable(mut self, value: bool) -> Self {
        self.inner.compare_enable = value as u32;
        self
    }
    #[inline]
    pub fn compare_op(mut self, value: CompareOp) -> Self {
        self.inner.compare_op = value;
        self
    }
    #[inline]
    pub fn min_lod(mut self, value: f32) -> Self {
        self.inner.min_lod = value;
        self
    }
    #[inline]
    pub fn max_lod(mut self, value: f32) -> Self {
        self.inner.max_lod = value;
        self
    }
    #[inline]
    pub fn border_color(mut self, value: BorderColor) -> Self {
        self.inner.border_color = value;
        self
    }
    #[inline]
    pub fn unnormalized_coordinates(mut self, value: bool) -> Self {
        self.inner.unnormalized_coordinates = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`SamplerCreateInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsSamplerCreateInfo>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for SamplerCreateInfoBuilder<'a> {
    type Target = SamplerCreateInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for SamplerCreateInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`CommandPoolCreateInfo`] with lifetime-tied pNext safety.
pub struct CommandPoolCreateInfoBuilder<'a> {
    inner: CommandPoolCreateInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl CommandPoolCreateInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> CommandPoolCreateInfoBuilder<'a> {
        CommandPoolCreateInfoBuilder {
            inner: CommandPoolCreateInfo {
                s_type: StructureType::from_raw(39i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> CommandPoolCreateInfoBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: CommandPoolCreateFlags) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn queue_family_index(mut self, value: u32) -> Self {
        self.inner.queue_family_index = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`CommandPoolCreateInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsCommandPoolCreateInfo>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for CommandPoolCreateInfoBuilder<'a> {
    type Target = CommandPoolCreateInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for CommandPoolCreateInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`CommandBufferAllocateInfo`] with lifetime-tied pNext safety.
pub struct CommandBufferAllocateInfoBuilder<'a> {
    inner: CommandBufferAllocateInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl CommandBufferAllocateInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> CommandBufferAllocateInfoBuilder<'a> {
        CommandBufferAllocateInfoBuilder {
            inner: CommandBufferAllocateInfo {
                s_type: StructureType::from_raw(40i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> CommandBufferAllocateInfoBuilder<'a> {
    #[inline]
    pub fn command_pool(mut self, value: CommandPool) -> Self {
        self.inner.command_pool = value;
        self
    }
    #[inline]
    pub fn level(mut self, value: CommandBufferLevel) -> Self {
        self.inner.level = value;
        self
    }
    #[inline]
    pub fn command_buffer_count(mut self, value: u32) -> Self {
        self.inner.command_buffer_count = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`CommandBufferAllocateInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsCommandBufferAllocateInfo>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for CommandBufferAllocateInfoBuilder<'a> {
    type Target = CommandBufferAllocateInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for CommandBufferAllocateInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`CommandBufferInheritanceInfo`] with lifetime-tied pNext safety.
pub struct CommandBufferInheritanceInfoBuilder<'a> {
    inner: CommandBufferInheritanceInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl CommandBufferInheritanceInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> CommandBufferInheritanceInfoBuilder<'a> {
        CommandBufferInheritanceInfoBuilder {
            inner: CommandBufferInheritanceInfo {
                s_type: StructureType::from_raw(41i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> CommandBufferInheritanceInfoBuilder<'a> {
    #[inline]
    pub fn render_pass(mut self, value: RenderPass) -> Self {
        self.inner.render_pass = value;
        self
    }
    #[inline]
    pub fn subpass(mut self, value: u32) -> Self {
        self.inner.subpass = value;
        self
    }
    #[inline]
    pub fn framebuffer(mut self, value: Framebuffer) -> Self {
        self.inner.framebuffer = value;
        self
    }
    #[inline]
    pub fn occlusion_query_enable(mut self, value: bool) -> Self {
        self.inner.occlusion_query_enable = value as u32;
        self
    }
    #[inline]
    pub fn query_flags(mut self, value: QueryControlFlags) -> Self {
        self.inner.query_flags = value;
        self
    }
    #[inline]
    pub fn pipeline_statistics(mut self, value: QueryPipelineStatisticFlags) -> Self {
        self.inner.pipeline_statistics = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`CommandBufferInheritanceInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsCommandBufferInheritanceInfo>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for CommandBufferInheritanceInfoBuilder<'a> {
    type Target = CommandBufferInheritanceInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for CommandBufferInheritanceInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`CommandBufferBeginInfo`] with lifetime-tied pNext safety.
pub struct CommandBufferBeginInfoBuilder<'a> {
    inner: CommandBufferBeginInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl CommandBufferBeginInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> CommandBufferBeginInfoBuilder<'a> {
        CommandBufferBeginInfoBuilder {
            inner: CommandBufferBeginInfo {
                s_type: StructureType::from_raw(42i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> CommandBufferBeginInfoBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: CommandBufferUsageFlags) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn inheritance_info(mut self, value: &'a CommandBufferInheritanceInfo) -> Self {
        self.inner.p_inheritance_info = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`CommandBufferBeginInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsCommandBufferBeginInfo>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for CommandBufferBeginInfoBuilder<'a> {
    type Target = CommandBufferBeginInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for CommandBufferBeginInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`RenderPassBeginInfo`] with lifetime-tied pNext safety.
pub struct RenderPassBeginInfoBuilder<'a> {
    inner: RenderPassBeginInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl RenderPassBeginInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> RenderPassBeginInfoBuilder<'a> {
        RenderPassBeginInfoBuilder {
            inner: RenderPassBeginInfo {
                s_type: StructureType::from_raw(43i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> RenderPassBeginInfoBuilder<'a> {
    #[inline]
    pub fn render_pass(mut self, value: RenderPass) -> Self {
        self.inner.render_pass = value;
        self
    }
    #[inline]
    pub fn framebuffer(mut self, value: Framebuffer) -> Self {
        self.inner.framebuffer = value;
        self
    }
    #[inline]
    pub fn render_area(mut self, value: Rect2D) -> Self {
        self.inner.render_area = value;
        self
    }
    #[inline]
    pub fn clear_values(mut self, slice: &'a [ClearValue]) -> Self {
        self.inner.clear_value_count = slice.len() as u32;
        self.inner.p_clear_values = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`RenderPassBeginInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsRenderPassBeginInfo>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for RenderPassBeginInfoBuilder<'a> {
    type Target = RenderPassBeginInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for RenderPassBeginInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ClearDepthStencilValue`].
pub struct ClearDepthStencilValueBuilder {
    inner: ClearDepthStencilValue,
}
impl ClearDepthStencilValue {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> ClearDepthStencilValueBuilder {
        ClearDepthStencilValueBuilder {
            inner: ClearDepthStencilValue {
                ..Default::default()
            },
        }
    }
}
impl ClearDepthStencilValueBuilder {
    #[inline]
    pub fn depth(mut self, value: f32) -> Self {
        self.inner.depth = value;
        self
    }
    #[inline]
    pub fn stencil(mut self, value: u32) -> Self {
        self.inner.stencil = value;
        self
    }
}
impl core::ops::Deref for ClearDepthStencilValueBuilder {
    type Target = ClearDepthStencilValue;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for ClearDepthStencilValueBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ClearAttachment`].
pub struct ClearAttachmentBuilder {
    inner: ClearAttachment,
}
impl ClearAttachment {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> ClearAttachmentBuilder {
        ClearAttachmentBuilder {
            inner: ClearAttachment {
                ..Default::default()
            },
        }
    }
}
impl ClearAttachmentBuilder {
    #[inline]
    pub fn aspect_mask(mut self, value: ImageAspectFlags) -> Self {
        self.inner.aspect_mask = value;
        self
    }
    #[inline]
    pub fn color_attachment(mut self, value: u32) -> Self {
        self.inner.color_attachment = value;
        self
    }
    #[inline]
    pub fn clear_value(mut self, value: ClearValue) -> Self {
        self.inner.clear_value = value;
        self
    }
}
impl core::ops::Deref for ClearAttachmentBuilder {
    type Target = ClearAttachment;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for ClearAttachmentBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`AttachmentDescription`].
pub struct AttachmentDescriptionBuilder {
    inner: AttachmentDescription,
}
impl AttachmentDescription {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> AttachmentDescriptionBuilder {
        AttachmentDescriptionBuilder {
            inner: AttachmentDescription {
                ..Default::default()
            },
        }
    }
}
impl AttachmentDescriptionBuilder {
    #[inline]
    pub fn flags(mut self, value: AttachmentDescriptionFlags) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn format(mut self, value: Format) -> Self {
        self.inner.format = value;
        self
    }
    #[inline]
    pub fn samples(mut self, value: SampleCountFlagBits) -> Self {
        self.inner.samples = value;
        self
    }
    #[inline]
    pub fn load_op(mut self, value: AttachmentLoadOp) -> Self {
        self.inner.load_op = value;
        self
    }
    #[inline]
    pub fn store_op(mut self, value: AttachmentStoreOp) -> Self {
        self.inner.store_op = value;
        self
    }
    #[inline]
    pub fn stencil_load_op(mut self, value: AttachmentLoadOp) -> Self {
        self.inner.stencil_load_op = value;
        self
    }
    #[inline]
    pub fn stencil_store_op(mut self, value: AttachmentStoreOp) -> Self {
        self.inner.stencil_store_op = value;
        self
    }
    #[inline]
    pub fn initial_layout(mut self, value: ImageLayout) -> Self {
        self.inner.initial_layout = value;
        self
    }
    #[inline]
    pub fn final_layout(mut self, value: ImageLayout) -> Self {
        self.inner.final_layout = value;
        self
    }
}
impl core::ops::Deref for AttachmentDescriptionBuilder {
    type Target = AttachmentDescription;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for AttachmentDescriptionBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`AttachmentReference`].
pub struct AttachmentReferenceBuilder {
    inner: AttachmentReference,
}
impl AttachmentReference {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> AttachmentReferenceBuilder {
        AttachmentReferenceBuilder {
            inner: AttachmentReference {
                ..Default::default()
            },
        }
    }
}
impl AttachmentReferenceBuilder {
    #[inline]
    pub fn attachment(mut self, value: u32) -> Self {
        self.inner.attachment = value;
        self
    }
    #[inline]
    pub fn layout(mut self, value: ImageLayout) -> Self {
        self.inner.layout = value;
        self
    }
}
impl core::ops::Deref for AttachmentReferenceBuilder {
    type Target = AttachmentReference;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for AttachmentReferenceBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`SubpassDescription`].
pub struct SubpassDescriptionBuilder<'a> {
    inner: SubpassDescription,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl SubpassDescription {
    /// Start building this struct.
    #[inline]
    pub fn builder<'a>() -> SubpassDescriptionBuilder<'a> {
        SubpassDescriptionBuilder {
            inner: SubpassDescription {
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> SubpassDescriptionBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: SubpassDescriptionFlags) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn pipeline_bind_point(mut self, value: PipelineBindPoint) -> Self {
        self.inner.pipeline_bind_point = value;
        self
    }
    #[inline]
    pub fn input_attachments(mut self, slice: &'a [AttachmentReference]) -> Self {
        self.inner.input_attachment_count = slice.len() as u32;
        self.inner.p_input_attachments = slice.as_ptr();
        self
    }
    #[inline]
    pub fn color_attachments(mut self, slice: &'a [AttachmentReference]) -> Self {
        self.inner.color_attachment_count = slice.len() as u32;
        self.inner.p_color_attachments = slice.as_ptr();
        self
    }
    #[inline]
    pub fn resolve_attachments(mut self, slice: &'a [AttachmentReference]) -> Self {
        self.inner.color_attachment_count = slice.len() as u32;
        self.inner.p_resolve_attachments = slice.as_ptr();
        self
    }
    #[inline]
    pub fn depth_stencil_attachment(mut self, value: &'a AttachmentReference) -> Self {
        self.inner.p_depth_stencil_attachment = value;
        self
    }
    #[inline]
    pub fn preserve_attachments(mut self, slice: &'a [u32]) -> Self {
        self.inner.preserve_attachment_count = slice.len() as u32;
        self.inner.p_preserve_attachments = slice.as_ptr();
        self
    }
}
impl<'a> core::ops::Deref for SubpassDescriptionBuilder<'a> {
    type Target = SubpassDescription;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for SubpassDescriptionBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`SubpassDependency`].
pub struct SubpassDependencyBuilder {
    inner: SubpassDependency,
}
impl SubpassDependency {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> SubpassDependencyBuilder {
        SubpassDependencyBuilder {
            inner: SubpassDependency {
                ..Default::default()
            },
        }
    }
}
impl SubpassDependencyBuilder {
    #[inline]
    pub fn src_subpass(mut self, value: u32) -> Self {
        self.inner.src_subpass = value;
        self
    }
    #[inline]
    pub fn dst_subpass(mut self, value: u32) -> Self {
        self.inner.dst_subpass = value;
        self
    }
    #[inline]
    pub fn src_stage_mask(mut self, value: PipelineStageFlags) -> Self {
        self.inner.src_stage_mask = value;
        self
    }
    #[inline]
    pub fn dst_stage_mask(mut self, value: PipelineStageFlags) -> Self {
        self.inner.dst_stage_mask = value;
        self
    }
    #[inline]
    pub fn src_access_mask(mut self, value: AccessFlags) -> Self {
        self.inner.src_access_mask = value;
        self
    }
    #[inline]
    pub fn dst_access_mask(mut self, value: AccessFlags) -> Self {
        self.inner.dst_access_mask = value;
        self
    }
    #[inline]
    pub fn dependency_flags(mut self, value: DependencyFlags) -> Self {
        self.inner.dependency_flags = value;
        self
    }
}
impl core::ops::Deref for SubpassDependencyBuilder {
    type Target = SubpassDependency;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for SubpassDependencyBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`RenderPassCreateInfo`] with lifetime-tied pNext safety.
pub struct RenderPassCreateInfoBuilder<'a> {
    inner: RenderPassCreateInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl RenderPassCreateInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> RenderPassCreateInfoBuilder<'a> {
        RenderPassCreateInfoBuilder {
            inner: RenderPassCreateInfo {
                s_type: StructureType::from_raw(38i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> RenderPassCreateInfoBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: RenderPassCreateFlags) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn attachments(mut self, slice: &'a [AttachmentDescription]) -> Self {
        self.inner.attachment_count = slice.len() as u32;
        self.inner.p_attachments = slice.as_ptr();
        self
    }
    #[inline]
    pub fn subpasses(mut self, slice: &'a [SubpassDescription]) -> Self {
        self.inner.subpass_count = slice.len() as u32;
        self.inner.p_subpasses = slice.as_ptr();
        self
    }
    #[inline]
    pub fn dependencies(mut self, slice: &'a [SubpassDependency]) -> Self {
        self.inner.dependency_count = slice.len() as u32;
        self.inner.p_dependencies = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`RenderPassCreateInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsRenderPassCreateInfo>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for RenderPassCreateInfoBuilder<'a> {
    type Target = RenderPassCreateInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for RenderPassCreateInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`EventCreateInfo`] with lifetime-tied pNext safety.
pub struct EventCreateInfoBuilder<'a> {
    inner: EventCreateInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl EventCreateInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> EventCreateInfoBuilder<'a> {
        EventCreateInfoBuilder {
            inner: EventCreateInfo {
                s_type: StructureType::from_raw(10i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> EventCreateInfoBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: EventCreateFlags) -> Self {
        self.inner.flags = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`EventCreateInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsEventCreateInfo>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for EventCreateInfoBuilder<'a> {
    type Target = EventCreateInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for EventCreateInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`FenceCreateInfo`] with lifetime-tied pNext safety.
pub struct FenceCreateInfoBuilder<'a> {
    inner: FenceCreateInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl FenceCreateInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> FenceCreateInfoBuilder<'a> {
        FenceCreateInfoBuilder {
            inner: FenceCreateInfo {
                s_type: StructureType::from_raw(8i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> FenceCreateInfoBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: FenceCreateFlags) -> Self {
        self.inner.flags = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`FenceCreateInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsFenceCreateInfo>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for FenceCreateInfoBuilder<'a> {
    type Target = FenceCreateInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for FenceCreateInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceFeatures`].
pub struct PhysicalDeviceFeaturesBuilder {
    inner: PhysicalDeviceFeatures,
}
impl PhysicalDeviceFeatures {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> PhysicalDeviceFeaturesBuilder {
        PhysicalDeviceFeaturesBuilder {
            inner: PhysicalDeviceFeatures {
                ..Default::default()
            },
        }
    }
}
impl PhysicalDeviceFeaturesBuilder {
    #[inline]
    pub fn robust_buffer_access(mut self, value: bool) -> Self {
        self.inner.robust_buffer_access = value as u32;
        self
    }
    #[inline]
    pub fn full_draw_index_uint32(mut self, value: bool) -> Self {
        self.inner.full_draw_index_uint32 = value as u32;
        self
    }
    #[inline]
    pub fn image_cube_array(mut self, value: bool) -> Self {
        self.inner.image_cube_array = value as u32;
        self
    }
    #[inline]
    pub fn independent_blend(mut self, value: bool) -> Self {
        self.inner.independent_blend = value as u32;
        self
    }
    #[inline]
    pub fn geometry_shader(mut self, value: bool) -> Self {
        self.inner.geometry_shader = value as u32;
        self
    }
    #[inline]
    pub fn tessellation_shader(mut self, value: bool) -> Self {
        self.inner.tessellation_shader = value as u32;
        self
    }
    #[inline]
    pub fn sample_rate_shading(mut self, value: bool) -> Self {
        self.inner.sample_rate_shading = value as u32;
        self
    }
    #[inline]
    pub fn dual_src_blend(mut self, value: bool) -> Self {
        self.inner.dual_src_blend = value as u32;
        self
    }
    #[inline]
    pub fn logic_op(mut self, value: bool) -> Self {
        self.inner.logic_op = value as u32;
        self
    }
    #[inline]
    pub fn multi_draw_indirect(mut self, value: bool) -> Self {
        self.inner.multi_draw_indirect = value as u32;
        self
    }
    #[inline]
    pub fn draw_indirect_first_instance(mut self, value: bool) -> Self {
        self.inner.draw_indirect_first_instance = value as u32;
        self
    }
    #[inline]
    pub fn depth_clamp(mut self, value: bool) -> Self {
        self.inner.depth_clamp = value as u32;
        self
    }
    #[inline]
    pub fn depth_bias_clamp(mut self, value: bool) -> Self {
        self.inner.depth_bias_clamp = value as u32;
        self
    }
    #[inline]
    pub fn fill_mode_non_solid(mut self, value: bool) -> Self {
        self.inner.fill_mode_non_solid = value as u32;
        self
    }
    #[inline]
    pub fn depth_bounds(mut self, value: bool) -> Self {
        self.inner.depth_bounds = value as u32;
        self
    }
    #[inline]
    pub fn wide_lines(mut self, value: bool) -> Self {
        self.inner.wide_lines = value as u32;
        self
    }
    #[inline]
    pub fn large_points(mut self, value: bool) -> Self {
        self.inner.large_points = value as u32;
        self
    }
    #[inline]
    pub fn alpha_to_one(mut self, value: bool) -> Self {
        self.inner.alpha_to_one = value as u32;
        self
    }
    #[inline]
    pub fn multi_viewport(mut self, value: bool) -> Self {
        self.inner.multi_viewport = value as u32;
        self
    }
    #[inline]
    pub fn sampler_anisotropy(mut self, value: bool) -> Self {
        self.inner.sampler_anisotropy = value as u32;
        self
    }
    #[inline]
    pub fn texture_compression_etc2(mut self, value: bool) -> Self {
        self.inner.texture_compression_etc2 = value as u32;
        self
    }
    #[inline]
    pub fn texture_compression_astc_ldr(mut self, value: bool) -> Self {
        self.inner.texture_compression_astc_ldr = value as u32;
        self
    }
    #[inline]
    pub fn texture_compression_bc(mut self, value: bool) -> Self {
        self.inner.texture_compression_bc = value as u32;
        self
    }
    #[inline]
    pub fn occlusion_query_precise(mut self, value: bool) -> Self {
        self.inner.occlusion_query_precise = value as u32;
        self
    }
    #[inline]
    pub fn pipeline_statistics_query(mut self, value: bool) -> Self {
        self.inner.pipeline_statistics_query = value as u32;
        self
    }
    #[inline]
    pub fn vertex_pipeline_stores_and_atomics(mut self, value: bool) -> Self {
        self.inner.vertex_pipeline_stores_and_atomics = value as u32;
        self
    }
    #[inline]
    pub fn fragment_stores_and_atomics(mut self, value: bool) -> Self {
        self.inner.fragment_stores_and_atomics = value as u32;
        self
    }
    #[inline]
    pub fn shader_tessellation_and_geometry_point_size(mut self, value: bool) -> Self {
        self.inner.shader_tessellation_and_geometry_point_size = value as u32;
        self
    }
    #[inline]
    pub fn shader_image_gather_extended(mut self, value: bool) -> Self {
        self.inner.shader_image_gather_extended = value as u32;
        self
    }
    #[inline]
    pub fn shader_storage_image_extended_formats(mut self, value: bool) -> Self {
        self.inner.shader_storage_image_extended_formats = value as u32;
        self
    }
    #[inline]
    pub fn shader_storage_image_multisample(mut self, value: bool) -> Self {
        self.inner.shader_storage_image_multisample = value as u32;
        self
    }
    #[inline]
    pub fn shader_storage_image_read_without_format(mut self, value: bool) -> Self {
        self.inner.shader_storage_image_read_without_format = value as u32;
        self
    }
    #[inline]
    pub fn shader_storage_image_write_without_format(mut self, value: bool) -> Self {
        self.inner.shader_storage_image_write_without_format = value as u32;
        self
    }
    #[inline]
    pub fn shader_uniform_buffer_array_dynamic_indexing(mut self, value: bool) -> Self {
        self.inner.shader_uniform_buffer_array_dynamic_indexing = value as u32;
        self
    }
    #[inline]
    pub fn shader_sampled_image_array_dynamic_indexing(mut self, value: bool) -> Self {
        self.inner.shader_sampled_image_array_dynamic_indexing = value as u32;
        self
    }
    #[inline]
    pub fn shader_storage_buffer_array_dynamic_indexing(mut self, value: bool) -> Self {
        self.inner.shader_storage_buffer_array_dynamic_indexing = value as u32;
        self
    }
    #[inline]
    pub fn shader_storage_image_array_dynamic_indexing(mut self, value: bool) -> Self {
        self.inner.shader_storage_image_array_dynamic_indexing = value as u32;
        self
    }
    #[inline]
    pub fn shader_clip_distance(mut self, value: bool) -> Self {
        self.inner.shader_clip_distance = value as u32;
        self
    }
    #[inline]
    pub fn shader_cull_distance(mut self, value: bool) -> Self {
        self.inner.shader_cull_distance = value as u32;
        self
    }
    #[inline]
    pub fn shader_float64(mut self, value: bool) -> Self {
        self.inner.shader_float64 = value as u32;
        self
    }
    #[inline]
    pub fn shader_int64(mut self, value: bool) -> Self {
        self.inner.shader_int64 = value as u32;
        self
    }
    #[inline]
    pub fn shader_int16(mut self, value: bool) -> Self {
        self.inner.shader_int16 = value as u32;
        self
    }
    #[inline]
    pub fn shader_resource_residency(mut self, value: bool) -> Self {
        self.inner.shader_resource_residency = value as u32;
        self
    }
    #[inline]
    pub fn shader_resource_min_lod(mut self, value: bool) -> Self {
        self.inner.shader_resource_min_lod = value as u32;
        self
    }
    #[inline]
    pub fn sparse_binding(mut self, value: bool) -> Self {
        self.inner.sparse_binding = value as u32;
        self
    }
    #[inline]
    pub fn sparse_residency_buffer(mut self, value: bool) -> Self {
        self.inner.sparse_residency_buffer = value as u32;
        self
    }
    #[inline]
    pub fn sparse_residency_image2_d(mut self, value: bool) -> Self {
        self.inner.sparse_residency_image2_d = value as u32;
        self
    }
    #[inline]
    pub fn sparse_residency_image3_d(mut self, value: bool) -> Self {
        self.inner.sparse_residency_image3_d = value as u32;
        self
    }
    #[inline]
    pub fn sparse_residency2_samples(mut self, value: bool) -> Self {
        self.inner.sparse_residency2_samples = value as u32;
        self
    }
    #[inline]
    pub fn sparse_residency4_samples(mut self, value: bool) -> Self {
        self.inner.sparse_residency4_samples = value as u32;
        self
    }
    #[inline]
    pub fn sparse_residency8_samples(mut self, value: bool) -> Self {
        self.inner.sparse_residency8_samples = value as u32;
        self
    }
    #[inline]
    pub fn sparse_residency16_samples(mut self, value: bool) -> Self {
        self.inner.sparse_residency16_samples = value as u32;
        self
    }
    #[inline]
    pub fn sparse_residency_aliased(mut self, value: bool) -> Self {
        self.inner.sparse_residency_aliased = value as u32;
        self
    }
    #[inline]
    pub fn variable_multisample_rate(mut self, value: bool) -> Self {
        self.inner.variable_multisample_rate = value as u32;
        self
    }
    #[inline]
    pub fn inherited_queries(mut self, value: bool) -> Self {
        self.inner.inherited_queries = value as u32;
        self
    }
}
impl core::ops::Deref for PhysicalDeviceFeaturesBuilder {
    type Target = PhysicalDeviceFeatures;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for PhysicalDeviceFeaturesBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceSparseProperties`].
pub struct PhysicalDeviceSparsePropertiesBuilder {
    inner: PhysicalDeviceSparseProperties,
}
impl PhysicalDeviceSparseProperties {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> PhysicalDeviceSparsePropertiesBuilder {
        PhysicalDeviceSparsePropertiesBuilder {
            inner: PhysicalDeviceSparseProperties {
                ..Default::default()
            },
        }
    }
}
impl PhysicalDeviceSparsePropertiesBuilder {
    #[inline]
    pub fn residency_standard2_d_block_shape(mut self, value: bool) -> Self {
        self.inner.residency_standard2_d_block_shape = value as u32;
        self
    }
    #[inline]
    pub fn residency_standard2_d_multisample_block_shape(mut self, value: bool) -> Self {
        self.inner.residency_standard2_d_multisample_block_shape = value as u32;
        self
    }
    #[inline]
    pub fn residency_standard3_d_block_shape(mut self, value: bool) -> Self {
        self.inner.residency_standard3_d_block_shape = value as u32;
        self
    }
    #[inline]
    pub fn residency_aligned_mip_size(mut self, value: bool) -> Self {
        self.inner.residency_aligned_mip_size = value as u32;
        self
    }
    #[inline]
    pub fn residency_non_resident_strict(mut self, value: bool) -> Self {
        self.inner.residency_non_resident_strict = value as u32;
        self
    }
}
impl core::ops::Deref for PhysicalDeviceSparsePropertiesBuilder {
    type Target = PhysicalDeviceSparseProperties;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for PhysicalDeviceSparsePropertiesBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceLimits`].
pub struct PhysicalDeviceLimitsBuilder {
    inner: PhysicalDeviceLimits,
}
impl PhysicalDeviceLimits {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> PhysicalDeviceLimitsBuilder {
        PhysicalDeviceLimitsBuilder {
            inner: PhysicalDeviceLimits {
                ..Default::default()
            },
        }
    }
}
impl PhysicalDeviceLimitsBuilder {
    #[inline]
    pub fn max_image_dimension1_d(mut self, value: u32) -> Self {
        self.inner.max_image_dimension1_d = value;
        self
    }
    #[inline]
    pub fn max_image_dimension2_d(mut self, value: u32) -> Self {
        self.inner.max_image_dimension2_d = value;
        self
    }
    #[inline]
    pub fn max_image_dimension3_d(mut self, value: u32) -> Self {
        self.inner.max_image_dimension3_d = value;
        self
    }
    #[inline]
    pub fn max_image_dimension_cube(mut self, value: u32) -> Self {
        self.inner.max_image_dimension_cube = value;
        self
    }
    #[inline]
    pub fn max_image_array_layers(mut self, value: u32) -> Self {
        self.inner.max_image_array_layers = value;
        self
    }
    #[inline]
    pub fn max_texel_buffer_elements(mut self, value: u32) -> Self {
        self.inner.max_texel_buffer_elements = value;
        self
    }
    #[inline]
    pub fn max_uniform_buffer_range(mut self, value: u32) -> Self {
        self.inner.max_uniform_buffer_range = value;
        self
    }
    #[inline]
    pub fn max_storage_buffer_range(mut self, value: u32) -> Self {
        self.inner.max_storage_buffer_range = value;
        self
    }
    #[inline]
    pub fn max_push_constants_size(mut self, value: u32) -> Self {
        self.inner.max_push_constants_size = value;
        self
    }
    #[inline]
    pub fn max_memory_allocation_count(mut self, value: u32) -> Self {
        self.inner.max_memory_allocation_count = value;
        self
    }
    #[inline]
    pub fn max_sampler_allocation_count(mut self, value: u32) -> Self {
        self.inner.max_sampler_allocation_count = value;
        self
    }
    #[inline]
    pub fn buffer_image_granularity(mut self, value: u64) -> Self {
        self.inner.buffer_image_granularity = value;
        self
    }
    #[inline]
    pub fn sparse_address_space_size(mut self, value: u64) -> Self {
        self.inner.sparse_address_space_size = value;
        self
    }
    #[inline]
    pub fn max_bound_descriptor_sets(mut self, value: u32) -> Self {
        self.inner.max_bound_descriptor_sets = value;
        self
    }
    #[inline]
    pub fn max_per_stage_descriptor_samplers(mut self, value: u32) -> Self {
        self.inner.max_per_stage_descriptor_samplers = value;
        self
    }
    #[inline]
    pub fn max_per_stage_descriptor_uniform_buffers(mut self, value: u32) -> Self {
        self.inner.max_per_stage_descriptor_uniform_buffers = value;
        self
    }
    #[inline]
    pub fn max_per_stage_descriptor_storage_buffers(mut self, value: u32) -> Self {
        self.inner.max_per_stage_descriptor_storage_buffers = value;
        self
    }
    #[inline]
    pub fn max_per_stage_descriptor_sampled_images(mut self, value: u32) -> Self {
        self.inner.max_per_stage_descriptor_sampled_images = value;
        self
    }
    #[inline]
    pub fn max_per_stage_descriptor_storage_images(mut self, value: u32) -> Self {
        self.inner.max_per_stage_descriptor_storage_images = value;
        self
    }
    #[inline]
    pub fn max_per_stage_descriptor_input_attachments(mut self, value: u32) -> Self {
        self.inner.max_per_stage_descriptor_input_attachments = value;
        self
    }
    #[inline]
    pub fn max_per_stage_resources(mut self, value: u32) -> Self {
        self.inner.max_per_stage_resources = value;
        self
    }
    #[inline]
    pub fn max_descriptor_set_samplers(mut self, value: u32) -> Self {
        self.inner.max_descriptor_set_samplers = value;
        self
    }
    #[inline]
    pub fn max_descriptor_set_uniform_buffers(mut self, value: u32) -> Self {
        self.inner.max_descriptor_set_uniform_buffers = value;
        self
    }
    #[inline]
    pub fn max_descriptor_set_uniform_buffers_dynamic(mut self, value: u32) -> Self {
        self.inner.max_descriptor_set_uniform_buffers_dynamic = value;
        self
    }
    #[inline]
    pub fn max_descriptor_set_storage_buffers(mut self, value: u32) -> Self {
        self.inner.max_descriptor_set_storage_buffers = value;
        self
    }
    #[inline]
    pub fn max_descriptor_set_storage_buffers_dynamic(mut self, value: u32) -> Self {
        self.inner.max_descriptor_set_storage_buffers_dynamic = value;
        self
    }
    #[inline]
    pub fn max_descriptor_set_sampled_images(mut self, value: u32) -> Self {
        self.inner.max_descriptor_set_sampled_images = value;
        self
    }
    #[inline]
    pub fn max_descriptor_set_storage_images(mut self, value: u32) -> Self {
        self.inner.max_descriptor_set_storage_images = value;
        self
    }
    #[inline]
    pub fn max_descriptor_set_input_attachments(mut self, value: u32) -> Self {
        self.inner.max_descriptor_set_input_attachments = value;
        self
    }
    #[inline]
    pub fn max_vertex_input_attributes(mut self, value: u32) -> Self {
        self.inner.max_vertex_input_attributes = value;
        self
    }
    #[inline]
    pub fn max_vertex_input_bindings(mut self, value: u32) -> Self {
        self.inner.max_vertex_input_bindings = value;
        self
    }
    #[inline]
    pub fn max_vertex_input_attribute_offset(mut self, value: u32) -> Self {
        self.inner.max_vertex_input_attribute_offset = value;
        self
    }
    #[inline]
    pub fn max_vertex_input_binding_stride(mut self, value: u32) -> Self {
        self.inner.max_vertex_input_binding_stride = value;
        self
    }
    #[inline]
    pub fn max_vertex_output_components(mut self, value: u32) -> Self {
        self.inner.max_vertex_output_components = value;
        self
    }
    #[inline]
    pub fn max_tessellation_generation_level(mut self, value: u32) -> Self {
        self.inner.max_tessellation_generation_level = value;
        self
    }
    #[inline]
    pub fn max_tessellation_patch_size(mut self, value: u32) -> Self {
        self.inner.max_tessellation_patch_size = value;
        self
    }
    #[inline]
    pub fn max_tessellation_control_per_vertex_input_components(
        mut self,
        value: u32,
    ) -> Self {
        self.inner.max_tessellation_control_per_vertex_input_components = value;
        self
    }
    #[inline]
    pub fn max_tessellation_control_per_vertex_output_components(
        mut self,
        value: u32,
    ) -> Self {
        self.inner.max_tessellation_control_per_vertex_output_components = value;
        self
    }
    #[inline]
    pub fn max_tessellation_control_per_patch_output_components(
        mut self,
        value: u32,
    ) -> Self {
        self.inner.max_tessellation_control_per_patch_output_components = value;
        self
    }
    #[inline]
    pub fn max_tessellation_control_total_output_components(
        mut self,
        value: u32,
    ) -> Self {
        self.inner.max_tessellation_control_total_output_components = value;
        self
    }
    #[inline]
    pub fn max_tessellation_evaluation_input_components(mut self, value: u32) -> Self {
        self.inner.max_tessellation_evaluation_input_components = value;
        self
    }
    #[inline]
    pub fn max_tessellation_evaluation_output_components(mut self, value: u32) -> Self {
        self.inner.max_tessellation_evaluation_output_components = value;
        self
    }
    #[inline]
    pub fn max_geometry_shader_invocations(mut self, value: u32) -> Self {
        self.inner.max_geometry_shader_invocations = value;
        self
    }
    #[inline]
    pub fn max_geometry_input_components(mut self, value: u32) -> Self {
        self.inner.max_geometry_input_components = value;
        self
    }
    #[inline]
    pub fn max_geometry_output_components(mut self, value: u32) -> Self {
        self.inner.max_geometry_output_components = value;
        self
    }
    #[inline]
    pub fn max_geometry_output_vertices(mut self, value: u32) -> Self {
        self.inner.max_geometry_output_vertices = value;
        self
    }
    #[inline]
    pub fn max_geometry_total_output_components(mut self, value: u32) -> Self {
        self.inner.max_geometry_total_output_components = value;
        self
    }
    #[inline]
    pub fn max_fragment_input_components(mut self, value: u32) -> Self {
        self.inner.max_fragment_input_components = value;
        self
    }
    #[inline]
    pub fn max_fragment_output_attachments(mut self, value: u32) -> Self {
        self.inner.max_fragment_output_attachments = value;
        self
    }
    #[inline]
    pub fn max_fragment_dual_src_attachments(mut self, value: u32) -> Self {
        self.inner.max_fragment_dual_src_attachments = value;
        self
    }
    #[inline]
    pub fn max_fragment_combined_output_resources(mut self, value: u32) -> Self {
        self.inner.max_fragment_combined_output_resources = value;
        self
    }
    #[inline]
    pub fn max_compute_shared_memory_size(mut self, value: u32) -> Self {
        self.inner.max_compute_shared_memory_size = value;
        self
    }
    #[inline]
    pub fn max_compute_work_group_count(mut self, value: [u32; 3usize]) -> Self {
        self.inner.max_compute_work_group_count = value;
        self
    }
    #[inline]
    pub fn max_compute_work_group_invocations(mut self, value: u32) -> Self {
        self.inner.max_compute_work_group_invocations = value;
        self
    }
    #[inline]
    pub fn max_compute_work_group_size(mut self, value: [u32; 3usize]) -> Self {
        self.inner.max_compute_work_group_size = value;
        self
    }
    #[inline]
    pub fn sub_pixel_precision_bits(mut self, value: u32) -> Self {
        self.inner.sub_pixel_precision_bits = value;
        self
    }
    #[inline]
    pub fn sub_texel_precision_bits(mut self, value: u32) -> Self {
        self.inner.sub_texel_precision_bits = value;
        self
    }
    #[inline]
    pub fn mipmap_precision_bits(mut self, value: u32) -> Self {
        self.inner.mipmap_precision_bits = value;
        self
    }
    #[inline]
    pub fn max_draw_indexed_index_value(mut self, value: u32) -> Self {
        self.inner.max_draw_indexed_index_value = value;
        self
    }
    #[inline]
    pub fn max_draw_indirect_count(mut self, value: u32) -> Self {
        self.inner.max_draw_indirect_count = value;
        self
    }
    #[inline]
    pub fn max_sampler_lod_bias(mut self, value: f32) -> Self {
        self.inner.max_sampler_lod_bias = value;
        self
    }
    #[inline]
    pub fn max_sampler_anisotropy(mut self, value: f32) -> Self {
        self.inner.max_sampler_anisotropy = value;
        self
    }
    #[inline]
    pub fn max_viewports(mut self, value: u32) -> Self {
        self.inner.max_viewports = value;
        self
    }
    #[inline]
    pub fn max_viewport_dimensions(mut self, value: [u32; 2usize]) -> Self {
        self.inner.max_viewport_dimensions = value;
        self
    }
    #[inline]
    pub fn viewport_bounds_range(mut self, value: [f32; 2usize]) -> Self {
        self.inner.viewport_bounds_range = value;
        self
    }
    #[inline]
    pub fn viewport_sub_pixel_bits(mut self, value: u32) -> Self {
        self.inner.viewport_sub_pixel_bits = value;
        self
    }
    #[inline]
    pub fn min_memory_map_alignment(mut self, value: usize) -> Self {
        self.inner.min_memory_map_alignment = value;
        self
    }
    #[inline]
    pub fn min_texel_buffer_offset_alignment(mut self, value: u64) -> Self {
        self.inner.min_texel_buffer_offset_alignment = value;
        self
    }
    #[inline]
    pub fn min_uniform_buffer_offset_alignment(mut self, value: u64) -> Self {
        self.inner.min_uniform_buffer_offset_alignment = value;
        self
    }
    #[inline]
    pub fn min_storage_buffer_offset_alignment(mut self, value: u64) -> Self {
        self.inner.min_storage_buffer_offset_alignment = value;
        self
    }
    #[inline]
    pub fn min_texel_offset(mut self, value: i32) -> Self {
        self.inner.min_texel_offset = value;
        self
    }
    #[inline]
    pub fn max_texel_offset(mut self, value: u32) -> Self {
        self.inner.max_texel_offset = value;
        self
    }
    #[inline]
    pub fn min_texel_gather_offset(mut self, value: i32) -> Self {
        self.inner.min_texel_gather_offset = value;
        self
    }
    #[inline]
    pub fn max_texel_gather_offset(mut self, value: u32) -> Self {
        self.inner.max_texel_gather_offset = value;
        self
    }
    #[inline]
    pub fn min_interpolation_offset(mut self, value: f32) -> Self {
        self.inner.min_interpolation_offset = value;
        self
    }
    #[inline]
    pub fn max_interpolation_offset(mut self, value: f32) -> Self {
        self.inner.max_interpolation_offset = value;
        self
    }
    #[inline]
    pub fn sub_pixel_interpolation_offset_bits(mut self, value: u32) -> Self {
        self.inner.sub_pixel_interpolation_offset_bits = value;
        self
    }
    #[inline]
    pub fn max_framebuffer_width(mut self, value: u32) -> Self {
        self.inner.max_framebuffer_width = value;
        self
    }
    #[inline]
    pub fn max_framebuffer_height(mut self, value: u32) -> Self {
        self.inner.max_framebuffer_height = value;
        self
    }
    #[inline]
    pub fn max_framebuffer_layers(mut self, value: u32) -> Self {
        self.inner.max_framebuffer_layers = value;
        self
    }
    #[inline]
    pub fn framebuffer_color_sample_counts(mut self, value: SampleCountFlags) -> Self {
        self.inner.framebuffer_color_sample_counts = value;
        self
    }
    #[inline]
    pub fn framebuffer_depth_sample_counts(mut self, value: SampleCountFlags) -> Self {
        self.inner.framebuffer_depth_sample_counts = value;
        self
    }
    #[inline]
    pub fn framebuffer_stencil_sample_counts(mut self, value: SampleCountFlags) -> Self {
        self.inner.framebuffer_stencil_sample_counts = value;
        self
    }
    #[inline]
    pub fn framebuffer_no_attachments_sample_counts(
        mut self,
        value: SampleCountFlags,
    ) -> Self {
        self.inner.framebuffer_no_attachments_sample_counts = value;
        self
    }
    #[inline]
    pub fn max_color_attachments(mut self, value: u32) -> Self {
        self.inner.max_color_attachments = value;
        self
    }
    #[inline]
    pub fn sampled_image_color_sample_counts(mut self, value: SampleCountFlags) -> Self {
        self.inner.sampled_image_color_sample_counts = value;
        self
    }
    #[inline]
    pub fn sampled_image_integer_sample_counts(
        mut self,
        value: SampleCountFlags,
    ) -> Self {
        self.inner.sampled_image_integer_sample_counts = value;
        self
    }
    #[inline]
    pub fn sampled_image_depth_sample_counts(mut self, value: SampleCountFlags) -> Self {
        self.inner.sampled_image_depth_sample_counts = value;
        self
    }
    #[inline]
    pub fn sampled_image_stencil_sample_counts(
        mut self,
        value: SampleCountFlags,
    ) -> Self {
        self.inner.sampled_image_stencil_sample_counts = value;
        self
    }
    #[inline]
    pub fn storage_image_sample_counts(mut self, value: SampleCountFlags) -> Self {
        self.inner.storage_image_sample_counts = value;
        self
    }
    #[inline]
    pub fn max_sample_mask_words(mut self, value: u32) -> Self {
        self.inner.max_sample_mask_words = value;
        self
    }
    #[inline]
    pub fn timestamp_compute_and_graphics(mut self, value: bool) -> Self {
        self.inner.timestamp_compute_and_graphics = value as u32;
        self
    }
    #[inline]
    pub fn timestamp_period(mut self, value: f32) -> Self {
        self.inner.timestamp_period = value;
        self
    }
    #[inline]
    pub fn max_clip_distances(mut self, value: u32) -> Self {
        self.inner.max_clip_distances = value;
        self
    }
    #[inline]
    pub fn max_cull_distances(mut self, value: u32) -> Self {
        self.inner.max_cull_distances = value;
        self
    }
    #[inline]
    pub fn max_combined_clip_and_cull_distances(mut self, value: u32) -> Self {
        self.inner.max_combined_clip_and_cull_distances = value;
        self
    }
    #[inline]
    pub fn discrete_queue_priorities(mut self, value: u32) -> Self {
        self.inner.discrete_queue_priorities = value;
        self
    }
    #[inline]
    pub fn point_size_range(mut self, value: [f32; 2usize]) -> Self {
        self.inner.point_size_range = value;
        self
    }
    #[inline]
    pub fn line_width_range(mut self, value: [f32; 2usize]) -> Self {
        self.inner.line_width_range = value;
        self
    }
    #[inline]
    pub fn point_size_granularity(mut self, value: f32) -> Self {
        self.inner.point_size_granularity = value;
        self
    }
    #[inline]
    pub fn line_width_granularity(mut self, value: f32) -> Self {
        self.inner.line_width_granularity = value;
        self
    }
    #[inline]
    pub fn strict_lines(mut self, value: bool) -> Self {
        self.inner.strict_lines = value as u32;
        self
    }
    #[inline]
    pub fn standard_sample_locations(mut self, value: bool) -> Self {
        self.inner.standard_sample_locations = value as u32;
        self
    }
    #[inline]
    pub fn optimal_buffer_copy_offset_alignment(mut self, value: u64) -> Self {
        self.inner.optimal_buffer_copy_offset_alignment = value;
        self
    }
    #[inline]
    pub fn optimal_buffer_copy_row_pitch_alignment(mut self, value: u64) -> Self {
        self.inner.optimal_buffer_copy_row_pitch_alignment = value;
        self
    }
    #[inline]
    pub fn non_coherent_atom_size(mut self, value: u64) -> Self {
        self.inner.non_coherent_atom_size = value;
        self
    }
}
impl core::ops::Deref for PhysicalDeviceLimitsBuilder {
    type Target = PhysicalDeviceLimits;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for PhysicalDeviceLimitsBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`SemaphoreCreateInfo`] with lifetime-tied pNext safety.
pub struct SemaphoreCreateInfoBuilder<'a> {
    inner: SemaphoreCreateInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl SemaphoreCreateInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> SemaphoreCreateInfoBuilder<'a> {
        SemaphoreCreateInfoBuilder {
            inner: SemaphoreCreateInfo {
                s_type: StructureType::from_raw(9i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> SemaphoreCreateInfoBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: SemaphoreCreateFlags) -> Self {
        self.inner.flags = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`SemaphoreCreateInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsSemaphoreCreateInfo>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for SemaphoreCreateInfoBuilder<'a> {
    type Target = SemaphoreCreateInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for SemaphoreCreateInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`QueryPoolCreateInfo`] with lifetime-tied pNext safety.
pub struct QueryPoolCreateInfoBuilder<'a> {
    inner: QueryPoolCreateInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl QueryPoolCreateInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> QueryPoolCreateInfoBuilder<'a> {
        QueryPoolCreateInfoBuilder {
            inner: QueryPoolCreateInfo {
                s_type: StructureType::from_raw(11i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> QueryPoolCreateInfoBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: QueryPoolCreateFlags) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn query_type(mut self, value: QueryType) -> Self {
        self.inner.query_type = value;
        self
    }
    #[inline]
    pub fn query_count(mut self, value: u32) -> Self {
        self.inner.query_count = value;
        self
    }
    #[inline]
    pub fn pipeline_statistics(mut self, value: QueryPipelineStatisticFlags) -> Self {
        self.inner.pipeline_statistics = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`QueryPoolCreateInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsQueryPoolCreateInfo>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for QueryPoolCreateInfoBuilder<'a> {
    type Target = QueryPoolCreateInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for QueryPoolCreateInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`FramebufferCreateInfo`] with lifetime-tied pNext safety.
pub struct FramebufferCreateInfoBuilder<'a> {
    inner: FramebufferCreateInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl FramebufferCreateInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> FramebufferCreateInfoBuilder<'a> {
        FramebufferCreateInfoBuilder {
            inner: FramebufferCreateInfo {
                s_type: StructureType::from_raw(37i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> FramebufferCreateInfoBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: FramebufferCreateFlags) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn render_pass(mut self, value: RenderPass) -> Self {
        self.inner.render_pass = value;
        self
    }
    #[inline]
    pub fn attachments(mut self, slice: &'a [ImageView]) -> Self {
        self.inner.attachment_count = slice.len() as u32;
        self.inner.p_attachments = slice.as_ptr();
        self
    }
    #[inline]
    pub fn width(mut self, value: u32) -> Self {
        self.inner.width = value;
        self
    }
    #[inline]
    pub fn height(mut self, value: u32) -> Self {
        self.inner.height = value;
        self
    }
    #[inline]
    pub fn layers(mut self, value: u32) -> Self {
        self.inner.layers = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`FramebufferCreateInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsFramebufferCreateInfo>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for FramebufferCreateInfoBuilder<'a> {
    type Target = FramebufferCreateInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for FramebufferCreateInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DrawIndirectCommand`].
pub struct DrawIndirectCommandBuilder {
    inner: DrawIndirectCommand,
}
impl DrawIndirectCommand {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> DrawIndirectCommandBuilder {
        DrawIndirectCommandBuilder {
            inner: DrawIndirectCommand {
                ..Default::default()
            },
        }
    }
}
impl DrawIndirectCommandBuilder {
    #[inline]
    pub fn vertex_count(mut self, value: u32) -> Self {
        self.inner.vertex_count = value;
        self
    }
    #[inline]
    pub fn instance_count(mut self, value: u32) -> Self {
        self.inner.instance_count = value;
        self
    }
    #[inline]
    pub fn first_vertex(mut self, value: u32) -> Self {
        self.inner.first_vertex = value;
        self
    }
    #[inline]
    pub fn first_instance(mut self, value: u32) -> Self {
        self.inner.first_instance = value;
        self
    }
}
impl core::ops::Deref for DrawIndirectCommandBuilder {
    type Target = DrawIndirectCommand;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for DrawIndirectCommandBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DrawIndexedIndirectCommand`].
pub struct DrawIndexedIndirectCommandBuilder {
    inner: DrawIndexedIndirectCommand,
}
impl DrawIndexedIndirectCommand {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> DrawIndexedIndirectCommandBuilder {
        DrawIndexedIndirectCommandBuilder {
            inner: DrawIndexedIndirectCommand {
                ..Default::default()
            },
        }
    }
}
impl DrawIndexedIndirectCommandBuilder {
    #[inline]
    pub fn index_count(mut self, value: u32) -> Self {
        self.inner.index_count = value;
        self
    }
    #[inline]
    pub fn instance_count(mut self, value: u32) -> Self {
        self.inner.instance_count = value;
        self
    }
    #[inline]
    pub fn first_index(mut self, value: u32) -> Self {
        self.inner.first_index = value;
        self
    }
    #[inline]
    pub fn vertex_offset(mut self, value: i32) -> Self {
        self.inner.vertex_offset = value;
        self
    }
    #[inline]
    pub fn first_instance(mut self, value: u32) -> Self {
        self.inner.first_instance = value;
        self
    }
}
impl core::ops::Deref for DrawIndexedIndirectCommandBuilder {
    type Target = DrawIndexedIndirectCommand;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for DrawIndexedIndirectCommandBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DispatchIndirectCommand`].
pub struct DispatchIndirectCommandBuilder {
    inner: DispatchIndirectCommand,
}
impl DispatchIndirectCommand {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> DispatchIndirectCommandBuilder {
        DispatchIndirectCommandBuilder {
            inner: DispatchIndirectCommand {
                ..Default::default()
            },
        }
    }
}
impl DispatchIndirectCommandBuilder {
    #[inline]
    pub fn x(mut self, value: u32) -> Self {
        self.inner.x = value;
        self
    }
    #[inline]
    pub fn y(mut self, value: u32) -> Self {
        self.inner.y = value;
        self
    }
    #[inline]
    pub fn z(mut self, value: u32) -> Self {
        self.inner.z = value;
        self
    }
}
impl core::ops::Deref for DispatchIndirectCommandBuilder {
    type Target = DispatchIndirectCommand;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for DispatchIndirectCommandBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`MultiDrawInfoEXT`].
pub struct MultiDrawInfoEXTBuilder {
    inner: MultiDrawInfoEXT,
}
impl MultiDrawInfoEXT {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> MultiDrawInfoEXTBuilder {
        MultiDrawInfoEXTBuilder {
            inner: MultiDrawInfoEXT {
                ..Default::default()
            },
        }
    }
}
impl MultiDrawInfoEXTBuilder {
    #[inline]
    pub fn first_vertex(mut self, value: u32) -> Self {
        self.inner.first_vertex = value;
        self
    }
    #[inline]
    pub fn vertex_count(mut self, value: u32) -> Self {
        self.inner.vertex_count = value;
        self
    }
}
impl core::ops::Deref for MultiDrawInfoEXTBuilder {
    type Target = MultiDrawInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for MultiDrawInfoEXTBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`MultiDrawIndexedInfoEXT`].
pub struct MultiDrawIndexedInfoEXTBuilder {
    inner: MultiDrawIndexedInfoEXT,
}
impl MultiDrawIndexedInfoEXT {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> MultiDrawIndexedInfoEXTBuilder {
        MultiDrawIndexedInfoEXTBuilder {
            inner: MultiDrawIndexedInfoEXT {
                ..Default::default()
            },
        }
    }
}
impl MultiDrawIndexedInfoEXTBuilder {
    #[inline]
    pub fn first_index(mut self, value: u32) -> Self {
        self.inner.first_index = value;
        self
    }
    #[inline]
    pub fn index_count(mut self, value: u32) -> Self {
        self.inner.index_count = value;
        self
    }
    #[inline]
    pub fn vertex_offset(mut self, value: i32) -> Self {
        self.inner.vertex_offset = value;
        self
    }
}
impl core::ops::Deref for MultiDrawIndexedInfoEXTBuilder {
    type Target = MultiDrawIndexedInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for MultiDrawIndexedInfoEXTBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`SubmitInfo`] with lifetime-tied pNext safety.
pub struct SubmitInfoBuilder<'a> {
    inner: SubmitInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl SubmitInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> SubmitInfoBuilder<'a> {
        SubmitInfoBuilder {
            inner: SubmitInfo {
                s_type: StructureType::from_raw(4i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> SubmitInfoBuilder<'a> {
    #[inline]
    pub fn wait_semaphores(mut self, slice: &'a [Semaphore]) -> Self {
        self.inner.wait_semaphore_count = slice.len() as u32;
        self.inner.p_wait_semaphores = slice.as_ptr();
        self
    }
    #[inline]
    pub fn wait_dst_stage_mask(mut self, slice: &'a [PipelineStageFlags]) -> Self {
        self.inner.wait_semaphore_count = slice.len() as u32;
        self.inner.p_wait_dst_stage_mask = slice.as_ptr();
        self
    }
    #[inline]
    pub fn command_buffers(mut self, slice: &'a [CommandBuffer]) -> Self {
        self.inner.command_buffer_count = slice.len() as u32;
        self.inner.p_command_buffers = slice.as_ptr();
        self
    }
    #[inline]
    pub fn signal_semaphores(mut self, slice: &'a [Semaphore]) -> Self {
        self.inner.signal_semaphore_count = slice.len() as u32;
        self.inner.p_signal_semaphores = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`SubmitInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsSubmitInfo>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for SubmitInfoBuilder<'a> {
    type Target = SubmitInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for SubmitInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DisplayPropertiesKHR`].
pub struct DisplayPropertiesKHRBuilder<'a> {
    inner: DisplayPropertiesKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DisplayPropertiesKHR {
    /// Start building this struct.
    #[inline]
    pub fn builder<'a>() -> DisplayPropertiesKHRBuilder<'a> {
        DisplayPropertiesKHRBuilder {
            inner: DisplayPropertiesKHR {
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DisplayPropertiesKHRBuilder<'a> {
    #[inline]
    pub fn display(mut self, value: DisplayKHR) -> Self {
        self.inner.display = value;
        self
    }
    #[inline]
    pub fn display_name(mut self, value: &'a core::ffi::CStr) -> Self {
        self.inner.display_name = value.as_ptr();
        self
    }
    #[inline]
    pub fn physical_dimensions(mut self, value: Extent2D) -> Self {
        self.inner.physical_dimensions = value;
        self
    }
    #[inline]
    pub fn physical_resolution(mut self, value: Extent2D) -> Self {
        self.inner.physical_resolution = value;
        self
    }
    #[inline]
    pub fn supported_transforms(mut self, value: SurfaceTransformFlagsKHR) -> Self {
        self.inner.supported_transforms = value;
        self
    }
    #[inline]
    pub fn plane_reorder_possible(mut self, value: bool) -> Self {
        self.inner.plane_reorder_possible = value as u32;
        self
    }
    #[inline]
    pub fn persistent_content(mut self, value: bool) -> Self {
        self.inner.persistent_content = value as u32;
        self
    }
}
impl<'a> core::ops::Deref for DisplayPropertiesKHRBuilder<'a> {
    type Target = DisplayPropertiesKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for DisplayPropertiesKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DisplayPlanePropertiesKHR`].
pub struct DisplayPlanePropertiesKHRBuilder {
    inner: DisplayPlanePropertiesKHR,
}
impl DisplayPlanePropertiesKHR {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> DisplayPlanePropertiesKHRBuilder {
        DisplayPlanePropertiesKHRBuilder {
            inner: DisplayPlanePropertiesKHR {
                ..Default::default()
            },
        }
    }
}
impl DisplayPlanePropertiesKHRBuilder {
    #[inline]
    pub fn current_display(mut self, value: DisplayKHR) -> Self {
        self.inner.current_display = value;
        self
    }
    #[inline]
    pub fn current_stack_index(mut self, value: u32) -> Self {
        self.inner.current_stack_index = value;
        self
    }
}
impl core::ops::Deref for DisplayPlanePropertiesKHRBuilder {
    type Target = DisplayPlanePropertiesKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for DisplayPlanePropertiesKHRBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DisplayModeParametersKHR`].
pub struct DisplayModeParametersKHRBuilder {
    inner: DisplayModeParametersKHR,
}
impl DisplayModeParametersKHR {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> DisplayModeParametersKHRBuilder {
        DisplayModeParametersKHRBuilder {
            inner: DisplayModeParametersKHR {
                ..Default::default()
            },
        }
    }
}
impl DisplayModeParametersKHRBuilder {
    #[inline]
    pub fn visible_region(mut self, value: Extent2D) -> Self {
        self.inner.visible_region = value;
        self
    }
    #[inline]
    pub fn refresh_rate(mut self, value: u32) -> Self {
        self.inner.refresh_rate = value;
        self
    }
}
impl core::ops::Deref for DisplayModeParametersKHRBuilder {
    type Target = DisplayModeParametersKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for DisplayModeParametersKHRBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DisplayModePropertiesKHR`].
pub struct DisplayModePropertiesKHRBuilder {
    inner: DisplayModePropertiesKHR,
}
impl DisplayModePropertiesKHR {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> DisplayModePropertiesKHRBuilder {
        DisplayModePropertiesKHRBuilder {
            inner: DisplayModePropertiesKHR {
                ..Default::default()
            },
        }
    }
}
impl DisplayModePropertiesKHRBuilder {
    #[inline]
    pub fn display_mode(mut self, value: DisplayModeKHR) -> Self {
        self.inner.display_mode = value;
        self
    }
    #[inline]
    pub fn parameters(mut self, value: DisplayModeParametersKHR) -> Self {
        self.inner.parameters = value;
        self
    }
}
impl core::ops::Deref for DisplayModePropertiesKHRBuilder {
    type Target = DisplayModePropertiesKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for DisplayModePropertiesKHRBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DisplayModeCreateInfoKHR`] with lifetime-tied pNext safety.
pub struct DisplayModeCreateInfoKHRBuilder<'a> {
    inner: DisplayModeCreateInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DisplayModeCreateInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> DisplayModeCreateInfoKHRBuilder<'a> {
        DisplayModeCreateInfoKHRBuilder {
            inner: DisplayModeCreateInfoKHR {
                s_type: StructureType::from_raw(1000002000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DisplayModeCreateInfoKHRBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: DisplayModeCreateFlagsKHR) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn parameters(mut self, value: DisplayModeParametersKHR) -> Self {
        self.inner.parameters = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`DisplayModeCreateInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsDisplayModeCreateInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for DisplayModeCreateInfoKHRBuilder<'a> {
    type Target = DisplayModeCreateInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for DisplayModeCreateInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DisplayPlaneCapabilitiesKHR`].
pub struct DisplayPlaneCapabilitiesKHRBuilder {
    inner: DisplayPlaneCapabilitiesKHR,
}
impl DisplayPlaneCapabilitiesKHR {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> DisplayPlaneCapabilitiesKHRBuilder {
        DisplayPlaneCapabilitiesKHRBuilder {
            inner: DisplayPlaneCapabilitiesKHR {
                ..Default::default()
            },
        }
    }
}
impl DisplayPlaneCapabilitiesKHRBuilder {
    #[inline]
    pub fn supported_alpha(mut self, value: DisplayPlaneAlphaFlagsKHR) -> Self {
        self.inner.supported_alpha = value;
        self
    }
    #[inline]
    pub fn min_src_position(mut self, value: Offset2D) -> Self {
        self.inner.min_src_position = value;
        self
    }
    #[inline]
    pub fn max_src_position(mut self, value: Offset2D) -> Self {
        self.inner.max_src_position = value;
        self
    }
    #[inline]
    pub fn min_src_extent(mut self, value: Extent2D) -> Self {
        self.inner.min_src_extent = value;
        self
    }
    #[inline]
    pub fn max_src_extent(mut self, value: Extent2D) -> Self {
        self.inner.max_src_extent = value;
        self
    }
    #[inline]
    pub fn min_dst_position(mut self, value: Offset2D) -> Self {
        self.inner.min_dst_position = value;
        self
    }
    #[inline]
    pub fn max_dst_position(mut self, value: Offset2D) -> Self {
        self.inner.max_dst_position = value;
        self
    }
    #[inline]
    pub fn min_dst_extent(mut self, value: Extent2D) -> Self {
        self.inner.min_dst_extent = value;
        self
    }
    #[inline]
    pub fn max_dst_extent(mut self, value: Extent2D) -> Self {
        self.inner.max_dst_extent = value;
        self
    }
}
impl core::ops::Deref for DisplayPlaneCapabilitiesKHRBuilder {
    type Target = DisplayPlaneCapabilitiesKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for DisplayPlaneCapabilitiesKHRBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DisplaySurfaceCreateInfoKHR`] with lifetime-tied pNext safety.
pub struct DisplaySurfaceCreateInfoKHRBuilder<'a> {
    inner: DisplaySurfaceCreateInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DisplaySurfaceCreateInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> DisplaySurfaceCreateInfoKHRBuilder<'a> {
        DisplaySurfaceCreateInfoKHRBuilder {
            inner: DisplaySurfaceCreateInfoKHR {
                s_type: StructureType::from_raw(1000002001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DisplaySurfaceCreateInfoKHRBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: DisplaySurfaceCreateFlagsKHR) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn display_mode(mut self, value: DisplayModeKHR) -> Self {
        self.inner.display_mode = value;
        self
    }
    #[inline]
    pub fn plane_index(mut self, value: u32) -> Self {
        self.inner.plane_index = value;
        self
    }
    #[inline]
    pub fn plane_stack_index(mut self, value: u32) -> Self {
        self.inner.plane_stack_index = value;
        self
    }
    #[inline]
    pub fn transform(mut self, value: SurfaceTransformFlagBitsKHR) -> Self {
        self.inner.transform = value;
        self
    }
    #[inline]
    pub fn global_alpha(mut self, value: f32) -> Self {
        self.inner.global_alpha = value;
        self
    }
    #[inline]
    pub fn alpha_mode(mut self, value: DisplayPlaneAlphaFlagBitsKHR) -> Self {
        self.inner.alpha_mode = value;
        self
    }
    #[inline]
    pub fn image_extent(mut self, value: Extent2D) -> Self {
        self.inner.image_extent = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`DisplaySurfaceCreateInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsDisplaySurfaceCreateInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for DisplaySurfaceCreateInfoKHRBuilder<'a> {
    type Target = DisplaySurfaceCreateInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for DisplaySurfaceCreateInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DisplaySurfaceStereoCreateInfoNV`] with lifetime-tied pNext safety.
pub struct DisplaySurfaceStereoCreateInfoNVBuilder<'a> {
    inner: DisplaySurfaceStereoCreateInfoNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DisplaySurfaceStereoCreateInfoNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> DisplaySurfaceStereoCreateInfoNVBuilder<'a> {
        DisplaySurfaceStereoCreateInfoNVBuilder {
            inner: DisplaySurfaceStereoCreateInfoNV {
                s_type: StructureType::from_raw(1000551000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DisplaySurfaceStereoCreateInfoNVBuilder<'a> {
    #[inline]
    pub fn stereo_type(mut self, value: DisplaySurfaceStereoTypeNV) -> Self {
        self.inner.stereo_type = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`DisplaySurfaceStereoCreateInfoNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsDisplaySurfaceStereoCreateInfoNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for DisplaySurfaceStereoCreateInfoNVBuilder<'a> {
    type Target = DisplaySurfaceStereoCreateInfoNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for DisplaySurfaceStereoCreateInfoNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DisplayPresentInfoKHR`] with lifetime-tied pNext safety.
pub struct DisplayPresentInfoKHRBuilder<'a> {
    inner: DisplayPresentInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DisplayPresentInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> DisplayPresentInfoKHRBuilder<'a> {
        DisplayPresentInfoKHRBuilder {
            inner: DisplayPresentInfoKHR {
                s_type: StructureType::from_raw(1000003000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DisplayPresentInfoKHRBuilder<'a> {
    #[inline]
    pub fn src_rect(mut self, value: Rect2D) -> Self {
        self.inner.src_rect = value;
        self
    }
    #[inline]
    pub fn dst_rect(mut self, value: Rect2D) -> Self {
        self.inner.dst_rect = value;
        self
    }
    #[inline]
    pub fn persistent(mut self, value: bool) -> Self {
        self.inner.persistent = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`DisplayPresentInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsDisplayPresentInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for DisplayPresentInfoKHRBuilder<'a> {
    type Target = DisplayPresentInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for DisplayPresentInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`SurfaceCapabilitiesKHR`].
pub struct SurfaceCapabilitiesKHRBuilder {
    inner: SurfaceCapabilitiesKHR,
}
impl SurfaceCapabilitiesKHR {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> SurfaceCapabilitiesKHRBuilder {
        SurfaceCapabilitiesKHRBuilder {
            inner: SurfaceCapabilitiesKHR {
                ..Default::default()
            },
        }
    }
}
impl SurfaceCapabilitiesKHRBuilder {
    #[inline]
    pub fn min_image_count(mut self, value: u32) -> Self {
        self.inner.min_image_count = value;
        self
    }
    #[inline]
    pub fn max_image_count(mut self, value: u32) -> Self {
        self.inner.max_image_count = value;
        self
    }
    #[inline]
    pub fn current_extent(mut self, value: Extent2D) -> Self {
        self.inner.current_extent = value;
        self
    }
    #[inline]
    pub fn min_image_extent(mut self, value: Extent2D) -> Self {
        self.inner.min_image_extent = value;
        self
    }
    #[inline]
    pub fn max_image_extent(mut self, value: Extent2D) -> Self {
        self.inner.max_image_extent = value;
        self
    }
    #[inline]
    pub fn max_image_array_layers(mut self, value: u32) -> Self {
        self.inner.max_image_array_layers = value;
        self
    }
    #[inline]
    pub fn supported_transforms(mut self, value: SurfaceTransformFlagsKHR) -> Self {
        self.inner.supported_transforms = value;
        self
    }
    #[inline]
    pub fn current_transform(mut self, value: SurfaceTransformFlagBitsKHR) -> Self {
        self.inner.current_transform = value;
        self
    }
    #[inline]
    pub fn supported_composite_alpha(mut self, value: CompositeAlphaFlagsKHR) -> Self {
        self.inner.supported_composite_alpha = value;
        self
    }
    #[inline]
    pub fn supported_usage_flags(mut self, value: ImageUsageFlags) -> Self {
        self.inner.supported_usage_flags = value;
        self
    }
}
impl core::ops::Deref for SurfaceCapabilitiesKHRBuilder {
    type Target = SurfaceCapabilitiesKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for SurfaceCapabilitiesKHRBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`AndroidSurfaceCreateInfoKHR`] with lifetime-tied pNext safety.
pub struct AndroidSurfaceCreateInfoKHRBuilder<'a> {
    inner: AndroidSurfaceCreateInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl AndroidSurfaceCreateInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> AndroidSurfaceCreateInfoKHRBuilder<'a> {
        AndroidSurfaceCreateInfoKHRBuilder {
            inner: AndroidSurfaceCreateInfoKHR {
                s_type: StructureType::from_raw(1000008000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> AndroidSurfaceCreateInfoKHRBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: AndroidSurfaceCreateFlagsKHR) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn window(mut self, value: *mut core::ffi::c_void) -> Self {
        self.inner.window = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`AndroidSurfaceCreateInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsAndroidSurfaceCreateInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for AndroidSurfaceCreateInfoKHRBuilder<'a> {
    type Target = AndroidSurfaceCreateInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for AndroidSurfaceCreateInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ViSurfaceCreateInfoNN`] with lifetime-tied pNext safety.
pub struct ViSurfaceCreateInfoNNBuilder<'a> {
    inner: ViSurfaceCreateInfoNN,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ViSurfaceCreateInfoNN {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ViSurfaceCreateInfoNNBuilder<'a> {
        ViSurfaceCreateInfoNNBuilder {
            inner: ViSurfaceCreateInfoNN {
                s_type: StructureType::from_raw(1000062000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ViSurfaceCreateInfoNNBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: ViSurfaceCreateFlagsNN) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn window(mut self, value: *mut core::ffi::c_void) -> Self {
        self.inner.window = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`ViSurfaceCreateInfoNN`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsViSurfaceCreateInfoNN>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for ViSurfaceCreateInfoNNBuilder<'a> {
    type Target = ViSurfaceCreateInfoNN;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ViSurfaceCreateInfoNNBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`WaylandSurfaceCreateInfoKHR`] with lifetime-tied pNext safety.
pub struct WaylandSurfaceCreateInfoKHRBuilder<'a> {
    inner: WaylandSurfaceCreateInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl WaylandSurfaceCreateInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> WaylandSurfaceCreateInfoKHRBuilder<'a> {
        WaylandSurfaceCreateInfoKHRBuilder {
            inner: WaylandSurfaceCreateInfoKHR {
                s_type: StructureType::from_raw(1000006000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> WaylandSurfaceCreateInfoKHRBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: WaylandSurfaceCreateFlagsKHR) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn display(mut self, value: *mut core::ffi::c_void) -> Self {
        self.inner.display = value;
        self
    }
    #[inline]
    pub fn surface(mut self, value: *mut core::ffi::c_void) -> Self {
        self.inner.surface = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`WaylandSurfaceCreateInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsWaylandSurfaceCreateInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for WaylandSurfaceCreateInfoKHRBuilder<'a> {
    type Target = WaylandSurfaceCreateInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for WaylandSurfaceCreateInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`UbmSurfaceCreateInfoSEC`] with lifetime-tied pNext safety.
pub struct UbmSurfaceCreateInfoSECBuilder<'a> {
    inner: UbmSurfaceCreateInfoSEC,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl UbmSurfaceCreateInfoSEC {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> UbmSurfaceCreateInfoSECBuilder<'a> {
        UbmSurfaceCreateInfoSECBuilder {
            inner: UbmSurfaceCreateInfoSEC {
                s_type: StructureType::from_raw(1000664000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> UbmSurfaceCreateInfoSECBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: UbmSurfaceCreateFlagsSEC) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn device(mut self, value: *mut core::ffi::c_void) -> Self {
        self.inner.device = value;
        self
    }
    #[inline]
    pub fn surface(mut self, value: *mut core::ffi::c_void) -> Self {
        self.inner.surface = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`UbmSurfaceCreateInfoSEC`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsUbmSurfaceCreateInfoSEC>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for UbmSurfaceCreateInfoSECBuilder<'a> {
    type Target = UbmSurfaceCreateInfoSEC;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for UbmSurfaceCreateInfoSECBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`Win32SurfaceCreateInfoKHR`] with lifetime-tied pNext safety.
pub struct Win32SurfaceCreateInfoKHRBuilder<'a> {
    inner: Win32SurfaceCreateInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl Win32SurfaceCreateInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> Win32SurfaceCreateInfoKHRBuilder<'a> {
        Win32SurfaceCreateInfoKHRBuilder {
            inner: Win32SurfaceCreateInfoKHR {
                s_type: StructureType::from_raw(1000009000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> Win32SurfaceCreateInfoKHRBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: Win32SurfaceCreateFlagsKHR) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn hinstance(mut self, value: isize) -> Self {
        self.inner.hinstance = value;
        self
    }
    #[inline]
    pub fn hwnd(mut self, value: isize) -> Self {
        self.inner.hwnd = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`Win32SurfaceCreateInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsWin32SurfaceCreateInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for Win32SurfaceCreateInfoKHRBuilder<'a> {
    type Target = Win32SurfaceCreateInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for Win32SurfaceCreateInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`XlibSurfaceCreateInfoKHR`] with lifetime-tied pNext safety.
pub struct XlibSurfaceCreateInfoKHRBuilder<'a> {
    inner: XlibSurfaceCreateInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl XlibSurfaceCreateInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> XlibSurfaceCreateInfoKHRBuilder<'a> {
        XlibSurfaceCreateInfoKHRBuilder {
            inner: XlibSurfaceCreateInfoKHR {
                s_type: StructureType::from_raw(1000004000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> XlibSurfaceCreateInfoKHRBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: XlibSurfaceCreateFlagsKHR) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn dpy(mut self, value: *mut core::ffi::c_void) -> Self {
        self.inner.dpy = value;
        self
    }
    #[inline]
    pub fn window(mut self, value: core::ffi::c_ulong) -> Self {
        self.inner.window = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`XlibSurfaceCreateInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsXlibSurfaceCreateInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for XlibSurfaceCreateInfoKHRBuilder<'a> {
    type Target = XlibSurfaceCreateInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for XlibSurfaceCreateInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`XcbSurfaceCreateInfoKHR`] with lifetime-tied pNext safety.
pub struct XcbSurfaceCreateInfoKHRBuilder<'a> {
    inner: XcbSurfaceCreateInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl XcbSurfaceCreateInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> XcbSurfaceCreateInfoKHRBuilder<'a> {
        XcbSurfaceCreateInfoKHRBuilder {
            inner: XcbSurfaceCreateInfoKHR {
                s_type: StructureType::from_raw(1000005000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> XcbSurfaceCreateInfoKHRBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: XcbSurfaceCreateFlagsKHR) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn connection(mut self, value: *mut core::ffi::c_void) -> Self {
        self.inner.connection = value;
        self
    }
    #[inline]
    pub fn window(mut self, value: u32) -> Self {
        self.inner.window = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`XcbSurfaceCreateInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsXcbSurfaceCreateInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for XcbSurfaceCreateInfoKHRBuilder<'a> {
    type Target = XcbSurfaceCreateInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for XcbSurfaceCreateInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DirectFBSurfaceCreateInfoEXT`] with lifetime-tied pNext safety.
pub struct DirectFBSurfaceCreateInfoEXTBuilder<'a> {
    inner: DirectFBSurfaceCreateInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DirectFBSurfaceCreateInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> DirectFBSurfaceCreateInfoEXTBuilder<'a> {
        DirectFBSurfaceCreateInfoEXTBuilder {
            inner: DirectFBSurfaceCreateInfoEXT {
                s_type: StructureType::from_raw(1000346000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DirectFBSurfaceCreateInfoEXTBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: DirectFBSurfaceCreateFlagsEXT) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn dfb(mut self, value: *mut core::ffi::c_void) -> Self {
        self.inner.dfb = value;
        self
    }
    #[inline]
    pub fn surface(mut self, value: *mut core::ffi::c_void) -> Self {
        self.inner.surface = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`DirectFBSurfaceCreateInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsDirectFBSurfaceCreateInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for DirectFBSurfaceCreateInfoEXTBuilder<'a> {
    type Target = DirectFBSurfaceCreateInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for DirectFBSurfaceCreateInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ImagePipeSurfaceCreateInfoFUCHSIA`] with lifetime-tied pNext safety.
pub struct ImagePipeSurfaceCreateInfoFUCHSIABuilder<'a> {
    inner: ImagePipeSurfaceCreateInfoFUCHSIA,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ImagePipeSurfaceCreateInfoFUCHSIA {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ImagePipeSurfaceCreateInfoFUCHSIABuilder<'a> {
        ImagePipeSurfaceCreateInfoFUCHSIABuilder {
            inner: ImagePipeSurfaceCreateInfoFUCHSIA {
                s_type: StructureType::from_raw(1000214000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ImagePipeSurfaceCreateInfoFUCHSIABuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: ImagePipeSurfaceCreateFlagsFUCHSIA) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn image_pipe_handle(mut self, value: u32) -> Self {
        self.inner.image_pipe_handle = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`ImagePipeSurfaceCreateInfoFUCHSIA`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsImagePipeSurfaceCreateInfoFUCHSIA>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for ImagePipeSurfaceCreateInfoFUCHSIABuilder<'a> {
    type Target = ImagePipeSurfaceCreateInfoFUCHSIA;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ImagePipeSurfaceCreateInfoFUCHSIABuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`StreamDescriptorSurfaceCreateInfoGGP`] with lifetime-tied pNext safety.
pub struct StreamDescriptorSurfaceCreateInfoGGPBuilder<'a> {
    inner: StreamDescriptorSurfaceCreateInfoGGP,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl StreamDescriptorSurfaceCreateInfoGGP {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> StreamDescriptorSurfaceCreateInfoGGPBuilder<'a> {
        StreamDescriptorSurfaceCreateInfoGGPBuilder {
            inner: StreamDescriptorSurfaceCreateInfoGGP {
                s_type: StructureType::from_raw(1000049000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> StreamDescriptorSurfaceCreateInfoGGPBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: StreamDescriptorSurfaceCreateFlagsGGP) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn stream_descriptor(mut self, value: u32) -> Self {
        self.inner.stream_descriptor = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`StreamDescriptorSurfaceCreateInfoGGP`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsStreamDescriptorSurfaceCreateInfoGGP>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for StreamDescriptorSurfaceCreateInfoGGPBuilder<'a> {
    type Target = StreamDescriptorSurfaceCreateInfoGGP;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for StreamDescriptorSurfaceCreateInfoGGPBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ScreenSurfaceCreateInfoQNX`] with lifetime-tied pNext safety.
pub struct ScreenSurfaceCreateInfoQNXBuilder<'a> {
    inner: ScreenSurfaceCreateInfoQNX,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ScreenSurfaceCreateInfoQNX {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ScreenSurfaceCreateInfoQNXBuilder<'a> {
        ScreenSurfaceCreateInfoQNXBuilder {
            inner: ScreenSurfaceCreateInfoQNX {
                s_type: StructureType::from_raw(1000378000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ScreenSurfaceCreateInfoQNXBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: ScreenSurfaceCreateFlagsQNX) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn context(mut self, value: *mut core::ffi::c_void) -> Self {
        self.inner.context = value;
        self
    }
    #[inline]
    pub fn window(mut self, value: *mut core::ffi::c_void) -> Self {
        self.inner.window = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`ScreenSurfaceCreateInfoQNX`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsScreenSurfaceCreateInfoQNX>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for ScreenSurfaceCreateInfoQNXBuilder<'a> {
    type Target = ScreenSurfaceCreateInfoQNX;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ScreenSurfaceCreateInfoQNXBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`SurfaceFormatKHR`].
pub struct SurfaceFormatKHRBuilder {
    inner: SurfaceFormatKHR,
}
impl SurfaceFormatKHR {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> SurfaceFormatKHRBuilder {
        SurfaceFormatKHRBuilder {
            inner: SurfaceFormatKHR {
                ..Default::default()
            },
        }
    }
}
impl SurfaceFormatKHRBuilder {
    #[inline]
    pub fn format(mut self, value: Format) -> Self {
        self.inner.format = value;
        self
    }
    #[inline]
    pub fn color_space(mut self, value: ColorSpaceKHR) -> Self {
        self.inner.color_space = value;
        self
    }
}
impl core::ops::Deref for SurfaceFormatKHRBuilder {
    type Target = SurfaceFormatKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for SurfaceFormatKHRBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`SwapchainCreateInfoKHR`] with lifetime-tied pNext safety.
pub struct SwapchainCreateInfoKHRBuilder<'a> {
    inner: SwapchainCreateInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl SwapchainCreateInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> SwapchainCreateInfoKHRBuilder<'a> {
        SwapchainCreateInfoKHRBuilder {
            inner: SwapchainCreateInfoKHR {
                s_type: StructureType::from_raw(1000001000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> SwapchainCreateInfoKHRBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: SwapchainCreateFlagsKHR) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn surface(mut self, value: SurfaceKHR) -> Self {
        self.inner.surface = value;
        self
    }
    #[inline]
    pub fn min_image_count(mut self, value: u32) -> Self {
        self.inner.min_image_count = value;
        self
    }
    #[inline]
    pub fn image_format(mut self, value: Format) -> Self {
        self.inner.image_format = value;
        self
    }
    #[inline]
    pub fn image_color_space(mut self, value: ColorSpaceKHR) -> Self {
        self.inner.image_color_space = value;
        self
    }
    #[inline]
    pub fn image_extent(mut self, value: Extent2D) -> Self {
        self.inner.image_extent = value;
        self
    }
    #[inline]
    pub fn image_array_layers(mut self, value: u32) -> Self {
        self.inner.image_array_layers = value;
        self
    }
    #[inline]
    pub fn image_usage(mut self, value: ImageUsageFlags) -> Self {
        self.inner.image_usage = value;
        self
    }
    #[inline]
    pub fn image_sharing_mode(mut self, value: SharingMode) -> Self {
        self.inner.image_sharing_mode = value;
        self
    }
    #[inline]
    pub fn queue_family_indices(mut self, slice: &'a [u32]) -> Self {
        self.inner.queue_family_index_count = slice.len() as u32;
        self.inner.p_queue_family_indices = slice.as_ptr();
        self
    }
    #[inline]
    pub fn pre_transform(mut self, value: SurfaceTransformFlagBitsKHR) -> Self {
        self.inner.pre_transform = value;
        self
    }
    #[inline]
    pub fn composite_alpha(mut self, value: CompositeAlphaFlagBitsKHR) -> Self {
        self.inner.composite_alpha = value;
        self
    }
    #[inline]
    pub fn present_mode(mut self, value: PresentModeKHR) -> Self {
        self.inner.present_mode = value;
        self
    }
    #[inline]
    pub fn clipped(mut self, value: bool) -> Self {
        self.inner.clipped = value as u32;
        self
    }
    #[inline]
    pub fn old_swapchain(mut self, value: SwapchainKHR) -> Self {
        self.inner.old_swapchain = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`SwapchainCreateInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsSwapchainCreateInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for SwapchainCreateInfoKHRBuilder<'a> {
    type Target = SwapchainCreateInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for SwapchainCreateInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PresentInfoKHR`] with lifetime-tied pNext safety.
pub struct PresentInfoKHRBuilder<'a> {
    inner: PresentInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PresentInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PresentInfoKHRBuilder<'a> {
        PresentInfoKHRBuilder {
            inner: PresentInfoKHR {
                s_type: StructureType::from_raw(1000001001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PresentInfoKHRBuilder<'a> {
    #[inline]
    pub fn wait_semaphores(mut self, slice: &'a [Semaphore]) -> Self {
        self.inner.wait_semaphore_count = slice.len() as u32;
        self.inner.p_wait_semaphores = slice.as_ptr();
        self
    }
    #[inline]
    pub fn swapchains(mut self, slice: &'a [SwapchainKHR]) -> Self {
        self.inner.swapchain_count = slice.len() as u32;
        self.inner.p_swapchains = slice.as_ptr();
        self
    }
    #[inline]
    pub fn image_indices(mut self, slice: &'a [u32]) -> Self {
        self.inner.swapchain_count = slice.len() as u32;
        self.inner.p_image_indices = slice.as_ptr();
        self
    }
    #[inline]
    pub fn results(mut self, slice: &'a mut [Result]) -> Self {
        self.inner.swapchain_count = slice.len() as u32;
        self.inner.p_results = slice.as_mut_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`PresentInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPresentInfoKHR>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for PresentInfoKHRBuilder<'a> {
    type Target = PresentInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PresentInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DebugReportCallbackCreateInfoEXT`] with lifetime-tied pNext safety.
pub struct DebugReportCallbackCreateInfoEXTBuilder<'a> {
    inner: DebugReportCallbackCreateInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DebugReportCallbackCreateInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> DebugReportCallbackCreateInfoEXTBuilder<'a> {
        DebugReportCallbackCreateInfoEXTBuilder {
            inner: DebugReportCallbackCreateInfoEXT {
                s_type: StructureType::from_raw(1000011000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DebugReportCallbackCreateInfoEXTBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: DebugReportFlagsEXT) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn pfn_callback(mut self, value: PFN_vkDebugReportCallbackEXT) -> Self {
        self.inner.pfn_callback = value;
        self
    }
    #[inline]
    pub fn user_data(mut self, value: *mut core::ffi::c_void) -> Self {
        self.inner.p_user_data = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`DebugReportCallbackCreateInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsDebugReportCallbackCreateInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for DebugReportCallbackCreateInfoEXTBuilder<'a> {
    type Target = DebugReportCallbackCreateInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for DebugReportCallbackCreateInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ValidationFlagsEXT`] with lifetime-tied pNext safety.
pub struct ValidationFlagsEXTBuilder<'a> {
    inner: ValidationFlagsEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ValidationFlagsEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ValidationFlagsEXTBuilder<'a> {
        ValidationFlagsEXTBuilder {
            inner: ValidationFlagsEXT {
                s_type: StructureType::from_raw(1000061000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ValidationFlagsEXTBuilder<'a> {
    #[inline]
    pub fn disabled_validation_checks(
        mut self,
        slice: &'a [ValidationCheckEXT],
    ) -> Self {
        self.inner.disabled_validation_check_count = slice.len() as u32;
        self.inner.p_disabled_validation_checks = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`ValidationFlagsEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsValidationFlagsEXT>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for ValidationFlagsEXTBuilder<'a> {
    type Target = ValidationFlagsEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ValidationFlagsEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ValidationFeaturesEXT`] with lifetime-tied pNext safety.
pub struct ValidationFeaturesEXTBuilder<'a> {
    inner: ValidationFeaturesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ValidationFeaturesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ValidationFeaturesEXTBuilder<'a> {
        ValidationFeaturesEXTBuilder {
            inner: ValidationFeaturesEXT {
                s_type: StructureType::from_raw(1000247000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ValidationFeaturesEXTBuilder<'a> {
    #[inline]
    pub fn enabled_validation_features(
        mut self,
        slice: &'a [ValidationFeatureEnableEXT],
    ) -> Self {
        self.inner.enabled_validation_feature_count = slice.len() as u32;
        self.inner.p_enabled_validation_features = slice.as_ptr();
        self
    }
    #[inline]
    pub fn disabled_validation_features(
        mut self,
        slice: &'a [ValidationFeatureDisableEXT],
    ) -> Self {
        self.inner.disabled_validation_feature_count = slice.len() as u32;
        self.inner.p_disabled_validation_features = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`ValidationFeaturesEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsValidationFeaturesEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for ValidationFeaturesEXTBuilder<'a> {
    type Target = ValidationFeaturesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ValidationFeaturesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`LayerSettingsCreateInfoEXT`] with lifetime-tied pNext safety.
pub struct LayerSettingsCreateInfoEXTBuilder<'a> {
    inner: LayerSettingsCreateInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl LayerSettingsCreateInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> LayerSettingsCreateInfoEXTBuilder<'a> {
        LayerSettingsCreateInfoEXTBuilder {
            inner: LayerSettingsCreateInfoEXT {
                s_type: StructureType::from_raw(1000496000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> LayerSettingsCreateInfoEXTBuilder<'a> {
    #[inline]
    pub fn settings(mut self, slice: &'a [LayerSettingEXT]) -> Self {
        self.inner.setting_count = slice.len() as u32;
        self.inner.p_settings = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`LayerSettingsCreateInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsLayerSettingsCreateInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for LayerSettingsCreateInfoEXTBuilder<'a> {
    type Target = LayerSettingsCreateInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for LayerSettingsCreateInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`LayerSettingEXT`].
pub struct LayerSettingEXTBuilder<'a> {
    inner: LayerSettingEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl LayerSettingEXT {
    /// Start building this struct.
    #[inline]
    pub fn builder<'a>() -> LayerSettingEXTBuilder<'a> {
        LayerSettingEXTBuilder {
            inner: LayerSettingEXT {
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> LayerSettingEXTBuilder<'a> {
    #[inline]
    pub fn layer_name(mut self, value: &'a core::ffi::CStr) -> Self {
        self.inner.p_layer_name = value.as_ptr();
        self
    }
    #[inline]
    pub fn setting_name(mut self, value: &'a core::ffi::CStr) -> Self {
        self.inner.p_setting_name = value.as_ptr();
        self
    }
    #[inline]
    pub fn r#type(mut self, value: LayerSettingTypeEXT) -> Self {
        self.inner.r#type = value;
        self
    }
    #[inline]
    pub fn values(mut self, slice: &'a [core::ffi::c_void]) -> Self {
        self.inner.value_count = slice.len() as u32;
        self.inner.p_values = slice.as_ptr();
        self
    }
}
impl<'a> core::ops::Deref for LayerSettingEXTBuilder<'a> {
    type Target = LayerSettingEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for LayerSettingEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ApplicationParametersEXT`] with lifetime-tied pNext safety.
pub struct ApplicationParametersEXTBuilder<'a> {
    inner: ApplicationParametersEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ApplicationParametersEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ApplicationParametersEXTBuilder<'a> {
        ApplicationParametersEXTBuilder {
            inner: ApplicationParametersEXT {
                s_type: Default::default(),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ApplicationParametersEXTBuilder<'a> {
    #[inline]
    pub fn vendor_id(mut self, value: u32) -> Self {
        self.inner.vendor_id = value;
        self
    }
    #[inline]
    pub fn device_id(mut self, value: u32) -> Self {
        self.inner.device_id = value;
        self
    }
    #[inline]
    pub fn key(mut self, value: u32) -> Self {
        self.inner.key = value;
        self
    }
    #[inline]
    pub fn value(mut self, value: u64) -> Self {
        self.inner.value = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`ApplicationParametersEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsApplicationParametersEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for ApplicationParametersEXTBuilder<'a> {
    type Target = ApplicationParametersEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ApplicationParametersEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PipelineRasterizationStateRasterizationOrderAMD`] with lifetime-tied pNext safety.
pub struct PipelineRasterizationStateRasterizationOrderAMDBuilder<'a> {
    inner: PipelineRasterizationStateRasterizationOrderAMD,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PipelineRasterizationStateRasterizationOrderAMD {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PipelineRasterizationStateRasterizationOrderAMDBuilder<'a> {
        PipelineRasterizationStateRasterizationOrderAMDBuilder {
            inner: PipelineRasterizationStateRasterizationOrderAMD {
                s_type: StructureType::from_raw(1000018000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PipelineRasterizationStateRasterizationOrderAMDBuilder<'a> {
    #[inline]
    pub fn rasterization_order(mut self, value: RasterizationOrderAMD) -> Self {
        self.inner.rasterization_order = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PipelineRasterizationStateRasterizationOrderAMD`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPipelineRasterizationStateRasterizationOrderAMD>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref
for PipelineRasterizationStateRasterizationOrderAMDBuilder<'a> {
    type Target = PipelineRasterizationStateRasterizationOrderAMD;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PipelineRasterizationStateRasterizationOrderAMDBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DebugMarkerObjectNameInfoEXT`] with lifetime-tied pNext safety.
pub struct DebugMarkerObjectNameInfoEXTBuilder<'a> {
    inner: DebugMarkerObjectNameInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DebugMarkerObjectNameInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> DebugMarkerObjectNameInfoEXTBuilder<'a> {
        DebugMarkerObjectNameInfoEXTBuilder {
            inner: DebugMarkerObjectNameInfoEXT {
                s_type: StructureType::from_raw(1000022000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DebugMarkerObjectNameInfoEXTBuilder<'a> {
    #[inline]
    pub fn object_type(mut self, value: DebugReportObjectTypeEXT) -> Self {
        self.inner.object_type = value;
        self
    }
    #[inline]
    pub fn object(mut self, value: u64) -> Self {
        self.inner.object = value;
        self
    }
    #[inline]
    pub fn object_name(mut self, value: &'a core::ffi::CStr) -> Self {
        self.inner.p_object_name = value.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`DebugMarkerObjectNameInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsDebugMarkerObjectNameInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for DebugMarkerObjectNameInfoEXTBuilder<'a> {
    type Target = DebugMarkerObjectNameInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for DebugMarkerObjectNameInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DebugMarkerObjectTagInfoEXT`] with lifetime-tied pNext safety.
pub struct DebugMarkerObjectTagInfoEXTBuilder<'a> {
    inner: DebugMarkerObjectTagInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DebugMarkerObjectTagInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> DebugMarkerObjectTagInfoEXTBuilder<'a> {
        DebugMarkerObjectTagInfoEXTBuilder {
            inner: DebugMarkerObjectTagInfoEXT {
                s_type: StructureType::from_raw(1000022001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DebugMarkerObjectTagInfoEXTBuilder<'a> {
    #[inline]
    pub fn object_type(mut self, value: DebugReportObjectTypeEXT) -> Self {
        self.inner.object_type = value;
        self
    }
    #[inline]
    pub fn object(mut self, value: u64) -> Self {
        self.inner.object = value;
        self
    }
    #[inline]
    pub fn tag_name(mut self, value: u64) -> Self {
        self.inner.tag_name = value;
        self
    }
    #[inline]
    pub fn tag(mut self, slice: &'a [core::ffi::c_void]) -> Self {
        self.inner.tag_size = slice.len();
        self.inner.p_tag = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`DebugMarkerObjectTagInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsDebugMarkerObjectTagInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for DebugMarkerObjectTagInfoEXTBuilder<'a> {
    type Target = DebugMarkerObjectTagInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for DebugMarkerObjectTagInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DebugMarkerMarkerInfoEXT`] with lifetime-tied pNext safety.
pub struct DebugMarkerMarkerInfoEXTBuilder<'a> {
    inner: DebugMarkerMarkerInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DebugMarkerMarkerInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> DebugMarkerMarkerInfoEXTBuilder<'a> {
        DebugMarkerMarkerInfoEXTBuilder {
            inner: DebugMarkerMarkerInfoEXT {
                s_type: StructureType::from_raw(1000022002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DebugMarkerMarkerInfoEXTBuilder<'a> {
    #[inline]
    pub fn marker_name(mut self, value: &'a core::ffi::CStr) -> Self {
        self.inner.p_marker_name = value.as_ptr();
        self
    }
    #[inline]
    pub fn color(mut self, value: [f32; 4usize]) -> Self {
        self.inner.color = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`DebugMarkerMarkerInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsDebugMarkerMarkerInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for DebugMarkerMarkerInfoEXTBuilder<'a> {
    type Target = DebugMarkerMarkerInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for DebugMarkerMarkerInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DedicatedAllocationImageCreateInfoNV`] with lifetime-tied pNext safety.
pub struct DedicatedAllocationImageCreateInfoNVBuilder<'a> {
    inner: DedicatedAllocationImageCreateInfoNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DedicatedAllocationImageCreateInfoNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> DedicatedAllocationImageCreateInfoNVBuilder<'a> {
        DedicatedAllocationImageCreateInfoNVBuilder {
            inner: DedicatedAllocationImageCreateInfoNV {
                s_type: StructureType::from_raw(1000026000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DedicatedAllocationImageCreateInfoNVBuilder<'a> {
    #[inline]
    pub fn dedicated_allocation(mut self, value: bool) -> Self {
        self.inner.dedicated_allocation = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`DedicatedAllocationImageCreateInfoNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsDedicatedAllocationImageCreateInfoNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for DedicatedAllocationImageCreateInfoNVBuilder<'a> {
    type Target = DedicatedAllocationImageCreateInfoNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for DedicatedAllocationImageCreateInfoNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DedicatedAllocationBufferCreateInfoNV`] with lifetime-tied pNext safety.
pub struct DedicatedAllocationBufferCreateInfoNVBuilder<'a> {
    inner: DedicatedAllocationBufferCreateInfoNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DedicatedAllocationBufferCreateInfoNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> DedicatedAllocationBufferCreateInfoNVBuilder<'a> {
        DedicatedAllocationBufferCreateInfoNVBuilder {
            inner: DedicatedAllocationBufferCreateInfoNV {
                s_type: StructureType::from_raw(1000026001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DedicatedAllocationBufferCreateInfoNVBuilder<'a> {
    #[inline]
    pub fn dedicated_allocation(mut self, value: bool) -> Self {
        self.inner.dedicated_allocation = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`DedicatedAllocationBufferCreateInfoNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsDedicatedAllocationBufferCreateInfoNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for DedicatedAllocationBufferCreateInfoNVBuilder<'a> {
    type Target = DedicatedAllocationBufferCreateInfoNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for DedicatedAllocationBufferCreateInfoNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DedicatedAllocationMemoryAllocateInfoNV`] with lifetime-tied pNext safety.
pub struct DedicatedAllocationMemoryAllocateInfoNVBuilder<'a> {
    inner: DedicatedAllocationMemoryAllocateInfoNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DedicatedAllocationMemoryAllocateInfoNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> DedicatedAllocationMemoryAllocateInfoNVBuilder<'a> {
        DedicatedAllocationMemoryAllocateInfoNVBuilder {
            inner: DedicatedAllocationMemoryAllocateInfoNV {
                s_type: StructureType::from_raw(1000026002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DedicatedAllocationMemoryAllocateInfoNVBuilder<'a> {
    #[inline]
    pub fn image(mut self, value: Image) -> Self {
        self.inner.image = value;
        self
    }
    #[inline]
    pub fn buffer(mut self, value: Buffer) -> Self {
        self.inner.buffer = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`DedicatedAllocationMemoryAllocateInfoNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsDedicatedAllocationMemoryAllocateInfoNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for DedicatedAllocationMemoryAllocateInfoNVBuilder<'a> {
    type Target = DedicatedAllocationMemoryAllocateInfoNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for DedicatedAllocationMemoryAllocateInfoNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ExternalImageFormatPropertiesNV`].
pub struct ExternalImageFormatPropertiesNVBuilder {
    inner: ExternalImageFormatPropertiesNV,
}
impl ExternalImageFormatPropertiesNV {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> ExternalImageFormatPropertiesNVBuilder {
        ExternalImageFormatPropertiesNVBuilder {
            inner: ExternalImageFormatPropertiesNV {
                ..Default::default()
            },
        }
    }
}
impl ExternalImageFormatPropertiesNVBuilder {
    #[inline]
    pub fn image_format_properties(mut self, value: ImageFormatProperties) -> Self {
        self.inner.image_format_properties = value;
        self
    }
    #[inline]
    pub fn external_memory_features(
        mut self,
        value: ExternalMemoryFeatureFlagsNV,
    ) -> Self {
        self.inner.external_memory_features = value;
        self
    }
    #[inline]
    pub fn export_from_imported_handle_types(
        mut self,
        value: ExternalMemoryHandleTypeFlagsNV,
    ) -> Self {
        self.inner.export_from_imported_handle_types = value;
        self
    }
    #[inline]
    pub fn compatible_handle_types(
        mut self,
        value: ExternalMemoryHandleTypeFlagsNV,
    ) -> Self {
        self.inner.compatible_handle_types = value;
        self
    }
}
impl core::ops::Deref for ExternalImageFormatPropertiesNVBuilder {
    type Target = ExternalImageFormatPropertiesNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for ExternalImageFormatPropertiesNVBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ExternalMemoryImageCreateInfoNV`] with lifetime-tied pNext safety.
pub struct ExternalMemoryImageCreateInfoNVBuilder<'a> {
    inner: ExternalMemoryImageCreateInfoNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ExternalMemoryImageCreateInfoNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ExternalMemoryImageCreateInfoNVBuilder<'a> {
        ExternalMemoryImageCreateInfoNVBuilder {
            inner: ExternalMemoryImageCreateInfoNV {
                s_type: StructureType::from_raw(1000056000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ExternalMemoryImageCreateInfoNVBuilder<'a> {
    #[inline]
    pub fn handle_types(mut self, value: ExternalMemoryHandleTypeFlagsNV) -> Self {
        self.inner.handle_types = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`ExternalMemoryImageCreateInfoNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsExternalMemoryImageCreateInfoNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for ExternalMemoryImageCreateInfoNVBuilder<'a> {
    type Target = ExternalMemoryImageCreateInfoNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ExternalMemoryImageCreateInfoNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ExportMemoryAllocateInfoNV`] with lifetime-tied pNext safety.
pub struct ExportMemoryAllocateInfoNVBuilder<'a> {
    inner: ExportMemoryAllocateInfoNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ExportMemoryAllocateInfoNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ExportMemoryAllocateInfoNVBuilder<'a> {
        ExportMemoryAllocateInfoNVBuilder {
            inner: ExportMemoryAllocateInfoNV {
                s_type: StructureType::from_raw(1000056001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ExportMemoryAllocateInfoNVBuilder<'a> {
    #[inline]
    pub fn handle_types(mut self, value: ExternalMemoryHandleTypeFlagsNV) -> Self {
        self.inner.handle_types = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`ExportMemoryAllocateInfoNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsExportMemoryAllocateInfoNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for ExportMemoryAllocateInfoNVBuilder<'a> {
    type Target = ExportMemoryAllocateInfoNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ExportMemoryAllocateInfoNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ImportMemoryWin32HandleInfoNV`] with lifetime-tied pNext safety.
pub struct ImportMemoryWin32HandleInfoNVBuilder<'a> {
    inner: ImportMemoryWin32HandleInfoNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ImportMemoryWin32HandleInfoNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ImportMemoryWin32HandleInfoNVBuilder<'a> {
        ImportMemoryWin32HandleInfoNVBuilder {
            inner: ImportMemoryWin32HandleInfoNV {
                s_type: StructureType::from_raw(1000057000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ImportMemoryWin32HandleInfoNVBuilder<'a> {
    #[inline]
    pub fn handle_type(mut self, value: ExternalMemoryHandleTypeFlagsNV) -> Self {
        self.inner.handle_type = value;
        self
    }
    #[inline]
    pub fn handle(mut self, value: isize) -> Self {
        self.inner.handle = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`ImportMemoryWin32HandleInfoNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsImportMemoryWin32HandleInfoNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for ImportMemoryWin32HandleInfoNVBuilder<'a> {
    type Target = ImportMemoryWin32HandleInfoNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ImportMemoryWin32HandleInfoNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ExportMemoryWin32HandleInfoNV`] with lifetime-tied pNext safety.
pub struct ExportMemoryWin32HandleInfoNVBuilder<'a> {
    inner: ExportMemoryWin32HandleInfoNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ExportMemoryWin32HandleInfoNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ExportMemoryWin32HandleInfoNVBuilder<'a> {
        ExportMemoryWin32HandleInfoNVBuilder {
            inner: ExportMemoryWin32HandleInfoNV {
                s_type: StructureType::from_raw(1000057001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ExportMemoryWin32HandleInfoNVBuilder<'a> {
    #[inline]
    pub fn attributes(mut self, value: *const core::ffi::c_void) -> Self {
        self.inner.p_attributes = value;
        self
    }
    #[inline]
    pub fn dw_access(mut self, value: u32) -> Self {
        self.inner.dw_access = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`ExportMemoryWin32HandleInfoNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsExportMemoryWin32HandleInfoNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for ExportMemoryWin32HandleInfoNVBuilder<'a> {
    type Target = ExportMemoryWin32HandleInfoNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ExportMemoryWin32HandleInfoNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ExportMemorySciBufInfoNV`] with lifetime-tied pNext safety.
pub struct ExportMemorySciBufInfoNVBuilder<'a> {
    inner: ExportMemorySciBufInfoNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ExportMemorySciBufInfoNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ExportMemorySciBufInfoNVBuilder<'a> {
        ExportMemorySciBufInfoNVBuilder {
            inner: ExportMemorySciBufInfoNV {
                s_type: Default::default(),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ExportMemorySciBufInfoNVBuilder<'a> {
    #[inline]
    pub fn p_attributes(mut self, value: *const core::ffi::c_void) -> Self {
        self.inner.p_attributes = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`ExportMemorySciBufInfoNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsExportMemorySciBufInfoNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for ExportMemorySciBufInfoNVBuilder<'a> {
    type Target = ExportMemorySciBufInfoNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ExportMemorySciBufInfoNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ImportMemorySciBufInfoNV`] with lifetime-tied pNext safety.
pub struct ImportMemorySciBufInfoNVBuilder<'a> {
    inner: ImportMemorySciBufInfoNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ImportMemorySciBufInfoNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ImportMemorySciBufInfoNVBuilder<'a> {
        ImportMemorySciBufInfoNVBuilder {
            inner: ImportMemorySciBufInfoNV {
                s_type: Default::default(),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ImportMemorySciBufInfoNVBuilder<'a> {
    #[inline]
    pub fn handle_type(mut self, value: ExternalMemoryHandleTypeFlagBits) -> Self {
        self.inner.handle_type = value;
        self
    }
    #[inline]
    pub fn handle(mut self, value: *const core::ffi::c_void) -> Self {
        self.inner.handle = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`ImportMemorySciBufInfoNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsImportMemorySciBufInfoNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for ImportMemorySciBufInfoNVBuilder<'a> {
    type Target = ImportMemorySciBufInfoNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ImportMemorySciBufInfoNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`MemoryGetSciBufInfoNV`] with lifetime-tied pNext safety.
pub struct MemoryGetSciBufInfoNVBuilder<'a> {
    inner: MemoryGetSciBufInfoNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl MemoryGetSciBufInfoNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> MemoryGetSciBufInfoNVBuilder<'a> {
        MemoryGetSciBufInfoNVBuilder {
            inner: MemoryGetSciBufInfoNV {
                s_type: Default::default(),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> MemoryGetSciBufInfoNVBuilder<'a> {
    #[inline]
    pub fn memory(mut self, value: DeviceMemory) -> Self {
        self.inner.memory = value;
        self
    }
    #[inline]
    pub fn handle_type(mut self, value: ExternalMemoryHandleTypeFlagBits) -> Self {
        self.inner.handle_type = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`MemoryGetSciBufInfoNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsMemoryGetSciBufInfoNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for MemoryGetSciBufInfoNVBuilder<'a> {
    type Target = MemoryGetSciBufInfoNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for MemoryGetSciBufInfoNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`MemorySciBufPropertiesNV`] with lifetime-tied pNext safety.
pub struct MemorySciBufPropertiesNVBuilder<'a> {
    inner: MemorySciBufPropertiesNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl MemorySciBufPropertiesNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> MemorySciBufPropertiesNVBuilder<'a> {
        MemorySciBufPropertiesNVBuilder {
            inner: MemorySciBufPropertiesNV {
                s_type: Default::default(),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> MemorySciBufPropertiesNVBuilder<'a> {
    #[inline]
    pub fn memory_type_bits(mut self, value: u32) -> Self {
        self.inner.memory_type_bits = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`MemorySciBufPropertiesNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsMemorySciBufPropertiesNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for MemorySciBufPropertiesNVBuilder<'a> {
    type Target = MemorySciBufPropertiesNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for MemorySciBufPropertiesNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceExternalMemorySciBufFeaturesNV`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceExternalMemorySciBufFeaturesNVBuilder<'a> {
    inner: PhysicalDeviceExternalMemorySciBufFeaturesNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceExternalMemorySciBufFeaturesNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceExternalMemorySciBufFeaturesNVBuilder<'a> {
        PhysicalDeviceExternalMemorySciBufFeaturesNVBuilder {
            inner: PhysicalDeviceExternalMemorySciBufFeaturesNV {
                s_type: Default::default(),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceExternalMemorySciBufFeaturesNVBuilder<'a> {
    #[inline]
    pub fn sci_buf_import(mut self, value: bool) -> Self {
        self.inner.sci_buf_import = value as u32;
        self
    }
    #[inline]
    pub fn sci_buf_export(mut self, value: bool) -> Self {
        self.inner.sci_buf_export = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceExternalMemorySciBufFeaturesNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceExternalMemorySciBufFeaturesNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceExternalMemorySciBufFeaturesNVBuilder<'a> {
    type Target = PhysicalDeviceExternalMemorySciBufFeaturesNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceExternalMemorySciBufFeaturesNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`Win32KeyedMutexAcquireReleaseInfoNV`] with lifetime-tied pNext safety.
pub struct Win32KeyedMutexAcquireReleaseInfoNVBuilder<'a> {
    inner: Win32KeyedMutexAcquireReleaseInfoNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl Win32KeyedMutexAcquireReleaseInfoNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> Win32KeyedMutexAcquireReleaseInfoNVBuilder<'a> {
        Win32KeyedMutexAcquireReleaseInfoNVBuilder {
            inner: Win32KeyedMutexAcquireReleaseInfoNV {
                s_type: StructureType::from_raw(1000058000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> Win32KeyedMutexAcquireReleaseInfoNVBuilder<'a> {
    #[inline]
    pub fn acquire_syncs(mut self, slice: &'a [DeviceMemory]) -> Self {
        self.inner.acquire_count = slice.len() as u32;
        self.inner.p_acquire_syncs = slice.as_ptr();
        self
    }
    #[inline]
    pub fn acquire_keys(mut self, slice: &'a [u64]) -> Self {
        self.inner.acquire_count = slice.len() as u32;
        self.inner.p_acquire_keys = slice.as_ptr();
        self
    }
    #[inline]
    pub fn acquire_timeout_milliseconds(mut self, slice: &'a [u32]) -> Self {
        self.inner.acquire_count = slice.len() as u32;
        self.inner.p_acquire_timeout_milliseconds = slice.as_ptr();
        self
    }
    #[inline]
    pub fn release_syncs(mut self, slice: &'a [DeviceMemory]) -> Self {
        self.inner.release_count = slice.len() as u32;
        self.inner.p_release_syncs = slice.as_ptr();
        self
    }
    #[inline]
    pub fn release_keys(mut self, slice: &'a [u64]) -> Self {
        self.inner.release_count = slice.len() as u32;
        self.inner.p_release_keys = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`Win32KeyedMutexAcquireReleaseInfoNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsWin32KeyedMutexAcquireReleaseInfoNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for Win32KeyedMutexAcquireReleaseInfoNVBuilder<'a> {
    type Target = Win32KeyedMutexAcquireReleaseInfoNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for Win32KeyedMutexAcquireReleaseInfoNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceDeviceGeneratedCommandsFeaturesNV`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceDeviceGeneratedCommandsFeaturesNVBuilder<'a> {
    inner: PhysicalDeviceDeviceGeneratedCommandsFeaturesNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceDeviceGeneratedCommandsFeaturesNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceDeviceGeneratedCommandsFeaturesNVBuilder<'a> {
        PhysicalDeviceDeviceGeneratedCommandsFeaturesNVBuilder {
            inner: PhysicalDeviceDeviceGeneratedCommandsFeaturesNV {
                s_type: StructureType::from_raw(1000277007i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceDeviceGeneratedCommandsFeaturesNVBuilder<'a> {
    #[inline]
    pub fn device_generated_commands(mut self, value: bool) -> Self {
        self.inner.device_generated_commands = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceDeviceGeneratedCommandsFeaturesNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceDeviceGeneratedCommandsFeaturesNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDeviceDeviceGeneratedCommandsFeaturesNVBuilder<'a> {
    type Target = PhysicalDeviceDeviceGeneratedCommandsFeaturesNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceDeviceGeneratedCommandsFeaturesNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PushConstantBankInfoNV`] with lifetime-tied pNext safety.
pub struct PushConstantBankInfoNVBuilder<'a> {
    inner: PushConstantBankInfoNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PushConstantBankInfoNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PushConstantBankInfoNVBuilder<'a> {
        PushConstantBankInfoNVBuilder {
            inner: PushConstantBankInfoNV {
                s_type: StructureType::from_raw(1000580000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PushConstantBankInfoNVBuilder<'a> {
    #[inline]
    pub fn bank(mut self, value: u32) -> Self {
        self.inner.bank = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PushConstantBankInfoNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPushConstantBankInfoNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for PushConstantBankInfoNVBuilder<'a> {
    type Target = PushConstantBankInfoNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PushConstantBankInfoNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDevicePushConstantBankFeaturesNV`] with lifetime-tied pNext safety.
pub struct PhysicalDevicePushConstantBankFeaturesNVBuilder<'a> {
    inner: PhysicalDevicePushConstantBankFeaturesNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDevicePushConstantBankFeaturesNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDevicePushConstantBankFeaturesNVBuilder<'a> {
        PhysicalDevicePushConstantBankFeaturesNVBuilder {
            inner: PhysicalDevicePushConstantBankFeaturesNV {
                s_type: StructureType::from_raw(1000580001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDevicePushConstantBankFeaturesNVBuilder<'a> {
    #[inline]
    pub fn push_constant_bank(mut self, value: bool) -> Self {
        self.inner.push_constant_bank = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDevicePushConstantBankFeaturesNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDevicePushConstantBankFeaturesNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDevicePushConstantBankFeaturesNVBuilder<'a> {
    type Target = PhysicalDevicePushConstantBankFeaturesNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDevicePushConstantBankFeaturesNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDevicePushConstantBankPropertiesNV`] with lifetime-tied pNext safety.
pub struct PhysicalDevicePushConstantBankPropertiesNVBuilder<'a> {
    inner: PhysicalDevicePushConstantBankPropertiesNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDevicePushConstantBankPropertiesNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDevicePushConstantBankPropertiesNVBuilder<'a> {
        PhysicalDevicePushConstantBankPropertiesNVBuilder {
            inner: PhysicalDevicePushConstantBankPropertiesNV {
                s_type: StructureType::from_raw(1000580002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDevicePushConstantBankPropertiesNVBuilder<'a> {
    #[inline]
    pub fn max_graphics_push_constant_banks(mut self, value: u32) -> Self {
        self.inner.max_graphics_push_constant_banks = value;
        self
    }
    #[inline]
    pub fn max_compute_push_constant_banks(mut self, value: u32) -> Self {
        self.inner.max_compute_push_constant_banks = value;
        self
    }
    #[inline]
    pub fn max_graphics_push_data_banks(mut self, value: u32) -> Self {
        self.inner.max_graphics_push_data_banks = value;
        self
    }
    #[inline]
    pub fn max_compute_push_data_banks(mut self, value: u32) -> Self {
        self.inner.max_compute_push_data_banks = value;
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDevicePushConstantBankPropertiesNVBuilder<'a> {
    type Target = PhysicalDevicePushConstantBankPropertiesNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDevicePushConstantBankPropertiesNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNVBuilder<'a> {
    inner: PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNVBuilder<
        'a,
    > {
        PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNVBuilder {
            inner: PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV {
                s_type: StructureType::from_raw(1000428000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNVBuilder<'a> {
    #[inline]
    pub fn device_generated_compute(mut self, value: bool) -> Self {
        self.inner.device_generated_compute = value as u32;
        self
    }
    #[inline]
    pub fn device_generated_compute_pipelines(mut self, value: bool) -> Self {
        self.inner.device_generated_compute_pipelines = value as u32;
        self
    }
    #[inline]
    pub fn device_generated_compute_capture_replay(mut self, value: bool) -> Self {
        self.inner.device_generated_compute_capture_replay = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNVBuilder<'a> {
    type Target = PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DevicePrivateDataCreateInfo`] with lifetime-tied pNext safety.
pub struct DevicePrivateDataCreateInfoBuilder<'a> {
    inner: DevicePrivateDataCreateInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DevicePrivateDataCreateInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> DevicePrivateDataCreateInfoBuilder<'a> {
        DevicePrivateDataCreateInfoBuilder {
            inner: DevicePrivateDataCreateInfo {
                s_type: StructureType::from_raw(1000295001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DevicePrivateDataCreateInfoBuilder<'a> {
    #[inline]
    pub fn private_data_slot_request_count(mut self, value: u32) -> Self {
        self.inner.private_data_slot_request_count = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`DevicePrivateDataCreateInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsDevicePrivateDataCreateInfo>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for DevicePrivateDataCreateInfoBuilder<'a> {
    type Target = DevicePrivateDataCreateInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for DevicePrivateDataCreateInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PrivateDataSlotCreateInfo`] with lifetime-tied pNext safety.
pub struct PrivateDataSlotCreateInfoBuilder<'a> {
    inner: PrivateDataSlotCreateInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PrivateDataSlotCreateInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PrivateDataSlotCreateInfoBuilder<'a> {
        PrivateDataSlotCreateInfoBuilder {
            inner: PrivateDataSlotCreateInfo {
                s_type: StructureType::from_raw(1000295002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PrivateDataSlotCreateInfoBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: PrivateDataSlotCreateFlags) -> Self {
        self.inner.flags = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PrivateDataSlotCreateInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPrivateDataSlotCreateInfo>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for PrivateDataSlotCreateInfoBuilder<'a> {
    type Target = PrivateDataSlotCreateInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PrivateDataSlotCreateInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDevicePrivateDataFeatures`] with lifetime-tied pNext safety.
pub struct PhysicalDevicePrivateDataFeaturesBuilder<'a> {
    inner: PhysicalDevicePrivateDataFeatures,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDevicePrivateDataFeatures {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDevicePrivateDataFeaturesBuilder<'a> {
        PhysicalDevicePrivateDataFeaturesBuilder {
            inner: PhysicalDevicePrivateDataFeatures {
                s_type: StructureType::from_raw(1000295000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDevicePrivateDataFeaturesBuilder<'a> {
    #[inline]
    pub fn private_data(mut self, value: bool) -> Self {
        self.inner.private_data = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDevicePrivateDataFeatures`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDevicePrivateDataFeatures>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDevicePrivateDataFeaturesBuilder<'a> {
    type Target = PhysicalDevicePrivateDataFeatures;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDevicePrivateDataFeaturesBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceDeviceGeneratedCommandsPropertiesNV`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder<'a> {
    inner: PhysicalDeviceDeviceGeneratedCommandsPropertiesNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceDeviceGeneratedCommandsPropertiesNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder<
        'a,
    > {
        PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder {
            inner: PhysicalDeviceDeviceGeneratedCommandsPropertiesNV {
                s_type: StructureType::from_raw(1000277000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder<'a> {
    #[inline]
    pub fn max_graphics_shader_group_count(mut self, value: u32) -> Self {
        self.inner.max_graphics_shader_group_count = value;
        self
    }
    #[inline]
    pub fn max_indirect_sequence_count(mut self, value: u32) -> Self {
        self.inner.max_indirect_sequence_count = value;
        self
    }
    #[inline]
    pub fn max_indirect_commands_token_count(mut self, value: u32) -> Self {
        self.inner.max_indirect_commands_token_count = value;
        self
    }
    #[inline]
    pub fn max_indirect_commands_stream_count(mut self, value: u32) -> Self {
        self.inner.max_indirect_commands_stream_count = value;
        self
    }
    #[inline]
    pub fn max_indirect_commands_token_offset(mut self, value: u32) -> Self {
        self.inner.max_indirect_commands_token_offset = value;
        self
    }
    #[inline]
    pub fn max_indirect_commands_stream_stride(mut self, value: u32) -> Self {
        self.inner.max_indirect_commands_stream_stride = value;
        self
    }
    #[inline]
    pub fn min_sequences_count_buffer_offset_alignment(mut self, value: u32) -> Self {
        self.inner.min_sequences_count_buffer_offset_alignment = value;
        self
    }
    #[inline]
    pub fn min_sequences_index_buffer_offset_alignment(mut self, value: u32) -> Self {
        self.inner.min_sequences_index_buffer_offset_alignment = value;
        self
    }
    #[inline]
    pub fn min_indirect_commands_buffer_offset_alignment(mut self, value: u32) -> Self {
        self.inner.min_indirect_commands_buffer_offset_alignment = value;
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder<'a> {
    type Target = PhysicalDeviceDeviceGeneratedCommandsPropertiesNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceClusterAccelerationStructureFeaturesNV`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceClusterAccelerationStructureFeaturesNVBuilder<'a> {
    inner: PhysicalDeviceClusterAccelerationStructureFeaturesNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceClusterAccelerationStructureFeaturesNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceClusterAccelerationStructureFeaturesNVBuilder<
        'a,
    > {
        PhysicalDeviceClusterAccelerationStructureFeaturesNVBuilder {
            inner: PhysicalDeviceClusterAccelerationStructureFeaturesNV {
                s_type: StructureType::from_raw(1000569000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceClusterAccelerationStructureFeaturesNVBuilder<'a> {
    #[inline]
    pub fn cluster_acceleration_structure(mut self, value: bool) -> Self {
        self.inner.cluster_acceleration_structure = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceClusterAccelerationStructureFeaturesNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceClusterAccelerationStructureFeaturesNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDeviceClusterAccelerationStructureFeaturesNVBuilder<'a> {
    type Target = PhysicalDeviceClusterAccelerationStructureFeaturesNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceClusterAccelerationStructureFeaturesNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceClusterAccelerationStructurePropertiesNV`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceClusterAccelerationStructurePropertiesNVBuilder<'a> {
    inner: PhysicalDeviceClusterAccelerationStructurePropertiesNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceClusterAccelerationStructurePropertiesNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceClusterAccelerationStructurePropertiesNVBuilder<
        'a,
    > {
        PhysicalDeviceClusterAccelerationStructurePropertiesNVBuilder {
            inner: PhysicalDeviceClusterAccelerationStructurePropertiesNV {
                s_type: StructureType::from_raw(1000569001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceClusterAccelerationStructurePropertiesNVBuilder<'a> {
    #[inline]
    pub fn max_vertices_per_cluster(mut self, value: u32) -> Self {
        self.inner.max_vertices_per_cluster = value;
        self
    }
    #[inline]
    pub fn max_triangles_per_cluster(mut self, value: u32) -> Self {
        self.inner.max_triangles_per_cluster = value;
        self
    }
    #[inline]
    pub fn cluster_scratch_byte_alignment(mut self, value: u32) -> Self {
        self.inner.cluster_scratch_byte_alignment = value;
        self
    }
    #[inline]
    pub fn cluster_byte_alignment(mut self, value: u32) -> Self {
        self.inner.cluster_byte_alignment = value;
        self
    }
    #[inline]
    pub fn cluster_template_byte_alignment(mut self, value: u32) -> Self {
        self.inner.cluster_template_byte_alignment = value;
        self
    }
    #[inline]
    pub fn cluster_bottom_level_byte_alignment(mut self, value: u32) -> Self {
        self.inner.cluster_bottom_level_byte_alignment = value;
        self
    }
    #[inline]
    pub fn cluster_template_bounds_byte_alignment(mut self, value: u32) -> Self {
        self.inner.cluster_template_bounds_byte_alignment = value;
        self
    }
    #[inline]
    pub fn max_cluster_geometry_index(mut self, value: u32) -> Self {
        self.inner.max_cluster_geometry_index = value;
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDeviceClusterAccelerationStructurePropertiesNVBuilder<'a> {
    type Target = PhysicalDeviceClusterAccelerationStructurePropertiesNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceClusterAccelerationStructurePropertiesNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`StridedDeviceAddressNV`].
pub struct StridedDeviceAddressNVBuilder {
    inner: StridedDeviceAddressNV,
}
impl StridedDeviceAddressNV {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> StridedDeviceAddressNVBuilder {
        StridedDeviceAddressNVBuilder {
            inner: StridedDeviceAddressNV {
                ..Default::default()
            },
        }
    }
}
impl StridedDeviceAddressNVBuilder {
    #[inline]
    pub fn start_address(mut self, value: u64) -> Self {
        self.inner.start_address = value;
        self
    }
    #[inline]
    pub fn stride_in_bytes(mut self, value: u64) -> Self {
        self.inner.stride_in_bytes = value;
        self
    }
}
impl core::ops::Deref for StridedDeviceAddressNVBuilder {
    type Target = StridedDeviceAddressNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for StridedDeviceAddressNVBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`RayTracingPipelineClusterAccelerationStructureCreateInfoNV`] with lifetime-tied pNext safety.
pub struct RayTracingPipelineClusterAccelerationStructureCreateInfoNVBuilder<'a> {
    inner: RayTracingPipelineClusterAccelerationStructureCreateInfoNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl RayTracingPipelineClusterAccelerationStructureCreateInfoNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> RayTracingPipelineClusterAccelerationStructureCreateInfoNVBuilder<
        'a,
    > {
        RayTracingPipelineClusterAccelerationStructureCreateInfoNVBuilder {
            inner: RayTracingPipelineClusterAccelerationStructureCreateInfoNV {
                s_type: StructureType::from_raw(1000569007i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> RayTracingPipelineClusterAccelerationStructureCreateInfoNVBuilder<'a> {
    #[inline]
    pub fn allow_cluster_acceleration_structure(mut self, value: bool) -> Self {
        self.inner.allow_cluster_acceleration_structure = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`RayTracingPipelineClusterAccelerationStructureCreateInfoNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<
        T: ExtendsRayTracingPipelineClusterAccelerationStructureCreateInfoNV,
    >(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref
for RayTracingPipelineClusterAccelerationStructureCreateInfoNVBuilder<'a> {
    type Target = RayTracingPipelineClusterAccelerationStructureCreateInfoNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for RayTracingPipelineClusterAccelerationStructureCreateInfoNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ClusterAccelerationStructureMoveObjectsInfoNV`].
pub struct ClusterAccelerationStructureMoveObjectsInfoNVBuilder {
    inner: ClusterAccelerationStructureMoveObjectsInfoNV,
}
impl ClusterAccelerationStructureMoveObjectsInfoNV {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> ClusterAccelerationStructureMoveObjectsInfoNVBuilder {
        ClusterAccelerationStructureMoveObjectsInfoNVBuilder {
            inner: ClusterAccelerationStructureMoveObjectsInfoNV {
                ..Default::default()
            },
        }
    }
}
impl ClusterAccelerationStructureMoveObjectsInfoNVBuilder {
    #[inline]
    pub fn src_acceleration_structure(mut self, value: u64) -> Self {
        self.inner.src_acceleration_structure = value;
        self
    }
}
impl core::ops::Deref for ClusterAccelerationStructureMoveObjectsInfoNVBuilder {
    type Target = ClusterAccelerationStructureMoveObjectsInfoNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for ClusterAccelerationStructureMoveObjectsInfoNVBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ClusterAccelerationStructureBuildClustersBottomLevelInfoNV`].
pub struct ClusterAccelerationStructureBuildClustersBottomLevelInfoNVBuilder {
    inner: ClusterAccelerationStructureBuildClustersBottomLevelInfoNV,
}
impl ClusterAccelerationStructureBuildClustersBottomLevelInfoNV {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> ClusterAccelerationStructureBuildClustersBottomLevelInfoNVBuilder {
        ClusterAccelerationStructureBuildClustersBottomLevelInfoNVBuilder {
            inner: ClusterAccelerationStructureBuildClustersBottomLevelInfoNV {
                ..Default::default()
            },
        }
    }
}
impl ClusterAccelerationStructureBuildClustersBottomLevelInfoNVBuilder {
    #[inline]
    pub fn cluster_references_count(mut self, value: u32) -> Self {
        self.inner.cluster_references_count = value;
        self
    }
    #[inline]
    pub fn cluster_references_stride(mut self, value: u32) -> Self {
        self.inner.cluster_references_stride = value;
        self
    }
    #[inline]
    pub fn cluster_references(mut self, value: u64) -> Self {
        self.inner.cluster_references = value;
        self
    }
}
impl core::ops::Deref
for ClusterAccelerationStructureBuildClustersBottomLevelInfoNVBuilder {
    type Target = ClusterAccelerationStructureBuildClustersBottomLevelInfoNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut
for ClusterAccelerationStructureBuildClustersBottomLevelInfoNVBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ClusterAccelerationStructureGetTemplateIndicesInfoNV`].
pub struct ClusterAccelerationStructureGetTemplateIndicesInfoNVBuilder {
    inner: ClusterAccelerationStructureGetTemplateIndicesInfoNV,
}
impl ClusterAccelerationStructureGetTemplateIndicesInfoNV {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> ClusterAccelerationStructureGetTemplateIndicesInfoNVBuilder {
        ClusterAccelerationStructureGetTemplateIndicesInfoNVBuilder {
            inner: ClusterAccelerationStructureGetTemplateIndicesInfoNV {
                ..Default::default()
            },
        }
    }
}
impl ClusterAccelerationStructureGetTemplateIndicesInfoNVBuilder {
    #[inline]
    pub fn cluster_template_address(mut self, value: u64) -> Self {
        self.inner.cluster_template_address = value;
        self
    }
}
impl core::ops::Deref for ClusterAccelerationStructureGetTemplateIndicesInfoNVBuilder {
    type Target = ClusterAccelerationStructureGetTemplateIndicesInfoNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut
for ClusterAccelerationStructureGetTemplateIndicesInfoNVBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ClusterAccelerationStructureClustersBottomLevelInputNV`] with lifetime-tied pNext safety.
pub struct ClusterAccelerationStructureClustersBottomLevelInputNVBuilder<'a> {
    inner: ClusterAccelerationStructureClustersBottomLevelInputNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ClusterAccelerationStructureClustersBottomLevelInputNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ClusterAccelerationStructureClustersBottomLevelInputNVBuilder<
        'a,
    > {
        ClusterAccelerationStructureClustersBottomLevelInputNVBuilder {
            inner: ClusterAccelerationStructureClustersBottomLevelInputNV {
                s_type: StructureType::from_raw(1000569002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ClusterAccelerationStructureClustersBottomLevelInputNVBuilder<'a> {
    #[inline]
    pub fn max_total_cluster_count(mut self, value: u32) -> Self {
        self.inner.max_total_cluster_count = value;
        self
    }
    #[inline]
    pub fn max_cluster_count_per_acceleration_structure(mut self, value: u32) -> Self {
        self.inner.max_cluster_count_per_acceleration_structure = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`ClusterAccelerationStructureClustersBottomLevelInputNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsClusterAccelerationStructureClustersBottomLevelInputNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref
for ClusterAccelerationStructureClustersBottomLevelInputNVBuilder<'a> {
    type Target = ClusterAccelerationStructureClustersBottomLevelInputNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for ClusterAccelerationStructureClustersBottomLevelInputNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ClusterAccelerationStructureTriangleClusterInputNV`] with lifetime-tied pNext safety.
pub struct ClusterAccelerationStructureTriangleClusterInputNVBuilder<'a> {
    inner: ClusterAccelerationStructureTriangleClusterInputNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ClusterAccelerationStructureTriangleClusterInputNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ClusterAccelerationStructureTriangleClusterInputNVBuilder<
        'a,
    > {
        ClusterAccelerationStructureTriangleClusterInputNVBuilder {
            inner: ClusterAccelerationStructureTriangleClusterInputNV {
                s_type: StructureType::from_raw(1000569003i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ClusterAccelerationStructureTriangleClusterInputNVBuilder<'a> {
    #[inline]
    pub fn vertex_format(mut self, value: Format) -> Self {
        self.inner.vertex_format = value;
        self
    }
    #[inline]
    pub fn max_geometry_index_value(mut self, value: u32) -> Self {
        self.inner.max_geometry_index_value = value;
        self
    }
    #[inline]
    pub fn max_cluster_unique_geometry_count(mut self, value: u32) -> Self {
        self.inner.max_cluster_unique_geometry_count = value;
        self
    }
    #[inline]
    pub fn max_cluster_triangle_count(mut self, value: u32) -> Self {
        self.inner.max_cluster_triangle_count = value;
        self
    }
    #[inline]
    pub fn max_cluster_vertex_count(mut self, value: u32) -> Self {
        self.inner.max_cluster_vertex_count = value;
        self
    }
    #[inline]
    pub fn max_total_triangle_count(mut self, value: u32) -> Self {
        self.inner.max_total_triangle_count = value;
        self
    }
    #[inline]
    pub fn max_total_vertex_count(mut self, value: u32) -> Self {
        self.inner.max_total_vertex_count = value;
        self
    }
    #[inline]
    pub fn min_position_truncate_bit_count(mut self, value: u32) -> Self {
        self.inner.min_position_truncate_bit_count = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`ClusterAccelerationStructureTriangleClusterInputNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsClusterAccelerationStructureTriangleClusterInputNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref
for ClusterAccelerationStructureTriangleClusterInputNVBuilder<'a> {
    type Target = ClusterAccelerationStructureTriangleClusterInputNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for ClusterAccelerationStructureTriangleClusterInputNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ClusterAccelerationStructureMoveObjectsInputNV`] with lifetime-tied pNext safety.
pub struct ClusterAccelerationStructureMoveObjectsInputNVBuilder<'a> {
    inner: ClusterAccelerationStructureMoveObjectsInputNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ClusterAccelerationStructureMoveObjectsInputNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ClusterAccelerationStructureMoveObjectsInputNVBuilder<'a> {
        ClusterAccelerationStructureMoveObjectsInputNVBuilder {
            inner: ClusterAccelerationStructureMoveObjectsInputNV {
                s_type: StructureType::from_raw(1000569004i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ClusterAccelerationStructureMoveObjectsInputNVBuilder<'a> {
    #[inline]
    pub fn r#type(mut self, value: ClusterAccelerationStructureTypeNV) -> Self {
        self.inner.r#type = value;
        self
    }
    #[inline]
    pub fn no_move_overlap(mut self, value: bool) -> Self {
        self.inner.no_move_overlap = value as u32;
        self
    }
    #[inline]
    pub fn max_moved_bytes(mut self, value: u64) -> Self {
        self.inner.max_moved_bytes = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`ClusterAccelerationStructureMoveObjectsInputNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsClusterAccelerationStructureMoveObjectsInputNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for ClusterAccelerationStructureMoveObjectsInputNVBuilder<'a> {
    type Target = ClusterAccelerationStructureMoveObjectsInputNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for ClusterAccelerationStructureMoveObjectsInputNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ClusterAccelerationStructureInputInfoNV`] with lifetime-tied pNext safety.
pub struct ClusterAccelerationStructureInputInfoNVBuilder<'a> {
    inner: ClusterAccelerationStructureInputInfoNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ClusterAccelerationStructureInputInfoNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ClusterAccelerationStructureInputInfoNVBuilder<'a> {
        ClusterAccelerationStructureInputInfoNVBuilder {
            inner: ClusterAccelerationStructureInputInfoNV {
                s_type: StructureType::from_raw(1000569005i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ClusterAccelerationStructureInputInfoNVBuilder<'a> {
    #[inline]
    pub fn max_acceleration_structure_count(mut self, value: u32) -> Self {
        self.inner.max_acceleration_structure_count = value;
        self
    }
    #[inline]
    pub fn flags(mut self, value: BuildAccelerationStructureFlagsKHR) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn op_type(mut self, value: ClusterAccelerationStructureOpTypeNV) -> Self {
        self.inner.op_type = value;
        self
    }
    #[inline]
    pub fn op_mode(mut self, value: ClusterAccelerationStructureOpModeNV) -> Self {
        self.inner.op_mode = value;
        self
    }
    #[inline]
    pub fn op_input(mut self, value: ClusterAccelerationStructureOpInputNV) -> Self {
        self.inner.op_input = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`ClusterAccelerationStructureInputInfoNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsClusterAccelerationStructureInputInfoNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for ClusterAccelerationStructureInputInfoNVBuilder<'a> {
    type Target = ClusterAccelerationStructureInputInfoNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ClusterAccelerationStructureInputInfoNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ClusterAccelerationStructureCommandsInfoNV`] with lifetime-tied pNext safety.
pub struct ClusterAccelerationStructureCommandsInfoNVBuilder<'a> {
    inner: ClusterAccelerationStructureCommandsInfoNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ClusterAccelerationStructureCommandsInfoNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ClusterAccelerationStructureCommandsInfoNVBuilder<'a> {
        ClusterAccelerationStructureCommandsInfoNVBuilder {
            inner: ClusterAccelerationStructureCommandsInfoNV {
                s_type: StructureType::from_raw(1000569006i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ClusterAccelerationStructureCommandsInfoNVBuilder<'a> {
    #[inline]
    pub fn input(mut self, value: ClusterAccelerationStructureInputInfoNV) -> Self {
        self.inner.input = value;
        self
    }
    #[inline]
    pub fn dst_implicit_data(mut self, value: u64) -> Self {
        self.inner.dst_implicit_data = value;
        self
    }
    #[inline]
    pub fn scratch_data(mut self, value: u64) -> Self {
        self.inner.scratch_data = value;
        self
    }
    #[inline]
    pub fn dst_addresses_array(mut self, value: StridedDeviceAddressRegionKHR) -> Self {
        self.inner.dst_addresses_array = value;
        self
    }
    #[inline]
    pub fn dst_sizes_array(mut self, value: StridedDeviceAddressRegionKHR) -> Self {
        self.inner.dst_sizes_array = value;
        self
    }
    #[inline]
    pub fn src_infos_array(mut self, value: StridedDeviceAddressRegionKHR) -> Self {
        self.inner.src_infos_array = value;
        self
    }
    #[inline]
    pub fn src_infos_count(mut self, value: u64) -> Self {
        self.inner.src_infos_count = value;
        self
    }
    #[inline]
    pub fn address_resolution_flags(
        mut self,
        value: ClusterAccelerationStructureAddressResolutionFlagsNV,
    ) -> Self {
        self.inner.address_resolution_flags = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`ClusterAccelerationStructureCommandsInfoNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsClusterAccelerationStructureCommandsInfoNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for ClusterAccelerationStructureCommandsInfoNVBuilder<'a> {
    type Target = ClusterAccelerationStructureCommandsInfoNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ClusterAccelerationStructureCommandsInfoNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceMultiDrawPropertiesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceMultiDrawPropertiesEXTBuilder<'a> {
    inner: PhysicalDeviceMultiDrawPropertiesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceMultiDrawPropertiesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceMultiDrawPropertiesEXTBuilder<'a> {
        PhysicalDeviceMultiDrawPropertiesEXTBuilder {
            inner: PhysicalDeviceMultiDrawPropertiesEXT {
                s_type: StructureType::from_raw(1000392001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceMultiDrawPropertiesEXTBuilder<'a> {
    #[inline]
    pub fn max_multi_draw_count(mut self, value: u32) -> Self {
        self.inner.max_multi_draw_count = value;
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceMultiDrawPropertiesEXTBuilder<'a> {
    type Target = PhysicalDeviceMultiDrawPropertiesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceMultiDrawPropertiesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`GraphicsShaderGroupCreateInfoNV`] with lifetime-tied pNext safety.
pub struct GraphicsShaderGroupCreateInfoNVBuilder<'a> {
    inner: GraphicsShaderGroupCreateInfoNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl GraphicsShaderGroupCreateInfoNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> GraphicsShaderGroupCreateInfoNVBuilder<'a> {
        GraphicsShaderGroupCreateInfoNVBuilder {
            inner: GraphicsShaderGroupCreateInfoNV {
                s_type: StructureType::from_raw(1000277001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> GraphicsShaderGroupCreateInfoNVBuilder<'a> {
    #[inline]
    pub fn stages(mut self, slice: &'a [PipelineShaderStageCreateInfo]) -> Self {
        self.inner.stage_count = slice.len() as u32;
        self.inner.p_stages = slice.as_ptr();
        self
    }
    #[inline]
    pub fn vertex_input_state(
        mut self,
        value: &'a PipelineVertexInputStateCreateInfo,
    ) -> Self {
        self.inner.p_vertex_input_state = value;
        self
    }
    #[inline]
    pub fn tessellation_state(
        mut self,
        value: &'a PipelineTessellationStateCreateInfo,
    ) -> Self {
        self.inner.p_tessellation_state = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`GraphicsShaderGroupCreateInfoNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsGraphicsShaderGroupCreateInfoNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for GraphicsShaderGroupCreateInfoNVBuilder<'a> {
    type Target = GraphicsShaderGroupCreateInfoNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for GraphicsShaderGroupCreateInfoNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`GraphicsPipelineShaderGroupsCreateInfoNV`] with lifetime-tied pNext safety.
pub struct GraphicsPipelineShaderGroupsCreateInfoNVBuilder<'a> {
    inner: GraphicsPipelineShaderGroupsCreateInfoNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl GraphicsPipelineShaderGroupsCreateInfoNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> GraphicsPipelineShaderGroupsCreateInfoNVBuilder<'a> {
        GraphicsPipelineShaderGroupsCreateInfoNVBuilder {
            inner: GraphicsPipelineShaderGroupsCreateInfoNV {
                s_type: StructureType::from_raw(1000277002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> GraphicsPipelineShaderGroupsCreateInfoNVBuilder<'a> {
    #[inline]
    pub fn groups(mut self, slice: &'a [GraphicsShaderGroupCreateInfoNV]) -> Self {
        self.inner.group_count = slice.len() as u32;
        self.inner.p_groups = slice.as_ptr();
        self
    }
    #[inline]
    pub fn pipelines(mut self, slice: &'a [Pipeline]) -> Self {
        self.inner.pipeline_count = slice.len() as u32;
        self.inner.p_pipelines = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`GraphicsPipelineShaderGroupsCreateInfoNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsGraphicsPipelineShaderGroupsCreateInfoNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for GraphicsPipelineShaderGroupsCreateInfoNVBuilder<'a> {
    type Target = GraphicsPipelineShaderGroupsCreateInfoNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for GraphicsPipelineShaderGroupsCreateInfoNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`BindShaderGroupIndirectCommandNV`].
pub struct BindShaderGroupIndirectCommandNVBuilder {
    inner: BindShaderGroupIndirectCommandNV,
}
impl BindShaderGroupIndirectCommandNV {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> BindShaderGroupIndirectCommandNVBuilder {
        BindShaderGroupIndirectCommandNVBuilder {
            inner: BindShaderGroupIndirectCommandNV {
                ..Default::default()
            },
        }
    }
}
impl BindShaderGroupIndirectCommandNVBuilder {
    #[inline]
    pub fn group_index(mut self, value: u32) -> Self {
        self.inner.group_index = value;
        self
    }
}
impl core::ops::Deref for BindShaderGroupIndirectCommandNVBuilder {
    type Target = BindShaderGroupIndirectCommandNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for BindShaderGroupIndirectCommandNVBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`BindIndexBufferIndirectCommandNV`].
pub struct BindIndexBufferIndirectCommandNVBuilder {
    inner: BindIndexBufferIndirectCommandNV,
}
impl BindIndexBufferIndirectCommandNV {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> BindIndexBufferIndirectCommandNVBuilder {
        BindIndexBufferIndirectCommandNVBuilder {
            inner: BindIndexBufferIndirectCommandNV {
                ..Default::default()
            },
        }
    }
}
impl BindIndexBufferIndirectCommandNVBuilder {
    #[inline]
    pub fn buffer_address(mut self, value: u64) -> Self {
        self.inner.buffer_address = value;
        self
    }
    #[inline]
    pub fn size(mut self, value: u32) -> Self {
        self.inner.size = value;
        self
    }
    #[inline]
    pub fn index_type(mut self, value: IndexType) -> Self {
        self.inner.index_type = value;
        self
    }
}
impl core::ops::Deref for BindIndexBufferIndirectCommandNVBuilder {
    type Target = BindIndexBufferIndirectCommandNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for BindIndexBufferIndirectCommandNVBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`BindVertexBufferIndirectCommandNV`].
pub struct BindVertexBufferIndirectCommandNVBuilder {
    inner: BindVertexBufferIndirectCommandNV,
}
impl BindVertexBufferIndirectCommandNV {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> BindVertexBufferIndirectCommandNVBuilder {
        BindVertexBufferIndirectCommandNVBuilder {
            inner: BindVertexBufferIndirectCommandNV {
                ..Default::default()
            },
        }
    }
}
impl BindVertexBufferIndirectCommandNVBuilder {
    #[inline]
    pub fn buffer_address(mut self, value: u64) -> Self {
        self.inner.buffer_address = value;
        self
    }
    #[inline]
    pub fn size(mut self, value: u32) -> Self {
        self.inner.size = value;
        self
    }
    #[inline]
    pub fn stride(mut self, value: u32) -> Self {
        self.inner.stride = value;
        self
    }
}
impl core::ops::Deref for BindVertexBufferIndirectCommandNVBuilder {
    type Target = BindVertexBufferIndirectCommandNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for BindVertexBufferIndirectCommandNVBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`SetStateFlagsIndirectCommandNV`].
pub struct SetStateFlagsIndirectCommandNVBuilder {
    inner: SetStateFlagsIndirectCommandNV,
}
impl SetStateFlagsIndirectCommandNV {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> SetStateFlagsIndirectCommandNVBuilder {
        SetStateFlagsIndirectCommandNVBuilder {
            inner: SetStateFlagsIndirectCommandNV {
                ..Default::default()
            },
        }
    }
}
impl SetStateFlagsIndirectCommandNVBuilder {
    #[inline]
    pub fn data(mut self, value: u32) -> Self {
        self.inner.data = value;
        self
    }
}
impl core::ops::Deref for SetStateFlagsIndirectCommandNVBuilder {
    type Target = SetStateFlagsIndirectCommandNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for SetStateFlagsIndirectCommandNVBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`IndirectCommandsStreamNV`].
pub struct IndirectCommandsStreamNVBuilder {
    inner: IndirectCommandsStreamNV,
}
impl IndirectCommandsStreamNV {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> IndirectCommandsStreamNVBuilder {
        IndirectCommandsStreamNVBuilder {
            inner: IndirectCommandsStreamNV {
                ..Default::default()
            },
        }
    }
}
impl IndirectCommandsStreamNVBuilder {
    #[inline]
    pub fn buffer(mut self, value: Buffer) -> Self {
        self.inner.buffer = value;
        self
    }
    #[inline]
    pub fn offset(mut self, value: u64) -> Self {
        self.inner.offset = value;
        self
    }
}
impl core::ops::Deref for IndirectCommandsStreamNVBuilder {
    type Target = IndirectCommandsStreamNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for IndirectCommandsStreamNVBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`IndirectCommandsLayoutTokenNV`] with lifetime-tied pNext safety.
pub struct IndirectCommandsLayoutTokenNVBuilder<'a> {
    inner: IndirectCommandsLayoutTokenNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl IndirectCommandsLayoutTokenNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> IndirectCommandsLayoutTokenNVBuilder<'a> {
        IndirectCommandsLayoutTokenNVBuilder {
            inner: IndirectCommandsLayoutTokenNV {
                s_type: StructureType::from_raw(1000277003i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> IndirectCommandsLayoutTokenNVBuilder<'a> {
    #[inline]
    pub fn token_type(mut self, value: IndirectCommandsTokenTypeNV) -> Self {
        self.inner.token_type = value;
        self
    }
    #[inline]
    pub fn stream(mut self, value: u32) -> Self {
        self.inner.stream = value;
        self
    }
    #[inline]
    pub fn offset(mut self, value: u32) -> Self {
        self.inner.offset = value;
        self
    }
    #[inline]
    pub fn vertex_binding_unit(mut self, value: u32) -> Self {
        self.inner.vertex_binding_unit = value;
        self
    }
    #[inline]
    pub fn vertex_dynamic_stride(mut self, value: bool) -> Self {
        self.inner.vertex_dynamic_stride = value as u32;
        self
    }
    #[inline]
    pub fn pushconstant_pipeline_layout(mut self, value: PipelineLayout) -> Self {
        self.inner.pushconstant_pipeline_layout = value;
        self
    }
    #[inline]
    pub fn pushconstant_shader_stage_flags(mut self, value: ShaderStageFlags) -> Self {
        self.inner.pushconstant_shader_stage_flags = value;
        self
    }
    #[inline]
    pub fn pushconstant_offset(mut self, value: u32) -> Self {
        self.inner.pushconstant_offset = value;
        self
    }
    #[inline]
    pub fn pushconstant_size(mut self, value: u32) -> Self {
        self.inner.pushconstant_size = value;
        self
    }
    #[inline]
    pub fn indirect_state_flags(mut self, value: IndirectStateFlagsNV) -> Self {
        self.inner.indirect_state_flags = value;
        self
    }
    #[inline]
    pub fn index_types(mut self, slice: &'a [IndexType]) -> Self {
        self.inner.index_type_count = slice.len() as u32;
        self.inner.p_index_types = slice.as_ptr();
        self
    }
    #[inline]
    pub fn index_type_values(mut self, slice: &'a [u32]) -> Self {
        self.inner.index_type_count = slice.len() as u32;
        self.inner.p_index_type_values = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`IndirectCommandsLayoutTokenNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsIndirectCommandsLayoutTokenNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for IndirectCommandsLayoutTokenNVBuilder<'a> {
    type Target = IndirectCommandsLayoutTokenNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for IndirectCommandsLayoutTokenNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`IndirectCommandsLayoutCreateInfoNV`] with lifetime-tied pNext safety.
pub struct IndirectCommandsLayoutCreateInfoNVBuilder<'a> {
    inner: IndirectCommandsLayoutCreateInfoNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl IndirectCommandsLayoutCreateInfoNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> IndirectCommandsLayoutCreateInfoNVBuilder<'a> {
        IndirectCommandsLayoutCreateInfoNVBuilder {
            inner: IndirectCommandsLayoutCreateInfoNV {
                s_type: StructureType::from_raw(1000277004i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> IndirectCommandsLayoutCreateInfoNVBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: IndirectCommandsLayoutUsageFlagsNV) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn pipeline_bind_point(mut self, value: PipelineBindPoint) -> Self {
        self.inner.pipeline_bind_point = value;
        self
    }
    #[inline]
    pub fn tokens(mut self, slice: &'a [IndirectCommandsLayoutTokenNV]) -> Self {
        self.inner.token_count = slice.len() as u32;
        self.inner.p_tokens = slice.as_ptr();
        self
    }
    #[inline]
    pub fn stream_strides(mut self, slice: &'a [u32]) -> Self {
        self.inner.stream_count = slice.len() as u32;
        self.inner.p_stream_strides = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`IndirectCommandsLayoutCreateInfoNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsIndirectCommandsLayoutCreateInfoNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for IndirectCommandsLayoutCreateInfoNVBuilder<'a> {
    type Target = IndirectCommandsLayoutCreateInfoNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for IndirectCommandsLayoutCreateInfoNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`GeneratedCommandsInfoNV`] with lifetime-tied pNext safety.
pub struct GeneratedCommandsInfoNVBuilder<'a> {
    inner: GeneratedCommandsInfoNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl GeneratedCommandsInfoNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> GeneratedCommandsInfoNVBuilder<'a> {
        GeneratedCommandsInfoNVBuilder {
            inner: GeneratedCommandsInfoNV {
                s_type: StructureType::from_raw(1000277005i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> GeneratedCommandsInfoNVBuilder<'a> {
    #[inline]
    pub fn pipeline_bind_point(mut self, value: PipelineBindPoint) -> Self {
        self.inner.pipeline_bind_point = value;
        self
    }
    #[inline]
    pub fn pipeline(mut self, value: Pipeline) -> Self {
        self.inner.pipeline = value;
        self
    }
    #[inline]
    pub fn indirect_commands_layout(mut self, value: IndirectCommandsLayoutNV) -> Self {
        self.inner.indirect_commands_layout = value;
        self
    }
    #[inline]
    pub fn streams(mut self, slice: &'a [IndirectCommandsStreamNV]) -> Self {
        self.inner.stream_count = slice.len() as u32;
        self.inner.p_streams = slice.as_ptr();
        self
    }
    #[inline]
    pub fn sequences_count(mut self, value: u32) -> Self {
        self.inner.sequences_count = value;
        self
    }
    #[inline]
    pub fn preprocess_buffer(mut self, value: Buffer) -> Self {
        self.inner.preprocess_buffer = value;
        self
    }
    #[inline]
    pub fn preprocess_offset(mut self, value: u64) -> Self {
        self.inner.preprocess_offset = value;
        self
    }
    #[inline]
    pub fn preprocess_size(mut self, value: u64) -> Self {
        self.inner.preprocess_size = value;
        self
    }
    #[inline]
    pub fn sequences_count_buffer(mut self, value: Buffer) -> Self {
        self.inner.sequences_count_buffer = value;
        self
    }
    #[inline]
    pub fn sequences_count_offset(mut self, value: u64) -> Self {
        self.inner.sequences_count_offset = value;
        self
    }
    #[inline]
    pub fn sequences_index_buffer(mut self, value: Buffer) -> Self {
        self.inner.sequences_index_buffer = value;
        self
    }
    #[inline]
    pub fn sequences_index_offset(mut self, value: u64) -> Self {
        self.inner.sequences_index_offset = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`GeneratedCommandsInfoNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsGeneratedCommandsInfoNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for GeneratedCommandsInfoNVBuilder<'a> {
    type Target = GeneratedCommandsInfoNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for GeneratedCommandsInfoNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`GeneratedCommandsMemoryRequirementsInfoNV`] with lifetime-tied pNext safety.
pub struct GeneratedCommandsMemoryRequirementsInfoNVBuilder<'a> {
    inner: GeneratedCommandsMemoryRequirementsInfoNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl GeneratedCommandsMemoryRequirementsInfoNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> GeneratedCommandsMemoryRequirementsInfoNVBuilder<'a> {
        GeneratedCommandsMemoryRequirementsInfoNVBuilder {
            inner: GeneratedCommandsMemoryRequirementsInfoNV {
                s_type: StructureType::from_raw(1000277006i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> GeneratedCommandsMemoryRequirementsInfoNVBuilder<'a> {
    #[inline]
    pub fn pipeline_bind_point(mut self, value: PipelineBindPoint) -> Self {
        self.inner.pipeline_bind_point = value;
        self
    }
    #[inline]
    pub fn pipeline(mut self, value: Pipeline) -> Self {
        self.inner.pipeline = value;
        self
    }
    #[inline]
    pub fn indirect_commands_layout(mut self, value: IndirectCommandsLayoutNV) -> Self {
        self.inner.indirect_commands_layout = value;
        self
    }
    #[inline]
    pub fn max_sequences_count(mut self, value: u32) -> Self {
        self.inner.max_sequences_count = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`GeneratedCommandsMemoryRequirementsInfoNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsGeneratedCommandsMemoryRequirementsInfoNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for GeneratedCommandsMemoryRequirementsInfoNVBuilder<'a> {
    type Target = GeneratedCommandsMemoryRequirementsInfoNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for GeneratedCommandsMemoryRequirementsInfoNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PipelineIndirectDeviceAddressInfoNV`] with lifetime-tied pNext safety.
pub struct PipelineIndirectDeviceAddressInfoNVBuilder<'a> {
    inner: PipelineIndirectDeviceAddressInfoNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PipelineIndirectDeviceAddressInfoNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PipelineIndirectDeviceAddressInfoNVBuilder<'a> {
        PipelineIndirectDeviceAddressInfoNVBuilder {
            inner: PipelineIndirectDeviceAddressInfoNV {
                s_type: StructureType::from_raw(1000428002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PipelineIndirectDeviceAddressInfoNVBuilder<'a> {
    #[inline]
    pub fn pipeline_bind_point(mut self, value: PipelineBindPoint) -> Self {
        self.inner.pipeline_bind_point = value;
        self
    }
    #[inline]
    pub fn pipeline(mut self, value: Pipeline) -> Self {
        self.inner.pipeline = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PipelineIndirectDeviceAddressInfoNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPipelineIndirectDeviceAddressInfoNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for PipelineIndirectDeviceAddressInfoNVBuilder<'a> {
    type Target = PipelineIndirectDeviceAddressInfoNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PipelineIndirectDeviceAddressInfoNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`BindPipelineIndirectCommandNV`].
pub struct BindPipelineIndirectCommandNVBuilder {
    inner: BindPipelineIndirectCommandNV,
}
impl BindPipelineIndirectCommandNV {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> BindPipelineIndirectCommandNVBuilder {
        BindPipelineIndirectCommandNVBuilder {
            inner: BindPipelineIndirectCommandNV {
                ..Default::default()
            },
        }
    }
}
impl BindPipelineIndirectCommandNVBuilder {
    #[inline]
    pub fn pipeline_address(mut self, value: u64) -> Self {
        self.inner.pipeline_address = value;
        self
    }
}
impl core::ops::Deref for BindPipelineIndirectCommandNVBuilder {
    type Target = BindPipelineIndirectCommandNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for BindPipelineIndirectCommandNVBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceFeatures2`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceFeatures2Builder<'a> {
    inner: PhysicalDeviceFeatures2,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceFeatures2 {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceFeatures2Builder<'a> {
        PhysicalDeviceFeatures2Builder {
            inner: PhysicalDeviceFeatures2 {
                s_type: StructureType::from_raw(1000059000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceFeatures2Builder<'a> {
    #[inline]
    pub fn features(mut self, value: PhysicalDeviceFeatures) -> Self {
        self.inner.features = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceFeatures2`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceFeatures2>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceFeatures2Builder<'a> {
    type Target = PhysicalDeviceFeatures2;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceFeatures2Builder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceProperties2`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceProperties2Builder<'a> {
    inner: PhysicalDeviceProperties2,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceProperties2 {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceProperties2Builder<'a> {
        PhysicalDeviceProperties2Builder {
            inner: PhysicalDeviceProperties2 {
                s_type: StructureType::from_raw(1000059001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceProperties2Builder<'a> {
    #[inline]
    pub fn properties(mut self, value: PhysicalDeviceProperties) -> Self {
        self.inner.properties = value;
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceProperties2Builder<'a> {
    type Target = PhysicalDeviceProperties2;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceProperties2Builder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`FormatProperties2`] with lifetime-tied pNext safety.
pub struct FormatProperties2Builder<'a> {
    inner: FormatProperties2,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl FormatProperties2 {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> FormatProperties2Builder<'a> {
        FormatProperties2Builder {
            inner: FormatProperties2 {
                s_type: StructureType::from_raw(1000059002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> FormatProperties2Builder<'a> {
    #[inline]
    pub fn format_properties(mut self, value: FormatProperties) -> Self {
        self.inner.format_properties = value;
        self
    }
}
impl<'a> core::ops::Deref for FormatProperties2Builder<'a> {
    type Target = FormatProperties2;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for FormatProperties2Builder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ImageFormatProperties2`] with lifetime-tied pNext safety.
pub struct ImageFormatProperties2Builder<'a> {
    inner: ImageFormatProperties2,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ImageFormatProperties2 {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ImageFormatProperties2Builder<'a> {
        ImageFormatProperties2Builder {
            inner: ImageFormatProperties2 {
                s_type: StructureType::from_raw(1000059003i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ImageFormatProperties2Builder<'a> {
    #[inline]
    pub fn image_format_properties(mut self, value: ImageFormatProperties) -> Self {
        self.inner.image_format_properties = value;
        self
    }
}
impl<'a> core::ops::Deref for ImageFormatProperties2Builder<'a> {
    type Target = ImageFormatProperties2;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ImageFormatProperties2Builder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceImageFormatInfo2`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceImageFormatInfo2Builder<'a> {
    inner: PhysicalDeviceImageFormatInfo2,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceImageFormatInfo2 {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceImageFormatInfo2Builder<'a> {
        PhysicalDeviceImageFormatInfo2Builder {
            inner: PhysicalDeviceImageFormatInfo2 {
                s_type: StructureType::from_raw(1000059004i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceImageFormatInfo2Builder<'a> {
    #[inline]
    pub fn format(mut self, value: Format) -> Self {
        self.inner.format = value;
        self
    }
    #[inline]
    pub fn r#type(mut self, value: ImageType) -> Self {
        self.inner.r#type = value;
        self
    }
    #[inline]
    pub fn tiling(mut self, value: ImageTiling) -> Self {
        self.inner.tiling = value;
        self
    }
    #[inline]
    pub fn usage(mut self, value: ImageUsageFlags) -> Self {
        self.inner.usage = value;
        self
    }
    #[inline]
    pub fn flags(mut self, value: ImageCreateFlags) -> Self {
        self.inner.flags = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceImageFormatInfo2`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceImageFormatInfo2>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceImageFormatInfo2Builder<'a> {
    type Target = PhysicalDeviceImageFormatInfo2;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceImageFormatInfo2Builder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`QueueFamilyProperties2`] with lifetime-tied pNext safety.
pub struct QueueFamilyProperties2Builder<'a> {
    inner: QueueFamilyProperties2,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl QueueFamilyProperties2 {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> QueueFamilyProperties2Builder<'a> {
        QueueFamilyProperties2Builder {
            inner: QueueFamilyProperties2 {
                s_type: StructureType::from_raw(1000059005i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> QueueFamilyProperties2Builder<'a> {
    #[inline]
    pub fn queue_family_properties(mut self, value: QueueFamilyProperties) -> Self {
        self.inner.queue_family_properties = value;
        self
    }
}
impl<'a> core::ops::Deref for QueueFamilyProperties2Builder<'a> {
    type Target = QueueFamilyProperties2;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for QueueFamilyProperties2Builder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceMemoryProperties2`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceMemoryProperties2Builder<'a> {
    inner: PhysicalDeviceMemoryProperties2,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceMemoryProperties2 {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceMemoryProperties2Builder<'a> {
        PhysicalDeviceMemoryProperties2Builder {
            inner: PhysicalDeviceMemoryProperties2 {
                s_type: StructureType::from_raw(1000059006i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceMemoryProperties2Builder<'a> {
    #[inline]
    pub fn memory_properties(mut self, value: PhysicalDeviceMemoryProperties) -> Self {
        self.inner.memory_properties = value;
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceMemoryProperties2Builder<'a> {
    type Target = PhysicalDeviceMemoryProperties2;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceMemoryProperties2Builder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`SparseImageFormatProperties2`] with lifetime-tied pNext safety.
pub struct SparseImageFormatProperties2Builder<'a> {
    inner: SparseImageFormatProperties2,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl SparseImageFormatProperties2 {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> SparseImageFormatProperties2Builder<'a> {
        SparseImageFormatProperties2Builder {
            inner: SparseImageFormatProperties2 {
                s_type: StructureType::from_raw(1000059007i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> SparseImageFormatProperties2Builder<'a> {
    #[inline]
    pub fn properties(mut self, value: SparseImageFormatProperties) -> Self {
        self.inner.properties = value;
        self
    }
}
impl<'a> core::ops::Deref for SparseImageFormatProperties2Builder<'a> {
    type Target = SparseImageFormatProperties2;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for SparseImageFormatProperties2Builder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceSparseImageFormatInfo2`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceSparseImageFormatInfo2Builder<'a> {
    inner: PhysicalDeviceSparseImageFormatInfo2,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceSparseImageFormatInfo2 {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceSparseImageFormatInfo2Builder<'a> {
        PhysicalDeviceSparseImageFormatInfo2Builder {
            inner: PhysicalDeviceSparseImageFormatInfo2 {
                s_type: StructureType::from_raw(1000059008i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceSparseImageFormatInfo2Builder<'a> {
    #[inline]
    pub fn format(mut self, value: Format) -> Self {
        self.inner.format = value;
        self
    }
    #[inline]
    pub fn r#type(mut self, value: ImageType) -> Self {
        self.inner.r#type = value;
        self
    }
    #[inline]
    pub fn samples(mut self, value: SampleCountFlagBits) -> Self {
        self.inner.samples = value;
        self
    }
    #[inline]
    pub fn usage(mut self, value: ImageUsageFlags) -> Self {
        self.inner.usage = value;
        self
    }
    #[inline]
    pub fn tiling(mut self, value: ImageTiling) -> Self {
        self.inner.tiling = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceSparseImageFormatInfo2`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceSparseImageFormatInfo2>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceSparseImageFormatInfo2Builder<'a> {
    type Target = PhysicalDeviceSparseImageFormatInfo2;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceSparseImageFormatInfo2Builder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDevicePushDescriptorProperties`] with lifetime-tied pNext safety.
pub struct PhysicalDevicePushDescriptorPropertiesBuilder<'a> {
    inner: PhysicalDevicePushDescriptorProperties,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDevicePushDescriptorProperties {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDevicePushDescriptorPropertiesBuilder<'a> {
        PhysicalDevicePushDescriptorPropertiesBuilder {
            inner: PhysicalDevicePushDescriptorProperties {
                s_type: StructureType::from_raw(1000080000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDevicePushDescriptorPropertiesBuilder<'a> {
    #[inline]
    pub fn max_push_descriptors(mut self, value: u32) -> Self {
        self.inner.max_push_descriptors = value;
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDevicePushDescriptorPropertiesBuilder<'a> {
    type Target = PhysicalDevicePushDescriptorProperties;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDevicePushDescriptorPropertiesBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ConformanceVersion`].
pub struct ConformanceVersionBuilder {
    inner: ConformanceVersion,
}
impl ConformanceVersion {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> ConformanceVersionBuilder {
        ConformanceVersionBuilder {
            inner: ConformanceVersion {
                ..Default::default()
            },
        }
    }
}
impl ConformanceVersionBuilder {
    #[inline]
    pub fn major(mut self, value: u8) -> Self {
        self.inner.major = value;
        self
    }
    #[inline]
    pub fn minor(mut self, value: u8) -> Self {
        self.inner.minor = value;
        self
    }
    #[inline]
    pub fn subminor(mut self, value: u8) -> Self {
        self.inner.subminor = value;
        self
    }
    #[inline]
    pub fn patch(mut self, value: u8) -> Self {
        self.inner.patch = value;
        self
    }
}
impl core::ops::Deref for ConformanceVersionBuilder {
    type Target = ConformanceVersion;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for ConformanceVersionBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceDriverProperties`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceDriverPropertiesBuilder<'a> {
    inner: PhysicalDeviceDriverProperties,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceDriverProperties {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceDriverPropertiesBuilder<'a> {
        PhysicalDeviceDriverPropertiesBuilder {
            inner: PhysicalDeviceDriverProperties {
                s_type: StructureType::from_raw(1000196000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceDriverPropertiesBuilder<'a> {
    #[inline]
    pub fn driver_id(mut self, value: DriverId) -> Self {
        self.inner.driver_id = value;
        self
    }
    #[inline]
    pub fn driver_name(
        mut self,
        value: crate::StringArray<{ MAX_DRIVER_NAME_SIZE as usize }>,
    ) -> Self {
        self.inner.driver_name = value;
        self
    }
    #[inline]
    pub fn driver_info(
        mut self,
        value: crate::StringArray<{ MAX_DRIVER_INFO_SIZE as usize }>,
    ) -> Self {
        self.inner.driver_info = value;
        self
    }
    #[inline]
    pub fn conformance_version(mut self, value: ConformanceVersion) -> Self {
        self.inner.conformance_version = value;
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceDriverPropertiesBuilder<'a> {
    type Target = PhysicalDeviceDriverProperties;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceDriverPropertiesBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PresentRegionsKHR`] with lifetime-tied pNext safety.
pub struct PresentRegionsKHRBuilder<'a> {
    inner: PresentRegionsKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PresentRegionsKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PresentRegionsKHRBuilder<'a> {
        PresentRegionsKHRBuilder {
            inner: PresentRegionsKHR {
                s_type: StructureType::from_raw(1000084000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PresentRegionsKHRBuilder<'a> {
    #[inline]
    pub fn swapchain_count(mut self, value: u32) -> Self {
        self.inner.swapchain_count = value;
        self
    }
    #[inline]
    pub fn regions(mut self, slice: &'a [PresentRegionKHR]) -> Self {
        self.inner.swapchain_count = slice.len() as u32;
        self.inner.p_regions = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`PresentRegionsKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPresentRegionsKHR>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for PresentRegionsKHRBuilder<'a> {
    type Target = PresentRegionsKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PresentRegionsKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PresentRegionKHR`].
pub struct PresentRegionKHRBuilder<'a> {
    inner: PresentRegionKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PresentRegionKHR {
    /// Start building this struct.
    #[inline]
    pub fn builder<'a>() -> PresentRegionKHRBuilder<'a> {
        PresentRegionKHRBuilder {
            inner: PresentRegionKHR {
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PresentRegionKHRBuilder<'a> {
    #[inline]
    pub fn rectangle_count(mut self, value: u32) -> Self {
        self.inner.rectangle_count = value;
        self
    }
    #[inline]
    pub fn rectangles(mut self, slice: &'a [RectLayerKHR]) -> Self {
        self.inner.rectangle_count = slice.len() as u32;
        self.inner.p_rectangles = slice.as_ptr();
        self
    }
}
impl<'a> core::ops::Deref for PresentRegionKHRBuilder<'a> {
    type Target = PresentRegionKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PresentRegionKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`RectLayerKHR`].
pub struct RectLayerKHRBuilder {
    inner: RectLayerKHR,
}
impl RectLayerKHR {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> RectLayerKHRBuilder {
        RectLayerKHRBuilder {
            inner: RectLayerKHR {
                ..Default::default()
            },
        }
    }
}
impl RectLayerKHRBuilder {
    #[inline]
    pub fn offset(mut self, value: Offset2D) -> Self {
        self.inner.offset = value;
        self
    }
    #[inline]
    pub fn extent(mut self, value: Extent2D) -> Self {
        self.inner.extent = value;
        self
    }
    #[inline]
    pub fn layer(mut self, value: u32) -> Self {
        self.inner.layer = value;
        self
    }
}
impl core::ops::Deref for RectLayerKHRBuilder {
    type Target = RectLayerKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for RectLayerKHRBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceVariablePointersFeatures`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceVariablePointersFeaturesBuilder<'a> {
    inner: PhysicalDeviceVariablePointersFeatures,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceVariablePointersFeatures {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceVariablePointersFeaturesBuilder<'a> {
        PhysicalDeviceVariablePointersFeaturesBuilder {
            inner: PhysicalDeviceVariablePointersFeatures {
                s_type: StructureType::from_raw(1000120000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceVariablePointersFeaturesBuilder<'a> {
    #[inline]
    pub fn variable_pointers_storage_buffer(mut self, value: bool) -> Self {
        self.inner.variable_pointers_storage_buffer = value as u32;
        self
    }
    #[inline]
    pub fn variable_pointers(mut self, value: bool) -> Self {
        self.inner.variable_pointers = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceVariablePointersFeatures`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceVariablePointersFeatures>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceVariablePointersFeaturesBuilder<'a> {
    type Target = PhysicalDeviceVariablePointersFeatures;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceVariablePointersFeaturesBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ExternalMemoryProperties`].
pub struct ExternalMemoryPropertiesBuilder {
    inner: ExternalMemoryProperties,
}
impl ExternalMemoryProperties {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> ExternalMemoryPropertiesBuilder {
        ExternalMemoryPropertiesBuilder {
            inner: ExternalMemoryProperties {
                ..Default::default()
            },
        }
    }
}
impl ExternalMemoryPropertiesBuilder {
    #[inline]
    pub fn external_memory_features(
        mut self,
        value: ExternalMemoryFeatureFlags,
    ) -> Self {
        self.inner.external_memory_features = value;
        self
    }
    #[inline]
    pub fn export_from_imported_handle_types(
        mut self,
        value: ExternalMemoryHandleTypeFlags,
    ) -> Self {
        self.inner.export_from_imported_handle_types = value;
        self
    }
    #[inline]
    pub fn compatible_handle_types(
        mut self,
        value: ExternalMemoryHandleTypeFlags,
    ) -> Self {
        self.inner.compatible_handle_types = value;
        self
    }
}
impl core::ops::Deref for ExternalMemoryPropertiesBuilder {
    type Target = ExternalMemoryProperties;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for ExternalMemoryPropertiesBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceExternalImageFormatInfo`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceExternalImageFormatInfoBuilder<'a> {
    inner: PhysicalDeviceExternalImageFormatInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceExternalImageFormatInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceExternalImageFormatInfoBuilder<'a> {
        PhysicalDeviceExternalImageFormatInfoBuilder {
            inner: PhysicalDeviceExternalImageFormatInfo {
                s_type: StructureType::from_raw(1000071000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceExternalImageFormatInfoBuilder<'a> {
    #[inline]
    pub fn handle_type(mut self, value: ExternalMemoryHandleTypeFlagBits) -> Self {
        self.inner.handle_type = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceExternalImageFormatInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceExternalImageFormatInfo>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceExternalImageFormatInfoBuilder<'a> {
    type Target = PhysicalDeviceExternalImageFormatInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceExternalImageFormatInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ExternalImageFormatProperties`] with lifetime-tied pNext safety.
pub struct ExternalImageFormatPropertiesBuilder<'a> {
    inner: ExternalImageFormatProperties,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ExternalImageFormatProperties {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ExternalImageFormatPropertiesBuilder<'a> {
        ExternalImageFormatPropertiesBuilder {
            inner: ExternalImageFormatProperties {
                s_type: StructureType::from_raw(1000071001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ExternalImageFormatPropertiesBuilder<'a> {
    #[inline]
    pub fn external_memory_properties(
        mut self,
        value: ExternalMemoryProperties,
    ) -> Self {
        self.inner.external_memory_properties = value;
        self
    }
}
impl<'a> core::ops::Deref for ExternalImageFormatPropertiesBuilder<'a> {
    type Target = ExternalImageFormatProperties;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ExternalImageFormatPropertiesBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceExternalBufferInfo`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceExternalBufferInfoBuilder<'a> {
    inner: PhysicalDeviceExternalBufferInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceExternalBufferInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceExternalBufferInfoBuilder<'a> {
        PhysicalDeviceExternalBufferInfoBuilder {
            inner: PhysicalDeviceExternalBufferInfo {
                s_type: StructureType::from_raw(1000071002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceExternalBufferInfoBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: BufferCreateFlags) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn usage(mut self, value: BufferUsageFlags) -> Self {
        self.inner.usage = value;
        self
    }
    #[inline]
    pub fn handle_type(mut self, value: ExternalMemoryHandleTypeFlagBits) -> Self {
        self.inner.handle_type = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceExternalBufferInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceExternalBufferInfo>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceExternalBufferInfoBuilder<'a> {
    type Target = PhysicalDeviceExternalBufferInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceExternalBufferInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ExternalBufferProperties`] with lifetime-tied pNext safety.
pub struct ExternalBufferPropertiesBuilder<'a> {
    inner: ExternalBufferProperties,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ExternalBufferProperties {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ExternalBufferPropertiesBuilder<'a> {
        ExternalBufferPropertiesBuilder {
            inner: ExternalBufferProperties {
                s_type: StructureType::from_raw(1000071003i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ExternalBufferPropertiesBuilder<'a> {
    #[inline]
    pub fn external_memory_properties(
        mut self,
        value: ExternalMemoryProperties,
    ) -> Self {
        self.inner.external_memory_properties = value;
        self
    }
}
impl<'a> core::ops::Deref for ExternalBufferPropertiesBuilder<'a> {
    type Target = ExternalBufferProperties;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ExternalBufferPropertiesBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceIDProperties`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceIDPropertiesBuilder<'a> {
    inner: PhysicalDeviceIDProperties,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceIDProperties {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceIDPropertiesBuilder<'a> {
        PhysicalDeviceIDPropertiesBuilder {
            inner: PhysicalDeviceIDProperties {
                s_type: StructureType::from_raw(1000071004i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceIDPropertiesBuilder<'a> {
    #[inline]
    pub fn device_uuid(mut self, value: [u8; UUID_SIZE as usize]) -> Self {
        self.inner.device_uuid = value;
        self
    }
    #[inline]
    pub fn driver_uuid(mut self, value: [u8; UUID_SIZE as usize]) -> Self {
        self.inner.driver_uuid = value;
        self
    }
    #[inline]
    pub fn device_luid(mut self, value: [u8; LUID_SIZE as usize]) -> Self {
        self.inner.device_luid = value;
        self
    }
    #[inline]
    pub fn device_node_mask(mut self, value: u32) -> Self {
        self.inner.device_node_mask = value;
        self
    }
    #[inline]
    pub fn device_luid_valid(mut self, value: bool) -> Self {
        self.inner.device_luid_valid = value as u32;
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceIDPropertiesBuilder<'a> {
    type Target = PhysicalDeviceIDProperties;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceIDPropertiesBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ExternalMemoryImageCreateInfo`] with lifetime-tied pNext safety.
pub struct ExternalMemoryImageCreateInfoBuilder<'a> {
    inner: ExternalMemoryImageCreateInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ExternalMemoryImageCreateInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ExternalMemoryImageCreateInfoBuilder<'a> {
        ExternalMemoryImageCreateInfoBuilder {
            inner: ExternalMemoryImageCreateInfo {
                s_type: StructureType::from_raw(1000072001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ExternalMemoryImageCreateInfoBuilder<'a> {
    #[inline]
    pub fn handle_types(mut self, value: ExternalMemoryHandleTypeFlags) -> Self {
        self.inner.handle_types = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`ExternalMemoryImageCreateInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsExternalMemoryImageCreateInfo>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for ExternalMemoryImageCreateInfoBuilder<'a> {
    type Target = ExternalMemoryImageCreateInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ExternalMemoryImageCreateInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ExternalMemoryBufferCreateInfo`] with lifetime-tied pNext safety.
pub struct ExternalMemoryBufferCreateInfoBuilder<'a> {
    inner: ExternalMemoryBufferCreateInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ExternalMemoryBufferCreateInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ExternalMemoryBufferCreateInfoBuilder<'a> {
        ExternalMemoryBufferCreateInfoBuilder {
            inner: ExternalMemoryBufferCreateInfo {
                s_type: StructureType::from_raw(1000072000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ExternalMemoryBufferCreateInfoBuilder<'a> {
    #[inline]
    pub fn handle_types(mut self, value: ExternalMemoryHandleTypeFlags) -> Self {
        self.inner.handle_types = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`ExternalMemoryBufferCreateInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsExternalMemoryBufferCreateInfo>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for ExternalMemoryBufferCreateInfoBuilder<'a> {
    type Target = ExternalMemoryBufferCreateInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ExternalMemoryBufferCreateInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ExportMemoryAllocateInfo`] with lifetime-tied pNext safety.
pub struct ExportMemoryAllocateInfoBuilder<'a> {
    inner: ExportMemoryAllocateInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ExportMemoryAllocateInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ExportMemoryAllocateInfoBuilder<'a> {
        ExportMemoryAllocateInfoBuilder {
            inner: ExportMemoryAllocateInfo {
                s_type: StructureType::from_raw(1000072002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ExportMemoryAllocateInfoBuilder<'a> {
    #[inline]
    pub fn handle_types(mut self, value: ExternalMemoryHandleTypeFlags) -> Self {
        self.inner.handle_types = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`ExportMemoryAllocateInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsExportMemoryAllocateInfo>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for ExportMemoryAllocateInfoBuilder<'a> {
    type Target = ExportMemoryAllocateInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ExportMemoryAllocateInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ImportMemoryWin32HandleInfoKHR`] with lifetime-tied pNext safety.
pub struct ImportMemoryWin32HandleInfoKHRBuilder<'a> {
    inner: ImportMemoryWin32HandleInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ImportMemoryWin32HandleInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ImportMemoryWin32HandleInfoKHRBuilder<'a> {
        ImportMemoryWin32HandleInfoKHRBuilder {
            inner: ImportMemoryWin32HandleInfoKHR {
                s_type: StructureType::from_raw(1000073000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ImportMemoryWin32HandleInfoKHRBuilder<'a> {
    #[inline]
    pub fn handle_type(mut self, value: ExternalMemoryHandleTypeFlagBits) -> Self {
        self.inner.handle_type = value;
        self
    }
    #[inline]
    pub fn handle(mut self, value: isize) -> Self {
        self.inner.handle = value;
        self
    }
    #[inline]
    pub fn name(mut self, value: *const u16) -> Self {
        self.inner.name = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`ImportMemoryWin32HandleInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsImportMemoryWin32HandleInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for ImportMemoryWin32HandleInfoKHRBuilder<'a> {
    type Target = ImportMemoryWin32HandleInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ImportMemoryWin32HandleInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ExportMemoryWin32HandleInfoKHR`] with lifetime-tied pNext safety.
pub struct ExportMemoryWin32HandleInfoKHRBuilder<'a> {
    inner: ExportMemoryWin32HandleInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ExportMemoryWin32HandleInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ExportMemoryWin32HandleInfoKHRBuilder<'a> {
        ExportMemoryWin32HandleInfoKHRBuilder {
            inner: ExportMemoryWin32HandleInfoKHR {
                s_type: StructureType::from_raw(1000073001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ExportMemoryWin32HandleInfoKHRBuilder<'a> {
    #[inline]
    pub fn attributes(mut self, value: *const core::ffi::c_void) -> Self {
        self.inner.p_attributes = value;
        self
    }
    #[inline]
    pub fn dw_access(mut self, value: u32) -> Self {
        self.inner.dw_access = value;
        self
    }
    #[inline]
    pub fn name(mut self, value: *const u16) -> Self {
        self.inner.name = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`ExportMemoryWin32HandleInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsExportMemoryWin32HandleInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for ExportMemoryWin32HandleInfoKHRBuilder<'a> {
    type Target = ExportMemoryWin32HandleInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ExportMemoryWin32HandleInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ImportMemoryZirconHandleInfoFUCHSIA`] with lifetime-tied pNext safety.
pub struct ImportMemoryZirconHandleInfoFUCHSIABuilder<'a> {
    inner: ImportMemoryZirconHandleInfoFUCHSIA,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ImportMemoryZirconHandleInfoFUCHSIA {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ImportMemoryZirconHandleInfoFUCHSIABuilder<'a> {
        ImportMemoryZirconHandleInfoFUCHSIABuilder {
            inner: ImportMemoryZirconHandleInfoFUCHSIA {
                s_type: StructureType::from_raw(1000364000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ImportMemoryZirconHandleInfoFUCHSIABuilder<'a> {
    #[inline]
    pub fn handle_type(mut self, value: ExternalMemoryHandleTypeFlagBits) -> Self {
        self.inner.handle_type = value;
        self
    }
    #[inline]
    pub fn handle(mut self, value: u32) -> Self {
        self.inner.handle = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`ImportMemoryZirconHandleInfoFUCHSIA`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsImportMemoryZirconHandleInfoFUCHSIA>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for ImportMemoryZirconHandleInfoFUCHSIABuilder<'a> {
    type Target = ImportMemoryZirconHandleInfoFUCHSIA;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ImportMemoryZirconHandleInfoFUCHSIABuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`MemoryZirconHandlePropertiesFUCHSIA`] with lifetime-tied pNext safety.
pub struct MemoryZirconHandlePropertiesFUCHSIABuilder<'a> {
    inner: MemoryZirconHandlePropertiesFUCHSIA,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl MemoryZirconHandlePropertiesFUCHSIA {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> MemoryZirconHandlePropertiesFUCHSIABuilder<'a> {
        MemoryZirconHandlePropertiesFUCHSIABuilder {
            inner: MemoryZirconHandlePropertiesFUCHSIA {
                s_type: StructureType::from_raw(1000364001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> MemoryZirconHandlePropertiesFUCHSIABuilder<'a> {
    #[inline]
    pub fn memory_type_bits(mut self, value: u32) -> Self {
        self.inner.memory_type_bits = value;
        self
    }
}
impl<'a> core::ops::Deref for MemoryZirconHandlePropertiesFUCHSIABuilder<'a> {
    type Target = MemoryZirconHandlePropertiesFUCHSIA;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for MemoryZirconHandlePropertiesFUCHSIABuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`MemoryGetZirconHandleInfoFUCHSIA`] with lifetime-tied pNext safety.
pub struct MemoryGetZirconHandleInfoFUCHSIABuilder<'a> {
    inner: MemoryGetZirconHandleInfoFUCHSIA,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl MemoryGetZirconHandleInfoFUCHSIA {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> MemoryGetZirconHandleInfoFUCHSIABuilder<'a> {
        MemoryGetZirconHandleInfoFUCHSIABuilder {
            inner: MemoryGetZirconHandleInfoFUCHSIA {
                s_type: StructureType::from_raw(1000364002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> MemoryGetZirconHandleInfoFUCHSIABuilder<'a> {
    #[inline]
    pub fn memory(mut self, value: DeviceMemory) -> Self {
        self.inner.memory = value;
        self
    }
    #[inline]
    pub fn handle_type(mut self, value: ExternalMemoryHandleTypeFlagBits) -> Self {
        self.inner.handle_type = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`MemoryGetZirconHandleInfoFUCHSIA`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsMemoryGetZirconHandleInfoFUCHSIA>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for MemoryGetZirconHandleInfoFUCHSIABuilder<'a> {
    type Target = MemoryGetZirconHandleInfoFUCHSIA;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for MemoryGetZirconHandleInfoFUCHSIABuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`MemoryWin32HandlePropertiesKHR`] with lifetime-tied pNext safety.
pub struct MemoryWin32HandlePropertiesKHRBuilder<'a> {
    inner: MemoryWin32HandlePropertiesKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl MemoryWin32HandlePropertiesKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> MemoryWin32HandlePropertiesKHRBuilder<'a> {
        MemoryWin32HandlePropertiesKHRBuilder {
            inner: MemoryWin32HandlePropertiesKHR {
                s_type: StructureType::from_raw(1000073002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> MemoryWin32HandlePropertiesKHRBuilder<'a> {
    #[inline]
    pub fn memory_type_bits(mut self, value: u32) -> Self {
        self.inner.memory_type_bits = value;
        self
    }
}
impl<'a> core::ops::Deref for MemoryWin32HandlePropertiesKHRBuilder<'a> {
    type Target = MemoryWin32HandlePropertiesKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for MemoryWin32HandlePropertiesKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`MemoryGetWin32HandleInfoKHR`] with lifetime-tied pNext safety.
pub struct MemoryGetWin32HandleInfoKHRBuilder<'a> {
    inner: MemoryGetWin32HandleInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl MemoryGetWin32HandleInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> MemoryGetWin32HandleInfoKHRBuilder<'a> {
        MemoryGetWin32HandleInfoKHRBuilder {
            inner: MemoryGetWin32HandleInfoKHR {
                s_type: StructureType::from_raw(1000073003i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> MemoryGetWin32HandleInfoKHRBuilder<'a> {
    #[inline]
    pub fn memory(mut self, value: DeviceMemory) -> Self {
        self.inner.memory = value;
        self
    }
    #[inline]
    pub fn handle_type(mut self, value: ExternalMemoryHandleTypeFlagBits) -> Self {
        self.inner.handle_type = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`MemoryGetWin32HandleInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsMemoryGetWin32HandleInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for MemoryGetWin32HandleInfoKHRBuilder<'a> {
    type Target = MemoryGetWin32HandleInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for MemoryGetWin32HandleInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ImportMemoryFdInfoKHR`] with lifetime-tied pNext safety.
pub struct ImportMemoryFdInfoKHRBuilder<'a> {
    inner: ImportMemoryFdInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ImportMemoryFdInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ImportMemoryFdInfoKHRBuilder<'a> {
        ImportMemoryFdInfoKHRBuilder {
            inner: ImportMemoryFdInfoKHR {
                s_type: StructureType::from_raw(1000074000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ImportMemoryFdInfoKHRBuilder<'a> {
    #[inline]
    pub fn handle_type(mut self, value: ExternalMemoryHandleTypeFlagBits) -> Self {
        self.inner.handle_type = value;
        self
    }
    #[inline]
    pub fn fd(mut self, value: core::ffi::c_int) -> Self {
        self.inner.fd = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`ImportMemoryFdInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsImportMemoryFdInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for ImportMemoryFdInfoKHRBuilder<'a> {
    type Target = ImportMemoryFdInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ImportMemoryFdInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`MemoryFdPropertiesKHR`] with lifetime-tied pNext safety.
pub struct MemoryFdPropertiesKHRBuilder<'a> {
    inner: MemoryFdPropertiesKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl MemoryFdPropertiesKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> MemoryFdPropertiesKHRBuilder<'a> {
        MemoryFdPropertiesKHRBuilder {
            inner: MemoryFdPropertiesKHR {
                s_type: StructureType::from_raw(1000074001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> MemoryFdPropertiesKHRBuilder<'a> {
    #[inline]
    pub fn memory_type_bits(mut self, value: u32) -> Self {
        self.inner.memory_type_bits = value;
        self
    }
}
impl<'a> core::ops::Deref for MemoryFdPropertiesKHRBuilder<'a> {
    type Target = MemoryFdPropertiesKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for MemoryFdPropertiesKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`MemoryGetFdInfoKHR`] with lifetime-tied pNext safety.
pub struct MemoryGetFdInfoKHRBuilder<'a> {
    inner: MemoryGetFdInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl MemoryGetFdInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> MemoryGetFdInfoKHRBuilder<'a> {
        MemoryGetFdInfoKHRBuilder {
            inner: MemoryGetFdInfoKHR {
                s_type: StructureType::from_raw(1000074002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> MemoryGetFdInfoKHRBuilder<'a> {
    #[inline]
    pub fn memory(mut self, value: DeviceMemory) -> Self {
        self.inner.memory = value;
        self
    }
    #[inline]
    pub fn handle_type(mut self, value: ExternalMemoryHandleTypeFlagBits) -> Self {
        self.inner.handle_type = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`MemoryGetFdInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsMemoryGetFdInfoKHR>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for MemoryGetFdInfoKHRBuilder<'a> {
    type Target = MemoryGetFdInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for MemoryGetFdInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`Win32KeyedMutexAcquireReleaseInfoKHR`] with lifetime-tied pNext safety.
pub struct Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'a> {
    inner: Win32KeyedMutexAcquireReleaseInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl Win32KeyedMutexAcquireReleaseInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'a> {
        Win32KeyedMutexAcquireReleaseInfoKHRBuilder {
            inner: Win32KeyedMutexAcquireReleaseInfoKHR {
                s_type: StructureType::from_raw(1000075000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'a> {
    #[inline]
    pub fn acquire_syncs(mut self, slice: &'a [DeviceMemory]) -> Self {
        self.inner.acquire_count = slice.len() as u32;
        self.inner.p_acquire_syncs = slice.as_ptr();
        self
    }
    #[inline]
    pub fn acquire_keys(mut self, slice: &'a [u64]) -> Self {
        self.inner.acquire_count = slice.len() as u32;
        self.inner.p_acquire_keys = slice.as_ptr();
        self
    }
    #[inline]
    pub fn acquire_timeouts(mut self, slice: &'a [u32]) -> Self {
        self.inner.acquire_count = slice.len() as u32;
        self.inner.p_acquire_timeouts = slice.as_ptr();
        self
    }
    #[inline]
    pub fn release_syncs(mut self, slice: &'a [DeviceMemory]) -> Self {
        self.inner.release_count = slice.len() as u32;
        self.inner.p_release_syncs = slice.as_ptr();
        self
    }
    #[inline]
    pub fn release_keys(mut self, slice: &'a [u64]) -> Self {
        self.inner.release_count = slice.len() as u32;
        self.inner.p_release_keys = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`Win32KeyedMutexAcquireReleaseInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsWin32KeyedMutexAcquireReleaseInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'a> {
    type Target = Win32KeyedMutexAcquireReleaseInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ImportMemoryMetalHandleInfoEXT`] with lifetime-tied pNext safety.
pub struct ImportMemoryMetalHandleInfoEXTBuilder<'a> {
    inner: ImportMemoryMetalHandleInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ImportMemoryMetalHandleInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ImportMemoryMetalHandleInfoEXTBuilder<'a> {
        ImportMemoryMetalHandleInfoEXTBuilder {
            inner: ImportMemoryMetalHandleInfoEXT {
                s_type: StructureType::from_raw(1000602000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ImportMemoryMetalHandleInfoEXTBuilder<'a> {
    #[inline]
    pub fn handle_type(mut self, value: ExternalMemoryHandleTypeFlagBits) -> Self {
        self.inner.handle_type = value;
        self
    }
    #[inline]
    pub fn handle(mut self, value: *mut core::ffi::c_void) -> Self {
        self.inner.handle = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`ImportMemoryMetalHandleInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsImportMemoryMetalHandleInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for ImportMemoryMetalHandleInfoEXTBuilder<'a> {
    type Target = ImportMemoryMetalHandleInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ImportMemoryMetalHandleInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`MemoryMetalHandlePropertiesEXT`] with lifetime-tied pNext safety.
pub struct MemoryMetalHandlePropertiesEXTBuilder<'a> {
    inner: MemoryMetalHandlePropertiesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl MemoryMetalHandlePropertiesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> MemoryMetalHandlePropertiesEXTBuilder<'a> {
        MemoryMetalHandlePropertiesEXTBuilder {
            inner: MemoryMetalHandlePropertiesEXT {
                s_type: StructureType::from_raw(1000602001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> MemoryMetalHandlePropertiesEXTBuilder<'a> {
    #[inline]
    pub fn memory_type_bits(mut self, value: u32) -> Self {
        self.inner.memory_type_bits = value;
        self
    }
}
impl<'a> core::ops::Deref for MemoryMetalHandlePropertiesEXTBuilder<'a> {
    type Target = MemoryMetalHandlePropertiesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for MemoryMetalHandlePropertiesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`MemoryGetMetalHandleInfoEXT`] with lifetime-tied pNext safety.
pub struct MemoryGetMetalHandleInfoEXTBuilder<'a> {
    inner: MemoryGetMetalHandleInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl MemoryGetMetalHandleInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> MemoryGetMetalHandleInfoEXTBuilder<'a> {
        MemoryGetMetalHandleInfoEXTBuilder {
            inner: MemoryGetMetalHandleInfoEXT {
                s_type: StructureType::from_raw(1000602002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> MemoryGetMetalHandleInfoEXTBuilder<'a> {
    #[inline]
    pub fn memory(mut self, value: DeviceMemory) -> Self {
        self.inner.memory = value;
        self
    }
    #[inline]
    pub fn handle_type(mut self, value: ExternalMemoryHandleTypeFlagBits) -> Self {
        self.inner.handle_type = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`MemoryGetMetalHandleInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsMemoryGetMetalHandleInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for MemoryGetMetalHandleInfoEXTBuilder<'a> {
    type Target = MemoryGetMetalHandleInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for MemoryGetMetalHandleInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceExternalSemaphoreInfo`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceExternalSemaphoreInfoBuilder<'a> {
    inner: PhysicalDeviceExternalSemaphoreInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceExternalSemaphoreInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceExternalSemaphoreInfoBuilder<'a> {
        PhysicalDeviceExternalSemaphoreInfoBuilder {
            inner: PhysicalDeviceExternalSemaphoreInfo {
                s_type: StructureType::from_raw(1000076000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceExternalSemaphoreInfoBuilder<'a> {
    #[inline]
    pub fn handle_type(mut self, value: ExternalSemaphoreHandleTypeFlagBits) -> Self {
        self.inner.handle_type = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceExternalSemaphoreInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceExternalSemaphoreInfo>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceExternalSemaphoreInfoBuilder<'a> {
    type Target = PhysicalDeviceExternalSemaphoreInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceExternalSemaphoreInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ExternalSemaphoreProperties`] with lifetime-tied pNext safety.
pub struct ExternalSemaphorePropertiesBuilder<'a> {
    inner: ExternalSemaphoreProperties,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ExternalSemaphoreProperties {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ExternalSemaphorePropertiesBuilder<'a> {
        ExternalSemaphorePropertiesBuilder {
            inner: ExternalSemaphoreProperties {
                s_type: StructureType::from_raw(1000076001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ExternalSemaphorePropertiesBuilder<'a> {
    #[inline]
    pub fn export_from_imported_handle_types(
        mut self,
        value: ExternalSemaphoreHandleTypeFlags,
    ) -> Self {
        self.inner.export_from_imported_handle_types = value;
        self
    }
    #[inline]
    pub fn compatible_handle_types(
        mut self,
        value: ExternalSemaphoreHandleTypeFlags,
    ) -> Self {
        self.inner.compatible_handle_types = value;
        self
    }
    #[inline]
    pub fn external_semaphore_features(
        mut self,
        value: ExternalSemaphoreFeatureFlags,
    ) -> Self {
        self.inner.external_semaphore_features = value;
        self
    }
}
impl<'a> core::ops::Deref for ExternalSemaphorePropertiesBuilder<'a> {
    type Target = ExternalSemaphoreProperties;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ExternalSemaphorePropertiesBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ExportSemaphoreCreateInfo`] with lifetime-tied pNext safety.
pub struct ExportSemaphoreCreateInfoBuilder<'a> {
    inner: ExportSemaphoreCreateInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ExportSemaphoreCreateInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ExportSemaphoreCreateInfoBuilder<'a> {
        ExportSemaphoreCreateInfoBuilder {
            inner: ExportSemaphoreCreateInfo {
                s_type: StructureType::from_raw(1000077000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ExportSemaphoreCreateInfoBuilder<'a> {
    #[inline]
    pub fn handle_types(mut self, value: ExternalSemaphoreHandleTypeFlags) -> Self {
        self.inner.handle_types = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`ExportSemaphoreCreateInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsExportSemaphoreCreateInfo>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for ExportSemaphoreCreateInfoBuilder<'a> {
    type Target = ExportSemaphoreCreateInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ExportSemaphoreCreateInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ImportSemaphoreWin32HandleInfoKHR`] with lifetime-tied pNext safety.
pub struct ImportSemaphoreWin32HandleInfoKHRBuilder<'a> {
    inner: ImportSemaphoreWin32HandleInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ImportSemaphoreWin32HandleInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ImportSemaphoreWin32HandleInfoKHRBuilder<'a> {
        ImportSemaphoreWin32HandleInfoKHRBuilder {
            inner: ImportSemaphoreWin32HandleInfoKHR {
                s_type: StructureType::from_raw(1000078000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ImportSemaphoreWin32HandleInfoKHRBuilder<'a> {
    #[inline]
    pub fn semaphore(mut self, value: Semaphore) -> Self {
        self.inner.semaphore = value;
        self
    }
    #[inline]
    pub fn flags(mut self, value: SemaphoreImportFlags) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn handle_type(mut self, value: ExternalSemaphoreHandleTypeFlagBits) -> Self {
        self.inner.handle_type = value;
        self
    }
    #[inline]
    pub fn handle(mut self, value: isize) -> Self {
        self.inner.handle = value;
        self
    }
    #[inline]
    pub fn name(mut self, value: *const u16) -> Self {
        self.inner.name = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`ImportSemaphoreWin32HandleInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsImportSemaphoreWin32HandleInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for ImportSemaphoreWin32HandleInfoKHRBuilder<'a> {
    type Target = ImportSemaphoreWin32HandleInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ImportSemaphoreWin32HandleInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ExportSemaphoreWin32HandleInfoKHR`] with lifetime-tied pNext safety.
pub struct ExportSemaphoreWin32HandleInfoKHRBuilder<'a> {
    inner: ExportSemaphoreWin32HandleInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ExportSemaphoreWin32HandleInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ExportSemaphoreWin32HandleInfoKHRBuilder<'a> {
        ExportSemaphoreWin32HandleInfoKHRBuilder {
            inner: ExportSemaphoreWin32HandleInfoKHR {
                s_type: StructureType::from_raw(1000078001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ExportSemaphoreWin32HandleInfoKHRBuilder<'a> {
    #[inline]
    pub fn attributes(mut self, value: *const core::ffi::c_void) -> Self {
        self.inner.p_attributes = value;
        self
    }
    #[inline]
    pub fn dw_access(mut self, value: u32) -> Self {
        self.inner.dw_access = value;
        self
    }
    #[inline]
    pub fn name(mut self, value: *const u16) -> Self {
        self.inner.name = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`ExportSemaphoreWin32HandleInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsExportSemaphoreWin32HandleInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for ExportSemaphoreWin32HandleInfoKHRBuilder<'a> {
    type Target = ExportSemaphoreWin32HandleInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ExportSemaphoreWin32HandleInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`D3D12FenceSubmitInfoKHR`] with lifetime-tied pNext safety.
pub struct D3D12FenceSubmitInfoKHRBuilder<'a> {
    inner: D3D12FenceSubmitInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl D3D12FenceSubmitInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> D3D12FenceSubmitInfoKHRBuilder<'a> {
        D3D12FenceSubmitInfoKHRBuilder {
            inner: D3D12FenceSubmitInfoKHR {
                s_type: StructureType::from_raw(1000078002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> D3D12FenceSubmitInfoKHRBuilder<'a> {
    #[inline]
    pub fn wait_semaphore_values_count(mut self, value: u32) -> Self {
        self.inner.wait_semaphore_values_count = value;
        self
    }
    #[inline]
    pub fn wait_semaphore_values(mut self, slice: &'a [u64]) -> Self {
        self.inner.wait_semaphore_values_count = slice.len() as u32;
        self.inner.p_wait_semaphore_values = slice.as_ptr();
        self
    }
    #[inline]
    pub fn signal_semaphore_values_count(mut self, value: u32) -> Self {
        self.inner.signal_semaphore_values_count = value;
        self
    }
    #[inline]
    pub fn signal_semaphore_values(mut self, slice: &'a [u64]) -> Self {
        self.inner.signal_semaphore_values_count = slice.len() as u32;
        self.inner.p_signal_semaphore_values = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`D3D12FenceSubmitInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsD3D12FenceSubmitInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for D3D12FenceSubmitInfoKHRBuilder<'a> {
    type Target = D3D12FenceSubmitInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for D3D12FenceSubmitInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`SemaphoreGetWin32HandleInfoKHR`] with lifetime-tied pNext safety.
pub struct SemaphoreGetWin32HandleInfoKHRBuilder<'a> {
    inner: SemaphoreGetWin32HandleInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl SemaphoreGetWin32HandleInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> SemaphoreGetWin32HandleInfoKHRBuilder<'a> {
        SemaphoreGetWin32HandleInfoKHRBuilder {
            inner: SemaphoreGetWin32HandleInfoKHR {
                s_type: StructureType::from_raw(1000078003i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> SemaphoreGetWin32HandleInfoKHRBuilder<'a> {
    #[inline]
    pub fn semaphore(mut self, value: Semaphore) -> Self {
        self.inner.semaphore = value;
        self
    }
    #[inline]
    pub fn handle_type(mut self, value: ExternalSemaphoreHandleTypeFlagBits) -> Self {
        self.inner.handle_type = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`SemaphoreGetWin32HandleInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsSemaphoreGetWin32HandleInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for SemaphoreGetWin32HandleInfoKHRBuilder<'a> {
    type Target = SemaphoreGetWin32HandleInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for SemaphoreGetWin32HandleInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ImportSemaphoreFdInfoKHR`] with lifetime-tied pNext safety.
pub struct ImportSemaphoreFdInfoKHRBuilder<'a> {
    inner: ImportSemaphoreFdInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ImportSemaphoreFdInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ImportSemaphoreFdInfoKHRBuilder<'a> {
        ImportSemaphoreFdInfoKHRBuilder {
            inner: ImportSemaphoreFdInfoKHR {
                s_type: StructureType::from_raw(1000079000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ImportSemaphoreFdInfoKHRBuilder<'a> {
    #[inline]
    pub fn semaphore(mut self, value: Semaphore) -> Self {
        self.inner.semaphore = value;
        self
    }
    #[inline]
    pub fn flags(mut self, value: SemaphoreImportFlags) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn handle_type(mut self, value: ExternalSemaphoreHandleTypeFlagBits) -> Self {
        self.inner.handle_type = value;
        self
    }
    #[inline]
    pub fn fd(mut self, value: core::ffi::c_int) -> Self {
        self.inner.fd = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`ImportSemaphoreFdInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsImportSemaphoreFdInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for ImportSemaphoreFdInfoKHRBuilder<'a> {
    type Target = ImportSemaphoreFdInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ImportSemaphoreFdInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`SemaphoreGetFdInfoKHR`] with lifetime-tied pNext safety.
pub struct SemaphoreGetFdInfoKHRBuilder<'a> {
    inner: SemaphoreGetFdInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl SemaphoreGetFdInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> SemaphoreGetFdInfoKHRBuilder<'a> {
        SemaphoreGetFdInfoKHRBuilder {
            inner: SemaphoreGetFdInfoKHR {
                s_type: StructureType::from_raw(1000079001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> SemaphoreGetFdInfoKHRBuilder<'a> {
    #[inline]
    pub fn semaphore(mut self, value: Semaphore) -> Self {
        self.inner.semaphore = value;
        self
    }
    #[inline]
    pub fn handle_type(mut self, value: ExternalSemaphoreHandleTypeFlagBits) -> Self {
        self.inner.handle_type = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`SemaphoreGetFdInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsSemaphoreGetFdInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for SemaphoreGetFdInfoKHRBuilder<'a> {
    type Target = SemaphoreGetFdInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for SemaphoreGetFdInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ImportSemaphoreZirconHandleInfoFUCHSIA`] with lifetime-tied pNext safety.
pub struct ImportSemaphoreZirconHandleInfoFUCHSIABuilder<'a> {
    inner: ImportSemaphoreZirconHandleInfoFUCHSIA,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ImportSemaphoreZirconHandleInfoFUCHSIA {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ImportSemaphoreZirconHandleInfoFUCHSIABuilder<'a> {
        ImportSemaphoreZirconHandleInfoFUCHSIABuilder {
            inner: ImportSemaphoreZirconHandleInfoFUCHSIA {
                s_type: StructureType::from_raw(1000365000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ImportSemaphoreZirconHandleInfoFUCHSIABuilder<'a> {
    #[inline]
    pub fn semaphore(mut self, value: Semaphore) -> Self {
        self.inner.semaphore = value;
        self
    }
    #[inline]
    pub fn flags(mut self, value: SemaphoreImportFlags) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn handle_type(mut self, value: ExternalSemaphoreHandleTypeFlagBits) -> Self {
        self.inner.handle_type = value;
        self
    }
    #[inline]
    pub fn zircon_handle(mut self, value: u32) -> Self {
        self.inner.zircon_handle = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`ImportSemaphoreZirconHandleInfoFUCHSIA`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsImportSemaphoreZirconHandleInfoFUCHSIA>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for ImportSemaphoreZirconHandleInfoFUCHSIABuilder<'a> {
    type Target = ImportSemaphoreZirconHandleInfoFUCHSIA;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ImportSemaphoreZirconHandleInfoFUCHSIABuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`SemaphoreGetZirconHandleInfoFUCHSIA`] with lifetime-tied pNext safety.
pub struct SemaphoreGetZirconHandleInfoFUCHSIABuilder<'a> {
    inner: SemaphoreGetZirconHandleInfoFUCHSIA,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl SemaphoreGetZirconHandleInfoFUCHSIA {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> SemaphoreGetZirconHandleInfoFUCHSIABuilder<'a> {
        SemaphoreGetZirconHandleInfoFUCHSIABuilder {
            inner: SemaphoreGetZirconHandleInfoFUCHSIA {
                s_type: StructureType::from_raw(1000365001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> SemaphoreGetZirconHandleInfoFUCHSIABuilder<'a> {
    #[inline]
    pub fn semaphore(mut self, value: Semaphore) -> Self {
        self.inner.semaphore = value;
        self
    }
    #[inline]
    pub fn handle_type(mut self, value: ExternalSemaphoreHandleTypeFlagBits) -> Self {
        self.inner.handle_type = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`SemaphoreGetZirconHandleInfoFUCHSIA`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsSemaphoreGetZirconHandleInfoFUCHSIA>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for SemaphoreGetZirconHandleInfoFUCHSIABuilder<'a> {
    type Target = SemaphoreGetZirconHandleInfoFUCHSIA;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for SemaphoreGetZirconHandleInfoFUCHSIABuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceExternalFenceInfo`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceExternalFenceInfoBuilder<'a> {
    inner: PhysicalDeviceExternalFenceInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceExternalFenceInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceExternalFenceInfoBuilder<'a> {
        PhysicalDeviceExternalFenceInfoBuilder {
            inner: PhysicalDeviceExternalFenceInfo {
                s_type: StructureType::from_raw(1000112000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceExternalFenceInfoBuilder<'a> {
    #[inline]
    pub fn handle_type(mut self, value: ExternalFenceHandleTypeFlagBits) -> Self {
        self.inner.handle_type = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceExternalFenceInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceExternalFenceInfo>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceExternalFenceInfoBuilder<'a> {
    type Target = PhysicalDeviceExternalFenceInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceExternalFenceInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ExternalFenceProperties`] with lifetime-tied pNext safety.
pub struct ExternalFencePropertiesBuilder<'a> {
    inner: ExternalFenceProperties,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ExternalFenceProperties {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ExternalFencePropertiesBuilder<'a> {
        ExternalFencePropertiesBuilder {
            inner: ExternalFenceProperties {
                s_type: StructureType::from_raw(1000112001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ExternalFencePropertiesBuilder<'a> {
    #[inline]
    pub fn export_from_imported_handle_types(
        mut self,
        value: ExternalFenceHandleTypeFlags,
    ) -> Self {
        self.inner.export_from_imported_handle_types = value;
        self
    }
    #[inline]
    pub fn compatible_handle_types(
        mut self,
        value: ExternalFenceHandleTypeFlags,
    ) -> Self {
        self.inner.compatible_handle_types = value;
        self
    }
    #[inline]
    pub fn external_fence_features(mut self, value: ExternalFenceFeatureFlags) -> Self {
        self.inner.external_fence_features = value;
        self
    }
}
impl<'a> core::ops::Deref for ExternalFencePropertiesBuilder<'a> {
    type Target = ExternalFenceProperties;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ExternalFencePropertiesBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ExportFenceCreateInfo`] with lifetime-tied pNext safety.
pub struct ExportFenceCreateInfoBuilder<'a> {
    inner: ExportFenceCreateInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ExportFenceCreateInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ExportFenceCreateInfoBuilder<'a> {
        ExportFenceCreateInfoBuilder {
            inner: ExportFenceCreateInfo {
                s_type: StructureType::from_raw(1000113000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ExportFenceCreateInfoBuilder<'a> {
    #[inline]
    pub fn handle_types(mut self, value: ExternalFenceHandleTypeFlags) -> Self {
        self.inner.handle_types = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`ExportFenceCreateInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsExportFenceCreateInfo>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for ExportFenceCreateInfoBuilder<'a> {
    type Target = ExportFenceCreateInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ExportFenceCreateInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ImportFenceWin32HandleInfoKHR`] with lifetime-tied pNext safety.
pub struct ImportFenceWin32HandleInfoKHRBuilder<'a> {
    inner: ImportFenceWin32HandleInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ImportFenceWin32HandleInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ImportFenceWin32HandleInfoKHRBuilder<'a> {
        ImportFenceWin32HandleInfoKHRBuilder {
            inner: ImportFenceWin32HandleInfoKHR {
                s_type: StructureType::from_raw(1000114000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ImportFenceWin32HandleInfoKHRBuilder<'a> {
    #[inline]
    pub fn fence(mut self, value: Fence) -> Self {
        self.inner.fence = value;
        self
    }
    #[inline]
    pub fn flags(mut self, value: FenceImportFlags) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn handle_type(mut self, value: ExternalFenceHandleTypeFlagBits) -> Self {
        self.inner.handle_type = value;
        self
    }
    #[inline]
    pub fn handle(mut self, value: isize) -> Self {
        self.inner.handle = value;
        self
    }
    #[inline]
    pub fn name(mut self, value: *const u16) -> Self {
        self.inner.name = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`ImportFenceWin32HandleInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsImportFenceWin32HandleInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for ImportFenceWin32HandleInfoKHRBuilder<'a> {
    type Target = ImportFenceWin32HandleInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ImportFenceWin32HandleInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ExportFenceWin32HandleInfoKHR`] with lifetime-tied pNext safety.
pub struct ExportFenceWin32HandleInfoKHRBuilder<'a> {
    inner: ExportFenceWin32HandleInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ExportFenceWin32HandleInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ExportFenceWin32HandleInfoKHRBuilder<'a> {
        ExportFenceWin32HandleInfoKHRBuilder {
            inner: ExportFenceWin32HandleInfoKHR {
                s_type: StructureType::from_raw(1000114001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ExportFenceWin32HandleInfoKHRBuilder<'a> {
    #[inline]
    pub fn attributes(mut self, value: *const core::ffi::c_void) -> Self {
        self.inner.p_attributes = value;
        self
    }
    #[inline]
    pub fn dw_access(mut self, value: u32) -> Self {
        self.inner.dw_access = value;
        self
    }
    #[inline]
    pub fn name(mut self, value: *const u16) -> Self {
        self.inner.name = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`ExportFenceWin32HandleInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsExportFenceWin32HandleInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for ExportFenceWin32HandleInfoKHRBuilder<'a> {
    type Target = ExportFenceWin32HandleInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ExportFenceWin32HandleInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`FenceGetWin32HandleInfoKHR`] with lifetime-tied pNext safety.
pub struct FenceGetWin32HandleInfoKHRBuilder<'a> {
    inner: FenceGetWin32HandleInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl FenceGetWin32HandleInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> FenceGetWin32HandleInfoKHRBuilder<'a> {
        FenceGetWin32HandleInfoKHRBuilder {
            inner: FenceGetWin32HandleInfoKHR {
                s_type: StructureType::from_raw(1000114002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> FenceGetWin32HandleInfoKHRBuilder<'a> {
    #[inline]
    pub fn fence(mut self, value: Fence) -> Self {
        self.inner.fence = value;
        self
    }
    #[inline]
    pub fn handle_type(mut self, value: ExternalFenceHandleTypeFlagBits) -> Self {
        self.inner.handle_type = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`FenceGetWin32HandleInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsFenceGetWin32HandleInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for FenceGetWin32HandleInfoKHRBuilder<'a> {
    type Target = FenceGetWin32HandleInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for FenceGetWin32HandleInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ImportFenceFdInfoKHR`] with lifetime-tied pNext safety.
pub struct ImportFenceFdInfoKHRBuilder<'a> {
    inner: ImportFenceFdInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ImportFenceFdInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ImportFenceFdInfoKHRBuilder<'a> {
        ImportFenceFdInfoKHRBuilder {
            inner: ImportFenceFdInfoKHR {
                s_type: StructureType::from_raw(1000115000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ImportFenceFdInfoKHRBuilder<'a> {
    #[inline]
    pub fn fence(mut self, value: Fence) -> Self {
        self.inner.fence = value;
        self
    }
    #[inline]
    pub fn flags(mut self, value: FenceImportFlags) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn handle_type(mut self, value: ExternalFenceHandleTypeFlagBits) -> Self {
        self.inner.handle_type = value;
        self
    }
    #[inline]
    pub fn fd(mut self, value: core::ffi::c_int) -> Self {
        self.inner.fd = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`ImportFenceFdInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsImportFenceFdInfoKHR>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for ImportFenceFdInfoKHRBuilder<'a> {
    type Target = ImportFenceFdInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ImportFenceFdInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`FenceGetFdInfoKHR`] with lifetime-tied pNext safety.
pub struct FenceGetFdInfoKHRBuilder<'a> {
    inner: FenceGetFdInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl FenceGetFdInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> FenceGetFdInfoKHRBuilder<'a> {
        FenceGetFdInfoKHRBuilder {
            inner: FenceGetFdInfoKHR {
                s_type: StructureType::from_raw(1000115001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> FenceGetFdInfoKHRBuilder<'a> {
    #[inline]
    pub fn fence(mut self, value: Fence) -> Self {
        self.inner.fence = value;
        self
    }
    #[inline]
    pub fn handle_type(mut self, value: ExternalFenceHandleTypeFlagBits) -> Self {
        self.inner.handle_type = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`FenceGetFdInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsFenceGetFdInfoKHR>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for FenceGetFdInfoKHRBuilder<'a> {
    type Target = FenceGetFdInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for FenceGetFdInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ExportFenceSciSyncInfoNV`] with lifetime-tied pNext safety.
pub struct ExportFenceSciSyncInfoNVBuilder<'a> {
    inner: ExportFenceSciSyncInfoNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ExportFenceSciSyncInfoNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ExportFenceSciSyncInfoNVBuilder<'a> {
        ExportFenceSciSyncInfoNVBuilder {
            inner: ExportFenceSciSyncInfoNV {
                s_type: Default::default(),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ExportFenceSciSyncInfoNVBuilder<'a> {
    #[inline]
    pub fn p_attributes(mut self, value: *const core::ffi::c_void) -> Self {
        self.inner.p_attributes = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`ExportFenceSciSyncInfoNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsExportFenceSciSyncInfoNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for ExportFenceSciSyncInfoNVBuilder<'a> {
    type Target = ExportFenceSciSyncInfoNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ExportFenceSciSyncInfoNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ImportFenceSciSyncInfoNV`] with lifetime-tied pNext safety.
pub struct ImportFenceSciSyncInfoNVBuilder<'a> {
    inner: ImportFenceSciSyncInfoNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ImportFenceSciSyncInfoNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ImportFenceSciSyncInfoNVBuilder<'a> {
        ImportFenceSciSyncInfoNVBuilder {
            inner: ImportFenceSciSyncInfoNV {
                s_type: Default::default(),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ImportFenceSciSyncInfoNVBuilder<'a> {
    #[inline]
    pub fn fence(mut self, value: Fence) -> Self {
        self.inner.fence = value;
        self
    }
    #[inline]
    pub fn handle_type(mut self, value: ExternalFenceHandleTypeFlagBits) -> Self {
        self.inner.handle_type = value;
        self
    }
    #[inline]
    pub fn handle(mut self, value: *mut core::ffi::c_void) -> Self {
        self.inner.handle = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`ImportFenceSciSyncInfoNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsImportFenceSciSyncInfoNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for ImportFenceSciSyncInfoNVBuilder<'a> {
    type Target = ImportFenceSciSyncInfoNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ImportFenceSciSyncInfoNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`FenceGetSciSyncInfoNV`] with lifetime-tied pNext safety.
pub struct FenceGetSciSyncInfoNVBuilder<'a> {
    inner: FenceGetSciSyncInfoNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl FenceGetSciSyncInfoNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> FenceGetSciSyncInfoNVBuilder<'a> {
        FenceGetSciSyncInfoNVBuilder {
            inner: FenceGetSciSyncInfoNV {
                s_type: Default::default(),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> FenceGetSciSyncInfoNVBuilder<'a> {
    #[inline]
    pub fn fence(mut self, value: Fence) -> Self {
        self.inner.fence = value;
        self
    }
    #[inline]
    pub fn handle_type(mut self, value: ExternalFenceHandleTypeFlagBits) -> Self {
        self.inner.handle_type = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`FenceGetSciSyncInfoNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsFenceGetSciSyncInfoNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for FenceGetSciSyncInfoNVBuilder<'a> {
    type Target = FenceGetSciSyncInfoNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for FenceGetSciSyncInfoNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ExportSemaphoreSciSyncInfoNV`] with lifetime-tied pNext safety.
pub struct ExportSemaphoreSciSyncInfoNVBuilder<'a> {
    inner: ExportSemaphoreSciSyncInfoNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ExportSemaphoreSciSyncInfoNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ExportSemaphoreSciSyncInfoNVBuilder<'a> {
        ExportSemaphoreSciSyncInfoNVBuilder {
            inner: ExportSemaphoreSciSyncInfoNV {
                s_type: Default::default(),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ExportSemaphoreSciSyncInfoNVBuilder<'a> {
    #[inline]
    pub fn p_attributes(mut self, value: *const core::ffi::c_void) -> Self {
        self.inner.p_attributes = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`ExportSemaphoreSciSyncInfoNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsExportSemaphoreSciSyncInfoNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for ExportSemaphoreSciSyncInfoNVBuilder<'a> {
    type Target = ExportSemaphoreSciSyncInfoNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ExportSemaphoreSciSyncInfoNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ImportSemaphoreSciSyncInfoNV`] with lifetime-tied pNext safety.
pub struct ImportSemaphoreSciSyncInfoNVBuilder<'a> {
    inner: ImportSemaphoreSciSyncInfoNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ImportSemaphoreSciSyncInfoNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ImportSemaphoreSciSyncInfoNVBuilder<'a> {
        ImportSemaphoreSciSyncInfoNVBuilder {
            inner: ImportSemaphoreSciSyncInfoNV {
                s_type: Default::default(),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ImportSemaphoreSciSyncInfoNVBuilder<'a> {
    #[inline]
    pub fn semaphore(mut self, value: Semaphore) -> Self {
        self.inner.semaphore = value;
        self
    }
    #[inline]
    pub fn handle_type(mut self, value: ExternalSemaphoreHandleTypeFlagBits) -> Self {
        self.inner.handle_type = value;
        self
    }
    #[inline]
    pub fn handle(mut self, value: *mut core::ffi::c_void) -> Self {
        self.inner.handle = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`ImportSemaphoreSciSyncInfoNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsImportSemaphoreSciSyncInfoNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for ImportSemaphoreSciSyncInfoNVBuilder<'a> {
    type Target = ImportSemaphoreSciSyncInfoNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ImportSemaphoreSciSyncInfoNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`SemaphoreGetSciSyncInfoNV`] with lifetime-tied pNext safety.
pub struct SemaphoreGetSciSyncInfoNVBuilder<'a> {
    inner: SemaphoreGetSciSyncInfoNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl SemaphoreGetSciSyncInfoNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> SemaphoreGetSciSyncInfoNVBuilder<'a> {
        SemaphoreGetSciSyncInfoNVBuilder {
            inner: SemaphoreGetSciSyncInfoNV {
                s_type: Default::default(),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> SemaphoreGetSciSyncInfoNVBuilder<'a> {
    #[inline]
    pub fn semaphore(mut self, value: Semaphore) -> Self {
        self.inner.semaphore = value;
        self
    }
    #[inline]
    pub fn handle_type(mut self, value: ExternalSemaphoreHandleTypeFlagBits) -> Self {
        self.inner.handle_type = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`SemaphoreGetSciSyncInfoNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsSemaphoreGetSciSyncInfoNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for SemaphoreGetSciSyncInfoNVBuilder<'a> {
    type Target = SemaphoreGetSciSyncInfoNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for SemaphoreGetSciSyncInfoNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`SciSyncAttributesInfoNV`] with lifetime-tied pNext safety.
pub struct SciSyncAttributesInfoNVBuilder<'a> {
    inner: SciSyncAttributesInfoNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl SciSyncAttributesInfoNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> SciSyncAttributesInfoNVBuilder<'a> {
        SciSyncAttributesInfoNVBuilder {
            inner: SciSyncAttributesInfoNV {
                s_type: Default::default(),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> SciSyncAttributesInfoNVBuilder<'a> {
    #[inline]
    pub fn client_type(mut self, value: SciSyncClientTypeNV) -> Self {
        self.inner.client_type = value;
        self
    }
    #[inline]
    pub fn primitive_type(mut self, value: SciSyncPrimitiveTypeNV) -> Self {
        self.inner.primitive_type = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`SciSyncAttributesInfoNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsSciSyncAttributesInfoNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for SciSyncAttributesInfoNVBuilder<'a> {
    type Target = SciSyncAttributesInfoNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for SciSyncAttributesInfoNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceExternalSciSyncFeaturesNV`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceExternalSciSyncFeaturesNVBuilder<'a> {
    inner: PhysicalDeviceExternalSciSyncFeaturesNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceExternalSciSyncFeaturesNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceExternalSciSyncFeaturesNVBuilder<'a> {
        PhysicalDeviceExternalSciSyncFeaturesNVBuilder {
            inner: PhysicalDeviceExternalSciSyncFeaturesNV {
                s_type: Default::default(),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceExternalSciSyncFeaturesNVBuilder<'a> {
    #[inline]
    pub fn sci_sync_fence(mut self, value: bool) -> Self {
        self.inner.sci_sync_fence = value as u32;
        self
    }
    #[inline]
    pub fn sci_sync_semaphore(mut self, value: bool) -> Self {
        self.inner.sci_sync_semaphore = value as u32;
        self
    }
    #[inline]
    pub fn sci_sync_import(mut self, value: bool) -> Self {
        self.inner.sci_sync_import = value as u32;
        self
    }
    #[inline]
    pub fn sci_sync_export(mut self, value: bool) -> Self {
        self.inner.sci_sync_export = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceExternalSciSyncFeaturesNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceExternalSciSyncFeaturesNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceExternalSciSyncFeaturesNVBuilder<'a> {
    type Target = PhysicalDeviceExternalSciSyncFeaturesNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceExternalSciSyncFeaturesNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceExternalSciSync2FeaturesNV`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceExternalSciSync2FeaturesNVBuilder<'a> {
    inner: PhysicalDeviceExternalSciSync2FeaturesNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceExternalSciSync2FeaturesNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceExternalSciSync2FeaturesNVBuilder<'a> {
        PhysicalDeviceExternalSciSync2FeaturesNVBuilder {
            inner: PhysicalDeviceExternalSciSync2FeaturesNV {
                s_type: Default::default(),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceExternalSciSync2FeaturesNVBuilder<'a> {
    #[inline]
    pub fn sci_sync_fence(mut self, value: bool) -> Self {
        self.inner.sci_sync_fence = value as u32;
        self
    }
    #[inline]
    pub fn sci_sync_semaphore2(mut self, value: bool) -> Self {
        self.inner.sci_sync_semaphore2 = value as u32;
        self
    }
    #[inline]
    pub fn sci_sync_import(mut self, value: bool) -> Self {
        self.inner.sci_sync_import = value as u32;
        self
    }
    #[inline]
    pub fn sci_sync_export(mut self, value: bool) -> Self {
        self.inner.sci_sync_export = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceExternalSciSync2FeaturesNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceExternalSciSync2FeaturesNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceExternalSciSync2FeaturesNVBuilder<'a> {
    type Target = PhysicalDeviceExternalSciSync2FeaturesNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceExternalSciSync2FeaturesNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`SemaphoreSciSyncPoolCreateInfoNV`] with lifetime-tied pNext safety.
pub struct SemaphoreSciSyncPoolCreateInfoNVBuilder<'a> {
    inner: SemaphoreSciSyncPoolCreateInfoNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl SemaphoreSciSyncPoolCreateInfoNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> SemaphoreSciSyncPoolCreateInfoNVBuilder<'a> {
        SemaphoreSciSyncPoolCreateInfoNVBuilder {
            inner: SemaphoreSciSyncPoolCreateInfoNV {
                s_type: Default::default(),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> SemaphoreSciSyncPoolCreateInfoNVBuilder<'a> {
    #[inline]
    pub fn handle(mut self, value: *const core::ffi::c_void) -> Self {
        self.inner.handle = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`SemaphoreSciSyncPoolCreateInfoNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsSemaphoreSciSyncPoolCreateInfoNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for SemaphoreSciSyncPoolCreateInfoNVBuilder<'a> {
    type Target = SemaphoreSciSyncPoolCreateInfoNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for SemaphoreSciSyncPoolCreateInfoNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`SemaphoreSciSyncCreateInfoNV`] with lifetime-tied pNext safety.
pub struct SemaphoreSciSyncCreateInfoNVBuilder<'a> {
    inner: SemaphoreSciSyncCreateInfoNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl SemaphoreSciSyncCreateInfoNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> SemaphoreSciSyncCreateInfoNVBuilder<'a> {
        SemaphoreSciSyncCreateInfoNVBuilder {
            inner: SemaphoreSciSyncCreateInfoNV {
                s_type: Default::default(),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> SemaphoreSciSyncCreateInfoNVBuilder<'a> {
    #[inline]
    pub fn semaphore_pool(mut self, value: SemaphoreSciSyncPoolNV) -> Self {
        self.inner.semaphore_pool = value;
        self
    }
    #[inline]
    pub fn fence(mut self, value: *const core::ffi::c_void) -> Self {
        self.inner.p_fence = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`SemaphoreSciSyncCreateInfoNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsSemaphoreSciSyncCreateInfoNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for SemaphoreSciSyncCreateInfoNVBuilder<'a> {
    type Target = SemaphoreSciSyncCreateInfoNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for SemaphoreSciSyncCreateInfoNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DeviceSemaphoreSciSyncPoolReservationCreateInfoNV`] with lifetime-tied pNext safety.
pub struct DeviceSemaphoreSciSyncPoolReservationCreateInfoNVBuilder<'a> {
    inner: DeviceSemaphoreSciSyncPoolReservationCreateInfoNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DeviceSemaphoreSciSyncPoolReservationCreateInfoNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> DeviceSemaphoreSciSyncPoolReservationCreateInfoNVBuilder<
        'a,
    > {
        DeviceSemaphoreSciSyncPoolReservationCreateInfoNVBuilder {
            inner: DeviceSemaphoreSciSyncPoolReservationCreateInfoNV {
                s_type: Default::default(),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DeviceSemaphoreSciSyncPoolReservationCreateInfoNVBuilder<'a> {
    #[inline]
    pub fn semaphore_sci_sync_pool_request_count(mut self, value: u32) -> Self {
        self.inner.semaphore_sci_sync_pool_request_count = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`DeviceSemaphoreSciSyncPoolReservationCreateInfoNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsDeviceSemaphoreSciSyncPoolReservationCreateInfoNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref
for DeviceSemaphoreSciSyncPoolReservationCreateInfoNVBuilder<'a> {
    type Target = DeviceSemaphoreSciSyncPoolReservationCreateInfoNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for DeviceSemaphoreSciSyncPoolReservationCreateInfoNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceMultiviewFeatures`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceMultiviewFeaturesBuilder<'a> {
    inner: PhysicalDeviceMultiviewFeatures,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceMultiviewFeatures {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceMultiviewFeaturesBuilder<'a> {
        PhysicalDeviceMultiviewFeaturesBuilder {
            inner: PhysicalDeviceMultiviewFeatures {
                s_type: StructureType::from_raw(1000053001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceMultiviewFeaturesBuilder<'a> {
    #[inline]
    pub fn multiview(mut self, value: bool) -> Self {
        self.inner.multiview = value as u32;
        self
    }
    #[inline]
    pub fn multiview_geometry_shader(mut self, value: bool) -> Self {
        self.inner.multiview_geometry_shader = value as u32;
        self
    }
    #[inline]
    pub fn multiview_tessellation_shader(mut self, value: bool) -> Self {
        self.inner.multiview_tessellation_shader = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceMultiviewFeatures`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceMultiviewFeatures>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceMultiviewFeaturesBuilder<'a> {
    type Target = PhysicalDeviceMultiviewFeatures;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceMultiviewFeaturesBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceMultiviewProperties`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceMultiviewPropertiesBuilder<'a> {
    inner: PhysicalDeviceMultiviewProperties,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceMultiviewProperties {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceMultiviewPropertiesBuilder<'a> {
        PhysicalDeviceMultiviewPropertiesBuilder {
            inner: PhysicalDeviceMultiviewProperties {
                s_type: StructureType::from_raw(1000053002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceMultiviewPropertiesBuilder<'a> {
    #[inline]
    pub fn max_multiview_view_count(mut self, value: u32) -> Self {
        self.inner.max_multiview_view_count = value;
        self
    }
    #[inline]
    pub fn max_multiview_instance_index(mut self, value: u32) -> Self {
        self.inner.max_multiview_instance_index = value;
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceMultiviewPropertiesBuilder<'a> {
    type Target = PhysicalDeviceMultiviewProperties;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceMultiviewPropertiesBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`RenderPassMultiviewCreateInfo`] with lifetime-tied pNext safety.
pub struct RenderPassMultiviewCreateInfoBuilder<'a> {
    inner: RenderPassMultiviewCreateInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl RenderPassMultiviewCreateInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> RenderPassMultiviewCreateInfoBuilder<'a> {
        RenderPassMultiviewCreateInfoBuilder {
            inner: RenderPassMultiviewCreateInfo {
                s_type: StructureType::from_raw(1000053000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> RenderPassMultiviewCreateInfoBuilder<'a> {
    #[inline]
    pub fn view_masks(mut self, slice: &'a [u32]) -> Self {
        self.inner.subpass_count = slice.len() as u32;
        self.inner.p_view_masks = slice.as_ptr();
        self
    }
    #[inline]
    pub fn view_offsets(mut self, slice: &'a [i32]) -> Self {
        self.inner.dependency_count = slice.len() as u32;
        self.inner.p_view_offsets = slice.as_ptr();
        self
    }
    #[inline]
    pub fn correlation_masks(mut self, slice: &'a [u32]) -> Self {
        self.inner.correlation_mask_count = slice.len() as u32;
        self.inner.p_correlation_masks = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`RenderPassMultiviewCreateInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsRenderPassMultiviewCreateInfo>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for RenderPassMultiviewCreateInfoBuilder<'a> {
    type Target = RenderPassMultiviewCreateInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for RenderPassMultiviewCreateInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`SurfaceCapabilities2EXT`] with lifetime-tied pNext safety.
pub struct SurfaceCapabilities2EXTBuilder<'a> {
    inner: SurfaceCapabilities2EXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl SurfaceCapabilities2EXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> SurfaceCapabilities2EXTBuilder<'a> {
        SurfaceCapabilities2EXTBuilder {
            inner: SurfaceCapabilities2EXT {
                s_type: StructureType::from_raw(1000090000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> SurfaceCapabilities2EXTBuilder<'a> {
    #[inline]
    pub fn min_image_count(mut self, value: u32) -> Self {
        self.inner.min_image_count = value;
        self
    }
    #[inline]
    pub fn max_image_count(mut self, value: u32) -> Self {
        self.inner.max_image_count = value;
        self
    }
    #[inline]
    pub fn current_extent(mut self, value: Extent2D) -> Self {
        self.inner.current_extent = value;
        self
    }
    #[inline]
    pub fn min_image_extent(mut self, value: Extent2D) -> Self {
        self.inner.min_image_extent = value;
        self
    }
    #[inline]
    pub fn max_image_extent(mut self, value: Extent2D) -> Self {
        self.inner.max_image_extent = value;
        self
    }
    #[inline]
    pub fn max_image_array_layers(mut self, value: u32) -> Self {
        self.inner.max_image_array_layers = value;
        self
    }
    #[inline]
    pub fn supported_transforms(mut self, value: SurfaceTransformFlagsKHR) -> Self {
        self.inner.supported_transforms = value;
        self
    }
    #[inline]
    pub fn current_transform(mut self, value: SurfaceTransformFlagBitsKHR) -> Self {
        self.inner.current_transform = value;
        self
    }
    #[inline]
    pub fn supported_composite_alpha(mut self, value: CompositeAlphaFlagsKHR) -> Self {
        self.inner.supported_composite_alpha = value;
        self
    }
    #[inline]
    pub fn supported_usage_flags(mut self, value: ImageUsageFlags) -> Self {
        self.inner.supported_usage_flags = value;
        self
    }
    #[inline]
    pub fn supported_surface_counters(mut self, value: SurfaceCounterFlagsEXT) -> Self {
        self.inner.supported_surface_counters = value;
        self
    }
}
impl<'a> core::ops::Deref for SurfaceCapabilities2EXTBuilder<'a> {
    type Target = SurfaceCapabilities2EXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for SurfaceCapabilities2EXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DisplayPowerInfoEXT`] with lifetime-tied pNext safety.
pub struct DisplayPowerInfoEXTBuilder<'a> {
    inner: DisplayPowerInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DisplayPowerInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> DisplayPowerInfoEXTBuilder<'a> {
        DisplayPowerInfoEXTBuilder {
            inner: DisplayPowerInfoEXT {
                s_type: StructureType::from_raw(1000091000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DisplayPowerInfoEXTBuilder<'a> {
    #[inline]
    pub fn power_state(mut self, value: DisplayPowerStateEXT) -> Self {
        self.inner.power_state = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`DisplayPowerInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsDisplayPowerInfoEXT>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for DisplayPowerInfoEXTBuilder<'a> {
    type Target = DisplayPowerInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for DisplayPowerInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DeviceEventInfoEXT`] with lifetime-tied pNext safety.
pub struct DeviceEventInfoEXTBuilder<'a> {
    inner: DeviceEventInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DeviceEventInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> DeviceEventInfoEXTBuilder<'a> {
        DeviceEventInfoEXTBuilder {
            inner: DeviceEventInfoEXT {
                s_type: StructureType::from_raw(1000091001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DeviceEventInfoEXTBuilder<'a> {
    #[inline]
    pub fn device_event(mut self, value: DeviceEventTypeEXT) -> Self {
        self.inner.device_event = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`DeviceEventInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsDeviceEventInfoEXT>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for DeviceEventInfoEXTBuilder<'a> {
    type Target = DeviceEventInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for DeviceEventInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DisplayEventInfoEXT`] with lifetime-tied pNext safety.
pub struct DisplayEventInfoEXTBuilder<'a> {
    inner: DisplayEventInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DisplayEventInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> DisplayEventInfoEXTBuilder<'a> {
        DisplayEventInfoEXTBuilder {
            inner: DisplayEventInfoEXT {
                s_type: StructureType::from_raw(1000091002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DisplayEventInfoEXTBuilder<'a> {
    #[inline]
    pub fn display_event(mut self, value: DisplayEventTypeEXT) -> Self {
        self.inner.display_event = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`DisplayEventInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsDisplayEventInfoEXT>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for DisplayEventInfoEXTBuilder<'a> {
    type Target = DisplayEventInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for DisplayEventInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`SwapchainCounterCreateInfoEXT`] with lifetime-tied pNext safety.
pub struct SwapchainCounterCreateInfoEXTBuilder<'a> {
    inner: SwapchainCounterCreateInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl SwapchainCounterCreateInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> SwapchainCounterCreateInfoEXTBuilder<'a> {
        SwapchainCounterCreateInfoEXTBuilder {
            inner: SwapchainCounterCreateInfoEXT {
                s_type: StructureType::from_raw(1000091003i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> SwapchainCounterCreateInfoEXTBuilder<'a> {
    #[inline]
    pub fn surface_counters(mut self, value: SurfaceCounterFlagsEXT) -> Self {
        self.inner.surface_counters = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`SwapchainCounterCreateInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsSwapchainCounterCreateInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for SwapchainCounterCreateInfoEXTBuilder<'a> {
    type Target = SwapchainCounterCreateInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for SwapchainCounterCreateInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceGroupProperties`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceGroupPropertiesBuilder<'a> {
    inner: PhysicalDeviceGroupProperties,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceGroupProperties {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceGroupPropertiesBuilder<'a> {
        PhysicalDeviceGroupPropertiesBuilder {
            inner: PhysicalDeviceGroupProperties {
                s_type: StructureType::from_raw(1000070000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceGroupPropertiesBuilder<'a> {
    #[inline]
    pub fn physical_device_count(mut self, value: u32) -> Self {
        self.inner.physical_device_count = value;
        self
    }
    #[inline]
    pub fn physical_devices(
        mut self,
        value: [PhysicalDevice; MAX_DEVICE_GROUP_SIZE as usize],
    ) -> Self {
        self.inner.physical_devices = value;
        self
    }
    #[inline]
    pub fn subset_allocation(mut self, value: bool) -> Self {
        self.inner.subset_allocation = value as u32;
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceGroupPropertiesBuilder<'a> {
    type Target = PhysicalDeviceGroupProperties;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceGroupPropertiesBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`MemoryAllocateFlagsInfo`] with lifetime-tied pNext safety.
pub struct MemoryAllocateFlagsInfoBuilder<'a> {
    inner: MemoryAllocateFlagsInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl MemoryAllocateFlagsInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> MemoryAllocateFlagsInfoBuilder<'a> {
        MemoryAllocateFlagsInfoBuilder {
            inner: MemoryAllocateFlagsInfo {
                s_type: StructureType::from_raw(1000060000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> MemoryAllocateFlagsInfoBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: MemoryAllocateFlags) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn device_mask(mut self, value: u32) -> Self {
        self.inner.device_mask = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`MemoryAllocateFlagsInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsMemoryAllocateFlagsInfo>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for MemoryAllocateFlagsInfoBuilder<'a> {
    type Target = MemoryAllocateFlagsInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for MemoryAllocateFlagsInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`BindBufferMemoryInfo`] with lifetime-tied pNext safety.
pub struct BindBufferMemoryInfoBuilder<'a> {
    inner: BindBufferMemoryInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl BindBufferMemoryInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> BindBufferMemoryInfoBuilder<'a> {
        BindBufferMemoryInfoBuilder {
            inner: BindBufferMemoryInfo {
                s_type: StructureType::from_raw(1000157000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> BindBufferMemoryInfoBuilder<'a> {
    #[inline]
    pub fn buffer(mut self, value: Buffer) -> Self {
        self.inner.buffer = value;
        self
    }
    #[inline]
    pub fn memory(mut self, value: DeviceMemory) -> Self {
        self.inner.memory = value;
        self
    }
    #[inline]
    pub fn memory_offset(mut self, value: u64) -> Self {
        self.inner.memory_offset = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`BindBufferMemoryInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsBindBufferMemoryInfo>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for BindBufferMemoryInfoBuilder<'a> {
    type Target = BindBufferMemoryInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for BindBufferMemoryInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`BindBufferMemoryDeviceGroupInfo`] with lifetime-tied pNext safety.
pub struct BindBufferMemoryDeviceGroupInfoBuilder<'a> {
    inner: BindBufferMemoryDeviceGroupInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl BindBufferMemoryDeviceGroupInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> BindBufferMemoryDeviceGroupInfoBuilder<'a> {
        BindBufferMemoryDeviceGroupInfoBuilder {
            inner: BindBufferMemoryDeviceGroupInfo {
                s_type: StructureType::from_raw(1000060013i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> BindBufferMemoryDeviceGroupInfoBuilder<'a> {
    #[inline]
    pub fn device_indices(mut self, slice: &'a [u32]) -> Self {
        self.inner.device_index_count = slice.len() as u32;
        self.inner.p_device_indices = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`BindBufferMemoryDeviceGroupInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsBindBufferMemoryDeviceGroupInfo>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for BindBufferMemoryDeviceGroupInfoBuilder<'a> {
    type Target = BindBufferMemoryDeviceGroupInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for BindBufferMemoryDeviceGroupInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`BindImageMemoryInfo`] with lifetime-tied pNext safety.
pub struct BindImageMemoryInfoBuilder<'a> {
    inner: BindImageMemoryInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl BindImageMemoryInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> BindImageMemoryInfoBuilder<'a> {
        BindImageMemoryInfoBuilder {
            inner: BindImageMemoryInfo {
                s_type: StructureType::from_raw(1000157001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> BindImageMemoryInfoBuilder<'a> {
    #[inline]
    pub fn image(mut self, value: Image) -> Self {
        self.inner.image = value;
        self
    }
    #[inline]
    pub fn memory(mut self, value: DeviceMemory) -> Self {
        self.inner.memory = value;
        self
    }
    #[inline]
    pub fn memory_offset(mut self, value: u64) -> Self {
        self.inner.memory_offset = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`BindImageMemoryInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsBindImageMemoryInfo>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for BindImageMemoryInfoBuilder<'a> {
    type Target = BindImageMemoryInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for BindImageMemoryInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`BindImageMemoryDeviceGroupInfo`] with lifetime-tied pNext safety.
pub struct BindImageMemoryDeviceGroupInfoBuilder<'a> {
    inner: BindImageMemoryDeviceGroupInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl BindImageMemoryDeviceGroupInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> BindImageMemoryDeviceGroupInfoBuilder<'a> {
        BindImageMemoryDeviceGroupInfoBuilder {
            inner: BindImageMemoryDeviceGroupInfo {
                s_type: StructureType::from_raw(1000060014i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> BindImageMemoryDeviceGroupInfoBuilder<'a> {
    #[inline]
    pub fn device_indices(mut self, slice: &'a [u32]) -> Self {
        self.inner.device_index_count = slice.len() as u32;
        self.inner.p_device_indices = slice.as_ptr();
        self
    }
    #[inline]
    pub fn split_instance_bind_regions(mut self, slice: &'a [Rect2D]) -> Self {
        self.inner.split_instance_bind_region_count = slice.len() as u32;
        self.inner.p_split_instance_bind_regions = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`BindImageMemoryDeviceGroupInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsBindImageMemoryDeviceGroupInfo>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for BindImageMemoryDeviceGroupInfoBuilder<'a> {
    type Target = BindImageMemoryDeviceGroupInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for BindImageMemoryDeviceGroupInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DeviceGroupRenderPassBeginInfo`] with lifetime-tied pNext safety.
pub struct DeviceGroupRenderPassBeginInfoBuilder<'a> {
    inner: DeviceGroupRenderPassBeginInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DeviceGroupRenderPassBeginInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> DeviceGroupRenderPassBeginInfoBuilder<'a> {
        DeviceGroupRenderPassBeginInfoBuilder {
            inner: DeviceGroupRenderPassBeginInfo {
                s_type: StructureType::from_raw(1000060003i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DeviceGroupRenderPassBeginInfoBuilder<'a> {
    #[inline]
    pub fn device_mask(mut self, value: u32) -> Self {
        self.inner.device_mask = value;
        self
    }
    #[inline]
    pub fn device_render_areas(mut self, slice: &'a [Rect2D]) -> Self {
        self.inner.device_render_area_count = slice.len() as u32;
        self.inner.p_device_render_areas = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`DeviceGroupRenderPassBeginInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsDeviceGroupRenderPassBeginInfo>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for DeviceGroupRenderPassBeginInfoBuilder<'a> {
    type Target = DeviceGroupRenderPassBeginInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for DeviceGroupRenderPassBeginInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DeviceGroupCommandBufferBeginInfo`] with lifetime-tied pNext safety.
pub struct DeviceGroupCommandBufferBeginInfoBuilder<'a> {
    inner: DeviceGroupCommandBufferBeginInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DeviceGroupCommandBufferBeginInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> DeviceGroupCommandBufferBeginInfoBuilder<'a> {
        DeviceGroupCommandBufferBeginInfoBuilder {
            inner: DeviceGroupCommandBufferBeginInfo {
                s_type: StructureType::from_raw(1000060004i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DeviceGroupCommandBufferBeginInfoBuilder<'a> {
    #[inline]
    pub fn device_mask(mut self, value: u32) -> Self {
        self.inner.device_mask = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`DeviceGroupCommandBufferBeginInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsDeviceGroupCommandBufferBeginInfo>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for DeviceGroupCommandBufferBeginInfoBuilder<'a> {
    type Target = DeviceGroupCommandBufferBeginInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for DeviceGroupCommandBufferBeginInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DeviceGroupSubmitInfo`] with lifetime-tied pNext safety.
pub struct DeviceGroupSubmitInfoBuilder<'a> {
    inner: DeviceGroupSubmitInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DeviceGroupSubmitInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> DeviceGroupSubmitInfoBuilder<'a> {
        DeviceGroupSubmitInfoBuilder {
            inner: DeviceGroupSubmitInfo {
                s_type: StructureType::from_raw(1000060005i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DeviceGroupSubmitInfoBuilder<'a> {
    #[inline]
    pub fn wait_semaphore_device_indices(mut self, slice: &'a [u32]) -> Self {
        self.inner.wait_semaphore_count = slice.len() as u32;
        self.inner.p_wait_semaphore_device_indices = slice.as_ptr();
        self
    }
    #[inline]
    pub fn command_buffer_device_masks(mut self, slice: &'a [u32]) -> Self {
        self.inner.command_buffer_count = slice.len() as u32;
        self.inner.p_command_buffer_device_masks = slice.as_ptr();
        self
    }
    #[inline]
    pub fn signal_semaphore_device_indices(mut self, slice: &'a [u32]) -> Self {
        self.inner.signal_semaphore_count = slice.len() as u32;
        self.inner.p_signal_semaphore_device_indices = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`DeviceGroupSubmitInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsDeviceGroupSubmitInfo>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for DeviceGroupSubmitInfoBuilder<'a> {
    type Target = DeviceGroupSubmitInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for DeviceGroupSubmitInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DeviceGroupBindSparseInfo`] with lifetime-tied pNext safety.
pub struct DeviceGroupBindSparseInfoBuilder<'a> {
    inner: DeviceGroupBindSparseInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DeviceGroupBindSparseInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> DeviceGroupBindSparseInfoBuilder<'a> {
        DeviceGroupBindSparseInfoBuilder {
            inner: DeviceGroupBindSparseInfo {
                s_type: StructureType::from_raw(1000060006i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DeviceGroupBindSparseInfoBuilder<'a> {
    #[inline]
    pub fn resource_device_index(mut self, value: u32) -> Self {
        self.inner.resource_device_index = value;
        self
    }
    #[inline]
    pub fn memory_device_index(mut self, value: u32) -> Self {
        self.inner.memory_device_index = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`DeviceGroupBindSparseInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsDeviceGroupBindSparseInfo>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for DeviceGroupBindSparseInfoBuilder<'a> {
    type Target = DeviceGroupBindSparseInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for DeviceGroupBindSparseInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DeviceGroupPresentCapabilitiesKHR`] with lifetime-tied pNext safety.
pub struct DeviceGroupPresentCapabilitiesKHRBuilder<'a> {
    inner: DeviceGroupPresentCapabilitiesKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DeviceGroupPresentCapabilitiesKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> DeviceGroupPresentCapabilitiesKHRBuilder<'a> {
        DeviceGroupPresentCapabilitiesKHRBuilder {
            inner: DeviceGroupPresentCapabilitiesKHR {
                s_type: StructureType::from_raw(1000060007i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DeviceGroupPresentCapabilitiesKHRBuilder<'a> {
    #[inline]
    pub fn present_mask(mut self, value: [u32; MAX_DEVICE_GROUP_SIZE as usize]) -> Self {
        self.inner.present_mask = value;
        self
    }
    #[inline]
    pub fn modes(mut self, value: DeviceGroupPresentModeFlagsKHR) -> Self {
        self.inner.modes = value;
        self
    }
}
impl<'a> core::ops::Deref for DeviceGroupPresentCapabilitiesKHRBuilder<'a> {
    type Target = DeviceGroupPresentCapabilitiesKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for DeviceGroupPresentCapabilitiesKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ImageSwapchainCreateInfoKHR`] with lifetime-tied pNext safety.
pub struct ImageSwapchainCreateInfoKHRBuilder<'a> {
    inner: ImageSwapchainCreateInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ImageSwapchainCreateInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ImageSwapchainCreateInfoKHRBuilder<'a> {
        ImageSwapchainCreateInfoKHRBuilder {
            inner: ImageSwapchainCreateInfoKHR {
                s_type: StructureType::from_raw(1000060008i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ImageSwapchainCreateInfoKHRBuilder<'a> {
    #[inline]
    pub fn swapchain(mut self, value: SwapchainKHR) -> Self {
        self.inner.swapchain = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`ImageSwapchainCreateInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsImageSwapchainCreateInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for ImageSwapchainCreateInfoKHRBuilder<'a> {
    type Target = ImageSwapchainCreateInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ImageSwapchainCreateInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`BindImageMemorySwapchainInfoKHR`] with lifetime-tied pNext safety.
pub struct BindImageMemorySwapchainInfoKHRBuilder<'a> {
    inner: BindImageMemorySwapchainInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl BindImageMemorySwapchainInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> BindImageMemorySwapchainInfoKHRBuilder<'a> {
        BindImageMemorySwapchainInfoKHRBuilder {
            inner: BindImageMemorySwapchainInfoKHR {
                s_type: StructureType::from_raw(1000060009i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> BindImageMemorySwapchainInfoKHRBuilder<'a> {
    #[inline]
    pub fn swapchain(mut self, value: SwapchainKHR) -> Self {
        self.inner.swapchain = value;
        self
    }
    #[inline]
    pub fn image_index(mut self, value: u32) -> Self {
        self.inner.image_index = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`BindImageMemorySwapchainInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsBindImageMemorySwapchainInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for BindImageMemorySwapchainInfoKHRBuilder<'a> {
    type Target = BindImageMemorySwapchainInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for BindImageMemorySwapchainInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`AcquireNextImageInfoKHR`] with lifetime-tied pNext safety.
pub struct AcquireNextImageInfoKHRBuilder<'a> {
    inner: AcquireNextImageInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl AcquireNextImageInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> AcquireNextImageInfoKHRBuilder<'a> {
        AcquireNextImageInfoKHRBuilder {
            inner: AcquireNextImageInfoKHR {
                s_type: StructureType::from_raw(1000060010i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> AcquireNextImageInfoKHRBuilder<'a> {
    #[inline]
    pub fn swapchain(mut self, value: SwapchainKHR) -> Self {
        self.inner.swapchain = value;
        self
    }
    #[inline]
    pub fn timeout(mut self, value: u64) -> Self {
        self.inner.timeout = value;
        self
    }
    #[inline]
    pub fn semaphore(mut self, value: Semaphore) -> Self {
        self.inner.semaphore = value;
        self
    }
    #[inline]
    pub fn fence(mut self, value: Fence) -> Self {
        self.inner.fence = value;
        self
    }
    #[inline]
    pub fn device_mask(mut self, value: u32) -> Self {
        self.inner.device_mask = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`AcquireNextImageInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsAcquireNextImageInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for AcquireNextImageInfoKHRBuilder<'a> {
    type Target = AcquireNextImageInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for AcquireNextImageInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DeviceGroupPresentInfoKHR`] with lifetime-tied pNext safety.
pub struct DeviceGroupPresentInfoKHRBuilder<'a> {
    inner: DeviceGroupPresentInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DeviceGroupPresentInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> DeviceGroupPresentInfoKHRBuilder<'a> {
        DeviceGroupPresentInfoKHRBuilder {
            inner: DeviceGroupPresentInfoKHR {
                s_type: StructureType::from_raw(1000060011i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DeviceGroupPresentInfoKHRBuilder<'a> {
    #[inline]
    pub fn device_masks(mut self, slice: &'a [u32]) -> Self {
        self.inner.swapchain_count = slice.len() as u32;
        self.inner.p_device_masks = slice.as_ptr();
        self
    }
    #[inline]
    pub fn mode(mut self, value: DeviceGroupPresentModeFlagBitsKHR) -> Self {
        self.inner.mode = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`DeviceGroupPresentInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsDeviceGroupPresentInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for DeviceGroupPresentInfoKHRBuilder<'a> {
    type Target = DeviceGroupPresentInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for DeviceGroupPresentInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DeviceGroupDeviceCreateInfo`] with lifetime-tied pNext safety.
pub struct DeviceGroupDeviceCreateInfoBuilder<'a> {
    inner: DeviceGroupDeviceCreateInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DeviceGroupDeviceCreateInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> DeviceGroupDeviceCreateInfoBuilder<'a> {
        DeviceGroupDeviceCreateInfoBuilder {
            inner: DeviceGroupDeviceCreateInfo {
                s_type: StructureType::from_raw(1000070001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DeviceGroupDeviceCreateInfoBuilder<'a> {
    #[inline]
    pub fn physical_devices(mut self, slice: &'a [PhysicalDevice]) -> Self {
        self.inner.physical_device_count = slice.len() as u32;
        self.inner.p_physical_devices = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`DeviceGroupDeviceCreateInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsDeviceGroupDeviceCreateInfo>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for DeviceGroupDeviceCreateInfoBuilder<'a> {
    type Target = DeviceGroupDeviceCreateInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for DeviceGroupDeviceCreateInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DeviceGroupSwapchainCreateInfoKHR`] with lifetime-tied pNext safety.
pub struct DeviceGroupSwapchainCreateInfoKHRBuilder<'a> {
    inner: DeviceGroupSwapchainCreateInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DeviceGroupSwapchainCreateInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> DeviceGroupSwapchainCreateInfoKHRBuilder<'a> {
        DeviceGroupSwapchainCreateInfoKHRBuilder {
            inner: DeviceGroupSwapchainCreateInfoKHR {
                s_type: StructureType::from_raw(1000060012i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DeviceGroupSwapchainCreateInfoKHRBuilder<'a> {
    #[inline]
    pub fn modes(mut self, value: DeviceGroupPresentModeFlagsKHR) -> Self {
        self.inner.modes = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`DeviceGroupSwapchainCreateInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsDeviceGroupSwapchainCreateInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for DeviceGroupSwapchainCreateInfoKHRBuilder<'a> {
    type Target = DeviceGroupSwapchainCreateInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for DeviceGroupSwapchainCreateInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DescriptorUpdateTemplateEntry`].
pub struct DescriptorUpdateTemplateEntryBuilder {
    inner: DescriptorUpdateTemplateEntry,
}
impl DescriptorUpdateTemplateEntry {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> DescriptorUpdateTemplateEntryBuilder {
        DescriptorUpdateTemplateEntryBuilder {
            inner: DescriptorUpdateTemplateEntry {
                ..Default::default()
            },
        }
    }
}
impl DescriptorUpdateTemplateEntryBuilder {
    #[inline]
    pub fn dst_binding(mut self, value: u32) -> Self {
        self.inner.dst_binding = value;
        self
    }
    #[inline]
    pub fn dst_array_element(mut self, value: u32) -> Self {
        self.inner.dst_array_element = value;
        self
    }
    #[inline]
    pub fn descriptor_count(mut self, value: u32) -> Self {
        self.inner.descriptor_count = value;
        self
    }
    #[inline]
    pub fn descriptor_type(mut self, value: DescriptorType) -> Self {
        self.inner.descriptor_type = value;
        self
    }
    #[inline]
    pub fn offset(mut self, value: usize) -> Self {
        self.inner.offset = value;
        self
    }
    #[inline]
    pub fn stride(mut self, value: usize) -> Self {
        self.inner.stride = value;
        self
    }
}
impl core::ops::Deref for DescriptorUpdateTemplateEntryBuilder {
    type Target = DescriptorUpdateTemplateEntry;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for DescriptorUpdateTemplateEntryBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DescriptorUpdateTemplateCreateInfo`] with lifetime-tied pNext safety.
pub struct DescriptorUpdateTemplateCreateInfoBuilder<'a> {
    inner: DescriptorUpdateTemplateCreateInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DescriptorUpdateTemplateCreateInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> DescriptorUpdateTemplateCreateInfoBuilder<'a> {
        DescriptorUpdateTemplateCreateInfoBuilder {
            inner: DescriptorUpdateTemplateCreateInfo {
                s_type: StructureType::from_raw(1000085000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DescriptorUpdateTemplateCreateInfoBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: DescriptorUpdateTemplateCreateFlags) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn descriptor_update_entries(
        mut self,
        slice: &'a [DescriptorUpdateTemplateEntry],
    ) -> Self {
        self.inner.descriptor_update_entry_count = slice.len() as u32;
        self.inner.p_descriptor_update_entries = slice.as_ptr();
        self
    }
    #[inline]
    pub fn template_type(mut self, value: DescriptorUpdateTemplateType) -> Self {
        self.inner.template_type = value;
        self
    }
    #[inline]
    pub fn descriptor_set_layout(mut self, value: DescriptorSetLayout) -> Self {
        self.inner.descriptor_set_layout = value;
        self
    }
    #[inline]
    pub fn pipeline_bind_point(mut self, value: PipelineBindPoint) -> Self {
        self.inner.pipeline_bind_point = value;
        self
    }
    #[inline]
    pub fn pipeline_layout(mut self, value: PipelineLayout) -> Self {
        self.inner.pipeline_layout = value;
        self
    }
    #[inline]
    pub fn set(mut self, value: u32) -> Self {
        self.inner.set = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`DescriptorUpdateTemplateCreateInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsDescriptorUpdateTemplateCreateInfo>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for DescriptorUpdateTemplateCreateInfoBuilder<'a> {
    type Target = DescriptorUpdateTemplateCreateInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for DescriptorUpdateTemplateCreateInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`XYColorEXT`].
pub struct XYColorEXTBuilder {
    inner: XYColorEXT,
}
impl XYColorEXT {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> XYColorEXTBuilder {
        XYColorEXTBuilder {
            inner: XYColorEXT { ..Default::default() },
        }
    }
}
impl XYColorEXTBuilder {
    #[inline]
    pub fn x(mut self, value: f32) -> Self {
        self.inner.x = value;
        self
    }
    #[inline]
    pub fn y(mut self, value: f32) -> Self {
        self.inner.y = value;
        self
    }
}
impl core::ops::Deref for XYColorEXTBuilder {
    type Target = XYColorEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for XYColorEXTBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDevicePresentIdFeaturesKHR`] with lifetime-tied pNext safety.
pub struct PhysicalDevicePresentIdFeaturesKHRBuilder<'a> {
    inner: PhysicalDevicePresentIdFeaturesKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDevicePresentIdFeaturesKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDevicePresentIdFeaturesKHRBuilder<'a> {
        PhysicalDevicePresentIdFeaturesKHRBuilder {
            inner: PhysicalDevicePresentIdFeaturesKHR {
                s_type: StructureType::from_raw(1000294001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDevicePresentIdFeaturesKHRBuilder<'a> {
    #[inline]
    pub fn present_id(mut self, value: bool) -> Self {
        self.inner.present_id = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDevicePresentIdFeaturesKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDevicePresentIdFeaturesKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDevicePresentIdFeaturesKHRBuilder<'a> {
    type Target = PhysicalDevicePresentIdFeaturesKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDevicePresentIdFeaturesKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PresentIdKHR`] with lifetime-tied pNext safety.
pub struct PresentIdKHRBuilder<'a> {
    inner: PresentIdKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PresentIdKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PresentIdKHRBuilder<'a> {
        PresentIdKHRBuilder {
            inner: PresentIdKHR {
                s_type: StructureType::from_raw(1000294000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PresentIdKHRBuilder<'a> {
    #[inline]
    pub fn swapchain_count(mut self, value: u32) -> Self {
        self.inner.swapchain_count = value;
        self
    }
    #[inline]
    pub fn present_ids(mut self, slice: &'a [u64]) -> Self {
        self.inner.swapchain_count = slice.len() as u32;
        self.inner.p_present_ids = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`PresentIdKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPresentIdKHR>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for PresentIdKHRBuilder<'a> {
    type Target = PresentIdKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PresentIdKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDevicePresentId2FeaturesKHR`] with lifetime-tied pNext safety.
pub struct PhysicalDevicePresentId2FeaturesKHRBuilder<'a> {
    inner: PhysicalDevicePresentId2FeaturesKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDevicePresentId2FeaturesKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDevicePresentId2FeaturesKHRBuilder<'a> {
        PhysicalDevicePresentId2FeaturesKHRBuilder {
            inner: PhysicalDevicePresentId2FeaturesKHR {
                s_type: StructureType::from_raw(1000479002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDevicePresentId2FeaturesKHRBuilder<'a> {
    #[inline]
    pub fn present_id2(mut self, value: bool) -> Self {
        self.inner.present_id2 = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDevicePresentId2FeaturesKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDevicePresentId2FeaturesKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDevicePresentId2FeaturesKHRBuilder<'a> {
    type Target = PhysicalDevicePresentId2FeaturesKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDevicePresentId2FeaturesKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PresentId2KHR`] with lifetime-tied pNext safety.
pub struct PresentId2KHRBuilder<'a> {
    inner: PresentId2KHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PresentId2KHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PresentId2KHRBuilder<'a> {
        PresentId2KHRBuilder {
            inner: PresentId2KHR {
                s_type: StructureType::from_raw(1000479001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PresentId2KHRBuilder<'a> {
    #[inline]
    pub fn swapchain_count(mut self, value: u32) -> Self {
        self.inner.swapchain_count = value;
        self
    }
    #[inline]
    pub fn present_ids(mut self, slice: &'a [u64]) -> Self {
        self.inner.swapchain_count = slice.len() as u32;
        self.inner.p_present_ids = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`PresentId2KHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPresentId2KHR>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for PresentId2KHRBuilder<'a> {
    type Target = PresentId2KHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PresentId2KHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PresentWait2InfoKHR`] with lifetime-tied pNext safety.
pub struct PresentWait2InfoKHRBuilder<'a> {
    inner: PresentWait2InfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PresentWait2InfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PresentWait2InfoKHRBuilder<'a> {
        PresentWait2InfoKHRBuilder {
            inner: PresentWait2InfoKHR {
                s_type: StructureType::from_raw(1000480002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PresentWait2InfoKHRBuilder<'a> {
    #[inline]
    pub fn present_id(mut self, value: u64) -> Self {
        self.inner.present_id = value;
        self
    }
    #[inline]
    pub fn timeout(mut self, value: u64) -> Self {
        self.inner.timeout = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PresentWait2InfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPresentWait2InfoKHR>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for PresentWait2InfoKHRBuilder<'a> {
    type Target = PresentWait2InfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PresentWait2InfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDevicePresentWaitFeaturesKHR`] with lifetime-tied pNext safety.
pub struct PhysicalDevicePresentWaitFeaturesKHRBuilder<'a> {
    inner: PhysicalDevicePresentWaitFeaturesKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDevicePresentWaitFeaturesKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDevicePresentWaitFeaturesKHRBuilder<'a> {
        PhysicalDevicePresentWaitFeaturesKHRBuilder {
            inner: PhysicalDevicePresentWaitFeaturesKHR {
                s_type: StructureType::from_raw(1000248000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDevicePresentWaitFeaturesKHRBuilder<'a> {
    #[inline]
    pub fn present_wait(mut self, value: bool) -> Self {
        self.inner.present_wait = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDevicePresentWaitFeaturesKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDevicePresentWaitFeaturesKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDevicePresentWaitFeaturesKHRBuilder<'a> {
    type Target = PhysicalDevicePresentWaitFeaturesKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDevicePresentWaitFeaturesKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDevicePresentWait2FeaturesKHR`] with lifetime-tied pNext safety.
pub struct PhysicalDevicePresentWait2FeaturesKHRBuilder<'a> {
    inner: PhysicalDevicePresentWait2FeaturesKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDevicePresentWait2FeaturesKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDevicePresentWait2FeaturesKHRBuilder<'a> {
        PhysicalDevicePresentWait2FeaturesKHRBuilder {
            inner: PhysicalDevicePresentWait2FeaturesKHR {
                s_type: StructureType::from_raw(1000480001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDevicePresentWait2FeaturesKHRBuilder<'a> {
    #[inline]
    pub fn present_wait2(mut self, value: bool) -> Self {
        self.inner.present_wait2 = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDevicePresentWait2FeaturesKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDevicePresentWait2FeaturesKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDevicePresentWait2FeaturesKHRBuilder<'a> {
    type Target = PhysicalDevicePresentWait2FeaturesKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDevicePresentWait2FeaturesKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDevicePresentTimingFeaturesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDevicePresentTimingFeaturesEXTBuilder<'a> {
    inner: PhysicalDevicePresentTimingFeaturesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDevicePresentTimingFeaturesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDevicePresentTimingFeaturesEXTBuilder<'a> {
        PhysicalDevicePresentTimingFeaturesEXTBuilder {
            inner: PhysicalDevicePresentTimingFeaturesEXT {
                s_type: StructureType::from_raw(1000208000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDevicePresentTimingFeaturesEXTBuilder<'a> {
    #[inline]
    pub fn present_timing(mut self, value: bool) -> Self {
        self.inner.present_timing = value as u32;
        self
    }
    #[inline]
    pub fn present_at_absolute_time(mut self, value: bool) -> Self {
        self.inner.present_at_absolute_time = value as u32;
        self
    }
    #[inline]
    pub fn present_at_relative_time(mut self, value: bool) -> Self {
        self.inner.present_at_relative_time = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDevicePresentTimingFeaturesEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDevicePresentTimingFeaturesEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDevicePresentTimingFeaturesEXTBuilder<'a> {
    type Target = PhysicalDevicePresentTimingFeaturesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDevicePresentTimingFeaturesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PresentTimingSurfaceCapabilitiesEXT`] with lifetime-tied pNext safety.
pub struct PresentTimingSurfaceCapabilitiesEXTBuilder<'a> {
    inner: PresentTimingSurfaceCapabilitiesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PresentTimingSurfaceCapabilitiesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PresentTimingSurfaceCapabilitiesEXTBuilder<'a> {
        PresentTimingSurfaceCapabilitiesEXTBuilder {
            inner: PresentTimingSurfaceCapabilitiesEXT {
                s_type: StructureType::from_raw(1000208008i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PresentTimingSurfaceCapabilitiesEXTBuilder<'a> {
    #[inline]
    pub fn present_timing_supported(mut self, value: bool) -> Self {
        self.inner.present_timing_supported = value as u32;
        self
    }
    #[inline]
    pub fn present_at_absolute_time_supported(mut self, value: bool) -> Self {
        self.inner.present_at_absolute_time_supported = value as u32;
        self
    }
    #[inline]
    pub fn present_at_relative_time_supported(mut self, value: bool) -> Self {
        self.inner.present_at_relative_time_supported = value as u32;
        self
    }
    #[inline]
    pub fn present_stage_queries(mut self, value: PresentStageFlagsEXT) -> Self {
        self.inner.present_stage_queries = value;
        self
    }
}
impl<'a> core::ops::Deref for PresentTimingSurfaceCapabilitiesEXTBuilder<'a> {
    type Target = PresentTimingSurfaceCapabilitiesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PresentTimingSurfaceCapabilitiesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`SwapchainTimingPropertiesEXT`] with lifetime-tied pNext safety.
pub struct SwapchainTimingPropertiesEXTBuilder<'a> {
    inner: SwapchainTimingPropertiesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl SwapchainTimingPropertiesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> SwapchainTimingPropertiesEXTBuilder<'a> {
        SwapchainTimingPropertiesEXTBuilder {
            inner: SwapchainTimingPropertiesEXT {
                s_type: StructureType::from_raw(1000208001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> SwapchainTimingPropertiesEXTBuilder<'a> {
    #[inline]
    pub fn refresh_duration(mut self, value: u64) -> Self {
        self.inner.refresh_duration = value;
        self
    }
    #[inline]
    pub fn refresh_interval(mut self, value: u64) -> Self {
        self.inner.refresh_interval = value;
        self
    }
}
impl<'a> core::ops::Deref for SwapchainTimingPropertiesEXTBuilder<'a> {
    type Target = SwapchainTimingPropertiesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for SwapchainTimingPropertiesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`SwapchainTimeDomainPropertiesEXT`] with lifetime-tied pNext safety.
pub struct SwapchainTimeDomainPropertiesEXTBuilder<'a> {
    inner: SwapchainTimeDomainPropertiesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl SwapchainTimeDomainPropertiesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> SwapchainTimeDomainPropertiesEXTBuilder<'a> {
        SwapchainTimeDomainPropertiesEXTBuilder {
            inner: SwapchainTimeDomainPropertiesEXT {
                s_type: StructureType::from_raw(1000208002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> SwapchainTimeDomainPropertiesEXTBuilder<'a> {
    #[inline]
    pub fn time_domain_count(mut self, value: u32) -> Self {
        self.inner.time_domain_count = value;
        self
    }
    #[inline]
    pub fn time_domains(mut self, slice: &'a mut [TimeDomainKHR]) -> Self {
        self.inner.time_domain_count = slice.len() as u32;
        self.inner.p_time_domains = slice.as_mut_ptr();
        self
    }
    #[inline]
    pub fn time_domain_ids(mut self, slice: &'a mut [u64]) -> Self {
        self.inner.time_domain_count = slice.len() as u32;
        self.inner.p_time_domain_ids = slice.as_mut_ptr();
        self
    }
}
impl<'a> core::ops::Deref for SwapchainTimeDomainPropertiesEXTBuilder<'a> {
    type Target = SwapchainTimeDomainPropertiesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for SwapchainTimeDomainPropertiesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PresentStageTimeEXT`].
pub struct PresentStageTimeEXTBuilder {
    inner: PresentStageTimeEXT,
}
impl PresentStageTimeEXT {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> PresentStageTimeEXTBuilder {
        PresentStageTimeEXTBuilder {
            inner: PresentStageTimeEXT {
                ..Default::default()
            },
        }
    }
}
impl PresentStageTimeEXTBuilder {
    #[inline]
    pub fn stage(mut self, value: PresentStageFlagsEXT) -> Self {
        self.inner.stage = value;
        self
    }
    #[inline]
    pub fn time(mut self, value: u64) -> Self {
        self.inner.time = value;
        self
    }
}
impl core::ops::Deref for PresentStageTimeEXTBuilder {
    type Target = PresentStageTimeEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for PresentStageTimeEXTBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PastPresentationTimingInfoEXT`] with lifetime-tied pNext safety.
pub struct PastPresentationTimingInfoEXTBuilder<'a> {
    inner: PastPresentationTimingInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PastPresentationTimingInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PastPresentationTimingInfoEXTBuilder<'a> {
        PastPresentationTimingInfoEXTBuilder {
            inner: PastPresentationTimingInfoEXT {
                s_type: StructureType::from_raw(1000208005i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PastPresentationTimingInfoEXTBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: PastPresentationTimingFlagsEXT) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn swapchain(mut self, value: SwapchainKHR) -> Self {
        self.inner.swapchain = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PastPresentationTimingInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPastPresentationTimingInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for PastPresentationTimingInfoEXTBuilder<'a> {
    type Target = PastPresentationTimingInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PastPresentationTimingInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PastPresentationTimingPropertiesEXT`] with lifetime-tied pNext safety.
pub struct PastPresentationTimingPropertiesEXTBuilder<'a> {
    inner: PastPresentationTimingPropertiesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PastPresentationTimingPropertiesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PastPresentationTimingPropertiesEXTBuilder<'a> {
        PastPresentationTimingPropertiesEXTBuilder {
            inner: PastPresentationTimingPropertiesEXT {
                s_type: StructureType::from_raw(1000208006i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PastPresentationTimingPropertiesEXTBuilder<'a> {
    #[inline]
    pub fn timing_properties_counter(mut self, value: u64) -> Self {
        self.inner.timing_properties_counter = value;
        self
    }
    #[inline]
    pub fn time_domains_counter(mut self, value: u64) -> Self {
        self.inner.time_domains_counter = value;
        self
    }
    #[inline]
    pub fn presentation_timings(
        mut self,
        slice: &'a mut [PastPresentationTimingEXT],
    ) -> Self {
        self.inner.presentation_timing_count = slice.len() as u32;
        self.inner.p_presentation_timings = slice.as_mut_ptr();
        self
    }
}
impl<'a> core::ops::Deref for PastPresentationTimingPropertiesEXTBuilder<'a> {
    type Target = PastPresentationTimingPropertiesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PastPresentationTimingPropertiesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PastPresentationTimingEXT`] with lifetime-tied pNext safety.
pub struct PastPresentationTimingEXTBuilder<'a> {
    inner: PastPresentationTimingEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PastPresentationTimingEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PastPresentationTimingEXTBuilder<'a> {
        PastPresentationTimingEXTBuilder {
            inner: PastPresentationTimingEXT {
                s_type: StructureType::from_raw(1000208007i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PastPresentationTimingEXTBuilder<'a> {
    #[inline]
    pub fn present_id(mut self, value: u64) -> Self {
        self.inner.present_id = value;
        self
    }
    #[inline]
    pub fn target_time(mut self, value: u64) -> Self {
        self.inner.target_time = value;
        self
    }
    #[inline]
    pub fn present_stages(mut self, slice: &'a mut [PresentStageTimeEXT]) -> Self {
        self.inner.present_stage_count = slice.len() as u32;
        self.inner.p_present_stages = slice.as_mut_ptr();
        self
    }
    #[inline]
    pub fn time_domain(mut self, value: TimeDomainKHR) -> Self {
        self.inner.time_domain = value;
        self
    }
    #[inline]
    pub fn time_domain_id(mut self, value: u64) -> Self {
        self.inner.time_domain_id = value;
        self
    }
    #[inline]
    pub fn report_complete(mut self, value: bool) -> Self {
        self.inner.report_complete = value as u32;
        self
    }
}
impl<'a> core::ops::Deref for PastPresentationTimingEXTBuilder<'a> {
    type Target = PastPresentationTimingEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PastPresentationTimingEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PresentTimingsInfoEXT`] with lifetime-tied pNext safety.
pub struct PresentTimingsInfoEXTBuilder<'a> {
    inner: PresentTimingsInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PresentTimingsInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PresentTimingsInfoEXTBuilder<'a> {
        PresentTimingsInfoEXTBuilder {
            inner: PresentTimingsInfoEXT {
                s_type: StructureType::from_raw(1000208003i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PresentTimingsInfoEXTBuilder<'a> {
    #[inline]
    pub fn swapchain_count(mut self, value: u32) -> Self {
        self.inner.swapchain_count = value;
        self
    }
    #[inline]
    pub fn timing_infos(mut self, slice: &'a [PresentTimingInfoEXT]) -> Self {
        self.inner.swapchain_count = slice.len() as u32;
        self.inner.p_timing_infos = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`PresentTimingsInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPresentTimingsInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for PresentTimingsInfoEXTBuilder<'a> {
    type Target = PresentTimingsInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PresentTimingsInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PresentTimingInfoEXT`] with lifetime-tied pNext safety.
pub struct PresentTimingInfoEXTBuilder<'a> {
    inner: PresentTimingInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PresentTimingInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PresentTimingInfoEXTBuilder<'a> {
        PresentTimingInfoEXTBuilder {
            inner: PresentTimingInfoEXT {
                s_type: StructureType::from_raw(1000208004i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PresentTimingInfoEXTBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: PresentTimingInfoFlagsEXT) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn target_time(mut self, value: u64) -> Self {
        self.inner.target_time = value;
        self
    }
    #[inline]
    pub fn time_domain_id(mut self, value: u64) -> Self {
        self.inner.time_domain_id = value;
        self
    }
    #[inline]
    pub fn present_stage_queries(mut self, value: PresentStageFlagsEXT) -> Self {
        self.inner.present_stage_queries = value;
        self
    }
    #[inline]
    pub fn target_time_domain_present_stage(
        mut self,
        value: PresentStageFlagsEXT,
    ) -> Self {
        self.inner.target_time_domain_present_stage = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PresentTimingInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPresentTimingInfoEXT>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for PresentTimingInfoEXTBuilder<'a> {
    type Target = PresentTimingInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PresentTimingInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`SwapchainCalibratedTimestampInfoEXT`] with lifetime-tied pNext safety.
pub struct SwapchainCalibratedTimestampInfoEXTBuilder<'a> {
    inner: SwapchainCalibratedTimestampInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl SwapchainCalibratedTimestampInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> SwapchainCalibratedTimestampInfoEXTBuilder<'a> {
        SwapchainCalibratedTimestampInfoEXTBuilder {
            inner: SwapchainCalibratedTimestampInfoEXT {
                s_type: StructureType::from_raw(1000208009i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> SwapchainCalibratedTimestampInfoEXTBuilder<'a> {
    #[inline]
    pub fn swapchain(mut self, value: SwapchainKHR) -> Self {
        self.inner.swapchain = value;
        self
    }
    #[inline]
    pub fn present_stage(mut self, value: PresentStageFlagsEXT) -> Self {
        self.inner.present_stage = value;
        self
    }
    #[inline]
    pub fn time_domain_id(mut self, value: u64) -> Self {
        self.inner.time_domain_id = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`SwapchainCalibratedTimestampInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsSwapchainCalibratedTimestampInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for SwapchainCalibratedTimestampInfoEXTBuilder<'a> {
    type Target = SwapchainCalibratedTimestampInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for SwapchainCalibratedTimestampInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`HdrMetadataEXT`] with lifetime-tied pNext safety.
pub struct HdrMetadataEXTBuilder<'a> {
    inner: HdrMetadataEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl HdrMetadataEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> HdrMetadataEXTBuilder<'a> {
        HdrMetadataEXTBuilder {
            inner: HdrMetadataEXT {
                s_type: StructureType::from_raw(1000105000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> HdrMetadataEXTBuilder<'a> {
    #[inline]
    pub fn display_primary_red(mut self, value: XYColorEXT) -> Self {
        self.inner.display_primary_red = value;
        self
    }
    #[inline]
    pub fn display_primary_green(mut self, value: XYColorEXT) -> Self {
        self.inner.display_primary_green = value;
        self
    }
    #[inline]
    pub fn display_primary_blue(mut self, value: XYColorEXT) -> Self {
        self.inner.display_primary_blue = value;
        self
    }
    #[inline]
    pub fn white_point(mut self, value: XYColorEXT) -> Self {
        self.inner.white_point = value;
        self
    }
    #[inline]
    pub fn max_luminance(mut self, value: f32) -> Self {
        self.inner.max_luminance = value;
        self
    }
    #[inline]
    pub fn min_luminance(mut self, value: f32) -> Self {
        self.inner.min_luminance = value;
        self
    }
    #[inline]
    pub fn max_content_light_level(mut self, value: f32) -> Self {
        self.inner.max_content_light_level = value;
        self
    }
    #[inline]
    pub fn max_frame_average_light_level(mut self, value: f32) -> Self {
        self.inner.max_frame_average_light_level = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`HdrMetadataEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsHdrMetadataEXT>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for HdrMetadataEXTBuilder<'a> {
    type Target = HdrMetadataEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for HdrMetadataEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`HdrVividDynamicMetadataHUAWEI`] with lifetime-tied pNext safety.
pub struct HdrVividDynamicMetadataHUAWEIBuilder<'a> {
    inner: HdrVividDynamicMetadataHUAWEI,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl HdrVividDynamicMetadataHUAWEI {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> HdrVividDynamicMetadataHUAWEIBuilder<'a> {
        HdrVividDynamicMetadataHUAWEIBuilder {
            inner: HdrVividDynamicMetadataHUAWEI {
                s_type: StructureType::from_raw(1000590001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> HdrVividDynamicMetadataHUAWEIBuilder<'a> {
    #[inline]
    pub fn dynamic_metadata(mut self, slice: &'a [core::ffi::c_void]) -> Self {
        self.inner.dynamic_metadata_size = slice.len();
        self.inner.p_dynamic_metadata = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`HdrVividDynamicMetadataHUAWEI`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsHdrVividDynamicMetadataHUAWEI>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for HdrVividDynamicMetadataHUAWEIBuilder<'a> {
    type Target = HdrVividDynamicMetadataHUAWEI;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for HdrVividDynamicMetadataHUAWEIBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DisplayNativeHdrSurfaceCapabilitiesAMD`] with lifetime-tied pNext safety.
pub struct DisplayNativeHdrSurfaceCapabilitiesAMDBuilder<'a> {
    inner: DisplayNativeHdrSurfaceCapabilitiesAMD,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DisplayNativeHdrSurfaceCapabilitiesAMD {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> DisplayNativeHdrSurfaceCapabilitiesAMDBuilder<'a> {
        DisplayNativeHdrSurfaceCapabilitiesAMDBuilder {
            inner: DisplayNativeHdrSurfaceCapabilitiesAMD {
                s_type: StructureType::from_raw(1000213000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DisplayNativeHdrSurfaceCapabilitiesAMDBuilder<'a> {
    #[inline]
    pub fn local_dimming_support(mut self, value: bool) -> Self {
        self.inner.local_dimming_support = value as u32;
        self
    }
}
impl<'a> core::ops::Deref for DisplayNativeHdrSurfaceCapabilitiesAMDBuilder<'a> {
    type Target = DisplayNativeHdrSurfaceCapabilitiesAMD;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for DisplayNativeHdrSurfaceCapabilitiesAMDBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`SwapchainDisplayNativeHdrCreateInfoAMD`] with lifetime-tied pNext safety.
pub struct SwapchainDisplayNativeHdrCreateInfoAMDBuilder<'a> {
    inner: SwapchainDisplayNativeHdrCreateInfoAMD,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl SwapchainDisplayNativeHdrCreateInfoAMD {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> SwapchainDisplayNativeHdrCreateInfoAMDBuilder<'a> {
        SwapchainDisplayNativeHdrCreateInfoAMDBuilder {
            inner: SwapchainDisplayNativeHdrCreateInfoAMD {
                s_type: StructureType::from_raw(1000213001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> SwapchainDisplayNativeHdrCreateInfoAMDBuilder<'a> {
    #[inline]
    pub fn local_dimming_enable(mut self, value: bool) -> Self {
        self.inner.local_dimming_enable = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`SwapchainDisplayNativeHdrCreateInfoAMD`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsSwapchainDisplayNativeHdrCreateInfoAMD>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for SwapchainDisplayNativeHdrCreateInfoAMDBuilder<'a> {
    type Target = SwapchainDisplayNativeHdrCreateInfoAMD;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for SwapchainDisplayNativeHdrCreateInfoAMDBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`RefreshCycleDurationGOOGLE`].
pub struct RefreshCycleDurationGOOGLEBuilder {
    inner: RefreshCycleDurationGOOGLE,
}
impl RefreshCycleDurationGOOGLE {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> RefreshCycleDurationGOOGLEBuilder {
        RefreshCycleDurationGOOGLEBuilder {
            inner: RefreshCycleDurationGOOGLE {
                ..Default::default()
            },
        }
    }
}
impl RefreshCycleDurationGOOGLEBuilder {
    #[inline]
    pub fn refresh_duration(mut self, value: u64) -> Self {
        self.inner.refresh_duration = value;
        self
    }
}
impl core::ops::Deref for RefreshCycleDurationGOOGLEBuilder {
    type Target = RefreshCycleDurationGOOGLE;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for RefreshCycleDurationGOOGLEBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PastPresentationTimingGOOGLE`].
pub struct PastPresentationTimingGOOGLEBuilder {
    inner: PastPresentationTimingGOOGLE,
}
impl PastPresentationTimingGOOGLE {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> PastPresentationTimingGOOGLEBuilder {
        PastPresentationTimingGOOGLEBuilder {
            inner: PastPresentationTimingGOOGLE {
                ..Default::default()
            },
        }
    }
}
impl PastPresentationTimingGOOGLEBuilder {
    #[inline]
    pub fn present_id(mut self, value: u32) -> Self {
        self.inner.present_id = value;
        self
    }
    #[inline]
    pub fn desired_present_time(mut self, value: u64) -> Self {
        self.inner.desired_present_time = value;
        self
    }
    #[inline]
    pub fn actual_present_time(mut self, value: u64) -> Self {
        self.inner.actual_present_time = value;
        self
    }
    #[inline]
    pub fn earliest_present_time(mut self, value: u64) -> Self {
        self.inner.earliest_present_time = value;
        self
    }
    #[inline]
    pub fn present_margin(mut self, value: u64) -> Self {
        self.inner.present_margin = value;
        self
    }
}
impl core::ops::Deref for PastPresentationTimingGOOGLEBuilder {
    type Target = PastPresentationTimingGOOGLE;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for PastPresentationTimingGOOGLEBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PresentTimesInfoGOOGLE`] with lifetime-tied pNext safety.
pub struct PresentTimesInfoGOOGLEBuilder<'a> {
    inner: PresentTimesInfoGOOGLE,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PresentTimesInfoGOOGLE {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PresentTimesInfoGOOGLEBuilder<'a> {
        PresentTimesInfoGOOGLEBuilder {
            inner: PresentTimesInfoGOOGLE {
                s_type: StructureType::from_raw(1000092000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PresentTimesInfoGOOGLEBuilder<'a> {
    #[inline]
    pub fn swapchain_count(mut self, value: u32) -> Self {
        self.inner.swapchain_count = value;
        self
    }
    #[inline]
    pub fn times(mut self, slice: &'a [PresentTimeGOOGLE]) -> Self {
        self.inner.swapchain_count = slice.len() as u32;
        self.inner.p_times = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`PresentTimesInfoGOOGLE`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPresentTimesInfoGOOGLE>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for PresentTimesInfoGOOGLEBuilder<'a> {
    type Target = PresentTimesInfoGOOGLE;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PresentTimesInfoGOOGLEBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PresentTimeGOOGLE`].
pub struct PresentTimeGOOGLEBuilder {
    inner: PresentTimeGOOGLE,
}
impl PresentTimeGOOGLE {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> PresentTimeGOOGLEBuilder {
        PresentTimeGOOGLEBuilder {
            inner: PresentTimeGOOGLE {
                ..Default::default()
            },
        }
    }
}
impl PresentTimeGOOGLEBuilder {
    #[inline]
    pub fn present_id(mut self, value: u32) -> Self {
        self.inner.present_id = value;
        self
    }
    #[inline]
    pub fn desired_present_time(mut self, value: u64) -> Self {
        self.inner.desired_present_time = value;
        self
    }
}
impl core::ops::Deref for PresentTimeGOOGLEBuilder {
    type Target = PresentTimeGOOGLE;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for PresentTimeGOOGLEBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`IOSSurfaceCreateInfoMVK`] with lifetime-tied pNext safety.
pub struct IOSSurfaceCreateInfoMVKBuilder<'a> {
    inner: IOSSurfaceCreateInfoMVK,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl IOSSurfaceCreateInfoMVK {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> IOSSurfaceCreateInfoMVKBuilder<'a> {
        IOSSurfaceCreateInfoMVKBuilder {
            inner: IOSSurfaceCreateInfoMVK {
                s_type: StructureType::from_raw(1000122000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> IOSSurfaceCreateInfoMVKBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: IOSSurfaceCreateFlagsMVK) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn view(mut self, value: *const core::ffi::c_void) -> Self {
        self.inner.p_view = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`IOSSurfaceCreateInfoMVK`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsIOSSurfaceCreateInfoMVK>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for IOSSurfaceCreateInfoMVKBuilder<'a> {
    type Target = IOSSurfaceCreateInfoMVK;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for IOSSurfaceCreateInfoMVKBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`MacOSSurfaceCreateInfoMVK`] with lifetime-tied pNext safety.
pub struct MacOSSurfaceCreateInfoMVKBuilder<'a> {
    inner: MacOSSurfaceCreateInfoMVK,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl MacOSSurfaceCreateInfoMVK {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> MacOSSurfaceCreateInfoMVKBuilder<'a> {
        MacOSSurfaceCreateInfoMVKBuilder {
            inner: MacOSSurfaceCreateInfoMVK {
                s_type: StructureType::from_raw(1000123000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> MacOSSurfaceCreateInfoMVKBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: MacOSSurfaceCreateFlagsMVK) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn view(mut self, value: *const core::ffi::c_void) -> Self {
        self.inner.p_view = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`MacOSSurfaceCreateInfoMVK`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsMacOSSurfaceCreateInfoMVK>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for MacOSSurfaceCreateInfoMVKBuilder<'a> {
    type Target = MacOSSurfaceCreateInfoMVK;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for MacOSSurfaceCreateInfoMVKBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`MetalSurfaceCreateInfoEXT`] with lifetime-tied pNext safety.
pub struct MetalSurfaceCreateInfoEXTBuilder<'a> {
    inner: MetalSurfaceCreateInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl MetalSurfaceCreateInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> MetalSurfaceCreateInfoEXTBuilder<'a> {
        MetalSurfaceCreateInfoEXTBuilder {
            inner: MetalSurfaceCreateInfoEXT {
                s_type: StructureType::from_raw(1000217000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> MetalSurfaceCreateInfoEXTBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: MetalSurfaceCreateFlagsEXT) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn layer(mut self, value: *const core::ffi::c_void) -> Self {
        self.inner.p_layer = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`MetalSurfaceCreateInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsMetalSurfaceCreateInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for MetalSurfaceCreateInfoEXTBuilder<'a> {
    type Target = MetalSurfaceCreateInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for MetalSurfaceCreateInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ViewportWScalingNV`].
pub struct ViewportWScalingNVBuilder {
    inner: ViewportWScalingNV,
}
impl ViewportWScalingNV {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> ViewportWScalingNVBuilder {
        ViewportWScalingNVBuilder {
            inner: ViewportWScalingNV {
                ..Default::default()
            },
        }
    }
}
impl ViewportWScalingNVBuilder {
    #[inline]
    pub fn xcoeff(mut self, value: f32) -> Self {
        self.inner.xcoeff = value;
        self
    }
    #[inline]
    pub fn ycoeff(mut self, value: f32) -> Self {
        self.inner.ycoeff = value;
        self
    }
}
impl core::ops::Deref for ViewportWScalingNVBuilder {
    type Target = ViewportWScalingNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for ViewportWScalingNVBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PipelineViewportWScalingStateCreateInfoNV`] with lifetime-tied pNext safety.
pub struct PipelineViewportWScalingStateCreateInfoNVBuilder<'a> {
    inner: PipelineViewportWScalingStateCreateInfoNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PipelineViewportWScalingStateCreateInfoNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PipelineViewportWScalingStateCreateInfoNVBuilder<'a> {
        PipelineViewportWScalingStateCreateInfoNVBuilder {
            inner: PipelineViewportWScalingStateCreateInfoNV {
                s_type: StructureType::from_raw(1000087000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PipelineViewportWScalingStateCreateInfoNVBuilder<'a> {
    #[inline]
    pub fn viewport_w_scaling_enable(mut self, value: bool) -> Self {
        self.inner.viewport_w_scaling_enable = value as u32;
        self
    }
    #[inline]
    pub fn viewport_count(mut self, value: u32) -> Self {
        self.inner.viewport_count = value;
        self
    }
    #[inline]
    pub fn viewport_w_scalings(mut self, slice: &'a [ViewportWScalingNV]) -> Self {
        self.inner.viewport_count = slice.len() as u32;
        self.inner.p_viewport_w_scalings = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`PipelineViewportWScalingStateCreateInfoNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPipelineViewportWScalingStateCreateInfoNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for PipelineViewportWScalingStateCreateInfoNVBuilder<'a> {
    type Target = PipelineViewportWScalingStateCreateInfoNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PipelineViewportWScalingStateCreateInfoNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ViewportSwizzleNV`].
pub struct ViewportSwizzleNVBuilder {
    inner: ViewportSwizzleNV,
}
impl ViewportSwizzleNV {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> ViewportSwizzleNVBuilder {
        ViewportSwizzleNVBuilder {
            inner: ViewportSwizzleNV {
                ..Default::default()
            },
        }
    }
}
impl ViewportSwizzleNVBuilder {
    #[inline]
    pub fn x(mut self, value: ViewportCoordinateSwizzleNV) -> Self {
        self.inner.x = value;
        self
    }
    #[inline]
    pub fn y(mut self, value: ViewportCoordinateSwizzleNV) -> Self {
        self.inner.y = value;
        self
    }
    #[inline]
    pub fn z(mut self, value: ViewportCoordinateSwizzleNV) -> Self {
        self.inner.z = value;
        self
    }
    #[inline]
    pub fn w(mut self, value: ViewportCoordinateSwizzleNV) -> Self {
        self.inner.w = value;
        self
    }
}
impl core::ops::Deref for ViewportSwizzleNVBuilder {
    type Target = ViewportSwizzleNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for ViewportSwizzleNVBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PipelineViewportSwizzleStateCreateInfoNV`] with lifetime-tied pNext safety.
pub struct PipelineViewportSwizzleStateCreateInfoNVBuilder<'a> {
    inner: PipelineViewportSwizzleStateCreateInfoNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PipelineViewportSwizzleStateCreateInfoNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PipelineViewportSwizzleStateCreateInfoNVBuilder<'a> {
        PipelineViewportSwizzleStateCreateInfoNVBuilder {
            inner: PipelineViewportSwizzleStateCreateInfoNV {
                s_type: StructureType::from_raw(1000098000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PipelineViewportSwizzleStateCreateInfoNVBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: PipelineViewportSwizzleStateCreateFlagsNV) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn viewport_swizzles(mut self, slice: &'a [ViewportSwizzleNV]) -> Self {
        self.inner.viewport_count = slice.len() as u32;
        self.inner.p_viewport_swizzles = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`PipelineViewportSwizzleStateCreateInfoNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPipelineViewportSwizzleStateCreateInfoNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for PipelineViewportSwizzleStateCreateInfoNVBuilder<'a> {
    type Target = PipelineViewportSwizzleStateCreateInfoNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PipelineViewportSwizzleStateCreateInfoNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceDiscardRectanglePropertiesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceDiscardRectanglePropertiesEXTBuilder<'a> {
    inner: PhysicalDeviceDiscardRectanglePropertiesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceDiscardRectanglePropertiesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceDiscardRectanglePropertiesEXTBuilder<'a> {
        PhysicalDeviceDiscardRectanglePropertiesEXTBuilder {
            inner: PhysicalDeviceDiscardRectanglePropertiesEXT {
                s_type: StructureType::from_raw(1000099000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceDiscardRectanglePropertiesEXTBuilder<'a> {
    #[inline]
    pub fn max_discard_rectangles(mut self, value: u32) -> Self {
        self.inner.max_discard_rectangles = value;
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceDiscardRectanglePropertiesEXTBuilder<'a> {
    type Target = PhysicalDeviceDiscardRectanglePropertiesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceDiscardRectanglePropertiesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PipelineDiscardRectangleStateCreateInfoEXT`] with lifetime-tied pNext safety.
pub struct PipelineDiscardRectangleStateCreateInfoEXTBuilder<'a> {
    inner: PipelineDiscardRectangleStateCreateInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PipelineDiscardRectangleStateCreateInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PipelineDiscardRectangleStateCreateInfoEXTBuilder<'a> {
        PipelineDiscardRectangleStateCreateInfoEXTBuilder {
            inner: PipelineDiscardRectangleStateCreateInfoEXT {
                s_type: StructureType::from_raw(1000099001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PipelineDiscardRectangleStateCreateInfoEXTBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: PipelineDiscardRectangleStateCreateFlagsEXT) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn discard_rectangle_mode(mut self, value: DiscardRectangleModeEXT) -> Self {
        self.inner.discard_rectangle_mode = value;
        self
    }
    #[inline]
    pub fn discard_rectangles(mut self, slice: &'a [Rect2D]) -> Self {
        self.inner.discard_rectangle_count = slice.len() as u32;
        self.inner.p_discard_rectangles = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`PipelineDiscardRectangleStateCreateInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPipelineDiscardRectangleStateCreateInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for PipelineDiscardRectangleStateCreateInfoEXTBuilder<'a> {
    type Target = PipelineDiscardRectangleStateCreateInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PipelineDiscardRectangleStateCreateInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceMultiviewPerViewAttributesPropertiesNVXBuilder<'a> {
    inner: PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceMultiviewPerViewAttributesPropertiesNVXBuilder<
        'a,
    > {
        PhysicalDeviceMultiviewPerViewAttributesPropertiesNVXBuilder {
            inner: PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX {
                s_type: StructureType::from_raw(1000097000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceMultiviewPerViewAttributesPropertiesNVXBuilder<'a> {
    #[inline]
    pub fn per_view_position_all_components(mut self, value: bool) -> Self {
        self.inner.per_view_position_all_components = value as u32;
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDeviceMultiviewPerViewAttributesPropertiesNVXBuilder<'a> {
    type Target = PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceMultiviewPerViewAttributesPropertiesNVXBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`InputAttachmentAspectReference`].
pub struct InputAttachmentAspectReferenceBuilder {
    inner: InputAttachmentAspectReference,
}
impl InputAttachmentAspectReference {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> InputAttachmentAspectReferenceBuilder {
        InputAttachmentAspectReferenceBuilder {
            inner: InputAttachmentAspectReference {
                ..Default::default()
            },
        }
    }
}
impl InputAttachmentAspectReferenceBuilder {
    #[inline]
    pub fn subpass(mut self, value: u32) -> Self {
        self.inner.subpass = value;
        self
    }
    #[inline]
    pub fn input_attachment_index(mut self, value: u32) -> Self {
        self.inner.input_attachment_index = value;
        self
    }
    #[inline]
    pub fn aspect_mask(mut self, value: ImageAspectFlags) -> Self {
        self.inner.aspect_mask = value;
        self
    }
}
impl core::ops::Deref for InputAttachmentAspectReferenceBuilder {
    type Target = InputAttachmentAspectReference;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for InputAttachmentAspectReferenceBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`RenderPassInputAttachmentAspectCreateInfo`] with lifetime-tied pNext safety.
pub struct RenderPassInputAttachmentAspectCreateInfoBuilder<'a> {
    inner: RenderPassInputAttachmentAspectCreateInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl RenderPassInputAttachmentAspectCreateInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> RenderPassInputAttachmentAspectCreateInfoBuilder<'a> {
        RenderPassInputAttachmentAspectCreateInfoBuilder {
            inner: RenderPassInputAttachmentAspectCreateInfo {
                s_type: StructureType::from_raw(1000117001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> RenderPassInputAttachmentAspectCreateInfoBuilder<'a> {
    #[inline]
    pub fn aspect_references(
        mut self,
        slice: &'a [InputAttachmentAspectReference],
    ) -> Self {
        self.inner.aspect_reference_count = slice.len() as u32;
        self.inner.p_aspect_references = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`RenderPassInputAttachmentAspectCreateInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsRenderPassInputAttachmentAspectCreateInfo>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for RenderPassInputAttachmentAspectCreateInfoBuilder<'a> {
    type Target = RenderPassInputAttachmentAspectCreateInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for RenderPassInputAttachmentAspectCreateInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceSurfaceInfo2KHR`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceSurfaceInfo2KHRBuilder<'a> {
    inner: PhysicalDeviceSurfaceInfo2KHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceSurfaceInfo2KHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceSurfaceInfo2KHRBuilder<'a> {
        PhysicalDeviceSurfaceInfo2KHRBuilder {
            inner: PhysicalDeviceSurfaceInfo2KHR {
                s_type: StructureType::from_raw(1000119000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceSurfaceInfo2KHRBuilder<'a> {
    #[inline]
    pub fn surface(mut self, value: SurfaceKHR) -> Self {
        self.inner.surface = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceSurfaceInfo2KHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceSurfaceInfo2KHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceSurfaceInfo2KHRBuilder<'a> {
    type Target = PhysicalDeviceSurfaceInfo2KHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceSurfaceInfo2KHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`SurfaceCapabilities2KHR`] with lifetime-tied pNext safety.
pub struct SurfaceCapabilities2KHRBuilder<'a> {
    inner: SurfaceCapabilities2KHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl SurfaceCapabilities2KHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> SurfaceCapabilities2KHRBuilder<'a> {
        SurfaceCapabilities2KHRBuilder {
            inner: SurfaceCapabilities2KHR {
                s_type: StructureType::from_raw(1000119001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> SurfaceCapabilities2KHRBuilder<'a> {
    #[inline]
    pub fn surface_capabilities(mut self, value: SurfaceCapabilitiesKHR) -> Self {
        self.inner.surface_capabilities = value;
        self
    }
}
impl<'a> core::ops::Deref for SurfaceCapabilities2KHRBuilder<'a> {
    type Target = SurfaceCapabilities2KHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for SurfaceCapabilities2KHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`SurfaceFormat2KHR`] with lifetime-tied pNext safety.
pub struct SurfaceFormat2KHRBuilder<'a> {
    inner: SurfaceFormat2KHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl SurfaceFormat2KHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> SurfaceFormat2KHRBuilder<'a> {
        SurfaceFormat2KHRBuilder {
            inner: SurfaceFormat2KHR {
                s_type: StructureType::from_raw(1000119002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> SurfaceFormat2KHRBuilder<'a> {
    #[inline]
    pub fn surface_format(mut self, value: SurfaceFormatKHR) -> Self {
        self.inner.surface_format = value;
        self
    }
}
impl<'a> core::ops::Deref for SurfaceFormat2KHRBuilder<'a> {
    type Target = SurfaceFormat2KHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for SurfaceFormat2KHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DisplayProperties2KHR`] with lifetime-tied pNext safety.
pub struct DisplayProperties2KHRBuilder<'a> {
    inner: DisplayProperties2KHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DisplayProperties2KHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> DisplayProperties2KHRBuilder<'a> {
        DisplayProperties2KHRBuilder {
            inner: DisplayProperties2KHR {
                s_type: StructureType::from_raw(1000121000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DisplayProperties2KHRBuilder<'a> {
    #[inline]
    pub fn display_properties(mut self, value: DisplayPropertiesKHR) -> Self {
        self.inner.display_properties = value;
        self
    }
}
impl<'a> core::ops::Deref for DisplayProperties2KHRBuilder<'a> {
    type Target = DisplayProperties2KHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for DisplayProperties2KHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DisplayPlaneProperties2KHR`] with lifetime-tied pNext safety.
pub struct DisplayPlaneProperties2KHRBuilder<'a> {
    inner: DisplayPlaneProperties2KHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DisplayPlaneProperties2KHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> DisplayPlaneProperties2KHRBuilder<'a> {
        DisplayPlaneProperties2KHRBuilder {
            inner: DisplayPlaneProperties2KHR {
                s_type: StructureType::from_raw(1000121001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DisplayPlaneProperties2KHRBuilder<'a> {
    #[inline]
    pub fn display_plane_properties(mut self, value: DisplayPlanePropertiesKHR) -> Self {
        self.inner.display_plane_properties = value;
        self
    }
}
impl<'a> core::ops::Deref for DisplayPlaneProperties2KHRBuilder<'a> {
    type Target = DisplayPlaneProperties2KHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for DisplayPlaneProperties2KHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DisplayModeProperties2KHR`] with lifetime-tied pNext safety.
pub struct DisplayModeProperties2KHRBuilder<'a> {
    inner: DisplayModeProperties2KHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DisplayModeProperties2KHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> DisplayModeProperties2KHRBuilder<'a> {
        DisplayModeProperties2KHRBuilder {
            inner: DisplayModeProperties2KHR {
                s_type: StructureType::from_raw(1000121002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DisplayModeProperties2KHRBuilder<'a> {
    #[inline]
    pub fn display_mode_properties(mut self, value: DisplayModePropertiesKHR) -> Self {
        self.inner.display_mode_properties = value;
        self
    }
}
impl<'a> core::ops::Deref for DisplayModeProperties2KHRBuilder<'a> {
    type Target = DisplayModeProperties2KHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for DisplayModeProperties2KHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DisplayModeStereoPropertiesNV`] with lifetime-tied pNext safety.
pub struct DisplayModeStereoPropertiesNVBuilder<'a> {
    inner: DisplayModeStereoPropertiesNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DisplayModeStereoPropertiesNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> DisplayModeStereoPropertiesNVBuilder<'a> {
        DisplayModeStereoPropertiesNVBuilder {
            inner: DisplayModeStereoPropertiesNV {
                s_type: StructureType::from_raw(1000551001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DisplayModeStereoPropertiesNVBuilder<'a> {
    #[inline]
    pub fn hdmi3_d_supported(mut self, value: bool) -> Self {
        self.inner.hdmi3_d_supported = value as u32;
        self
    }
}
impl<'a> core::ops::Deref for DisplayModeStereoPropertiesNVBuilder<'a> {
    type Target = DisplayModeStereoPropertiesNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for DisplayModeStereoPropertiesNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DisplayPlaneInfo2KHR`] with lifetime-tied pNext safety.
pub struct DisplayPlaneInfo2KHRBuilder<'a> {
    inner: DisplayPlaneInfo2KHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DisplayPlaneInfo2KHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> DisplayPlaneInfo2KHRBuilder<'a> {
        DisplayPlaneInfo2KHRBuilder {
            inner: DisplayPlaneInfo2KHR {
                s_type: StructureType::from_raw(1000121003i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DisplayPlaneInfo2KHRBuilder<'a> {
    #[inline]
    pub fn mode(mut self, value: DisplayModeKHR) -> Self {
        self.inner.mode = value;
        self
    }
    #[inline]
    pub fn plane_index(mut self, value: u32) -> Self {
        self.inner.plane_index = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`DisplayPlaneInfo2KHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsDisplayPlaneInfo2KHR>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for DisplayPlaneInfo2KHRBuilder<'a> {
    type Target = DisplayPlaneInfo2KHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for DisplayPlaneInfo2KHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DisplayPlaneCapabilities2KHR`] with lifetime-tied pNext safety.
pub struct DisplayPlaneCapabilities2KHRBuilder<'a> {
    inner: DisplayPlaneCapabilities2KHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DisplayPlaneCapabilities2KHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> DisplayPlaneCapabilities2KHRBuilder<'a> {
        DisplayPlaneCapabilities2KHRBuilder {
            inner: DisplayPlaneCapabilities2KHR {
                s_type: StructureType::from_raw(1000121004i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DisplayPlaneCapabilities2KHRBuilder<'a> {
    #[inline]
    pub fn capabilities(mut self, value: DisplayPlaneCapabilitiesKHR) -> Self {
        self.inner.capabilities = value;
        self
    }
}
impl<'a> core::ops::Deref for DisplayPlaneCapabilities2KHRBuilder<'a> {
    type Target = DisplayPlaneCapabilities2KHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for DisplayPlaneCapabilities2KHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`SharedPresentSurfaceCapabilitiesKHR`] with lifetime-tied pNext safety.
pub struct SharedPresentSurfaceCapabilitiesKHRBuilder<'a> {
    inner: SharedPresentSurfaceCapabilitiesKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl SharedPresentSurfaceCapabilitiesKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> SharedPresentSurfaceCapabilitiesKHRBuilder<'a> {
        SharedPresentSurfaceCapabilitiesKHRBuilder {
            inner: SharedPresentSurfaceCapabilitiesKHR {
                s_type: StructureType::from_raw(1000111000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> SharedPresentSurfaceCapabilitiesKHRBuilder<'a> {
    #[inline]
    pub fn shared_present_supported_usage_flags(
        mut self,
        value: ImageUsageFlags,
    ) -> Self {
        self.inner.shared_present_supported_usage_flags = value;
        self
    }
}
impl<'a> core::ops::Deref for SharedPresentSurfaceCapabilitiesKHRBuilder<'a> {
    type Target = SharedPresentSurfaceCapabilitiesKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for SharedPresentSurfaceCapabilitiesKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDevice16BitStorageFeatures`] with lifetime-tied pNext safety.
pub struct PhysicalDevice16BitStorageFeaturesBuilder<'a> {
    inner: PhysicalDevice16BitStorageFeatures,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDevice16BitStorageFeatures {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDevice16BitStorageFeaturesBuilder<'a> {
        PhysicalDevice16BitStorageFeaturesBuilder {
            inner: PhysicalDevice16BitStorageFeatures {
                s_type: StructureType::from_raw(1000083000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDevice16BitStorageFeaturesBuilder<'a> {
    #[inline]
    pub fn storage_buffer16_bit_access(mut self, value: bool) -> Self {
        self.inner.storage_buffer16_bit_access = value as u32;
        self
    }
    #[inline]
    pub fn uniform_and_storage_buffer16_bit_access(mut self, value: bool) -> Self {
        self.inner.uniform_and_storage_buffer16_bit_access = value as u32;
        self
    }
    #[inline]
    pub fn storage_push_constant16(mut self, value: bool) -> Self {
        self.inner.storage_push_constant16 = value as u32;
        self
    }
    #[inline]
    pub fn storage_input_output16(mut self, value: bool) -> Self {
        self.inner.storage_input_output16 = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDevice16BitStorageFeatures`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDevice16BitStorageFeatures>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDevice16BitStorageFeaturesBuilder<'a> {
    type Target = PhysicalDevice16BitStorageFeatures;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDevice16BitStorageFeaturesBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceSubgroupProperties`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceSubgroupPropertiesBuilder<'a> {
    inner: PhysicalDeviceSubgroupProperties,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceSubgroupProperties {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceSubgroupPropertiesBuilder<'a> {
        PhysicalDeviceSubgroupPropertiesBuilder {
            inner: PhysicalDeviceSubgroupProperties {
                s_type: StructureType::from_raw(1000094000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceSubgroupPropertiesBuilder<'a> {
    #[inline]
    pub fn subgroup_size(mut self, value: u32) -> Self {
        self.inner.subgroup_size = value;
        self
    }
    #[inline]
    pub fn supported_stages(mut self, value: ShaderStageFlags) -> Self {
        self.inner.supported_stages = value;
        self
    }
    #[inline]
    pub fn supported_operations(mut self, value: SubgroupFeatureFlags) -> Self {
        self.inner.supported_operations = value;
        self
    }
    #[inline]
    pub fn quad_operations_in_all_stages(mut self, value: bool) -> Self {
        self.inner.quad_operations_in_all_stages = value as u32;
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceSubgroupPropertiesBuilder<'a> {
    type Target = PhysicalDeviceSubgroupProperties;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceSubgroupPropertiesBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceShaderSubgroupExtendedTypesFeatures`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceShaderSubgroupExtendedTypesFeaturesBuilder<'a> {
    inner: PhysicalDeviceShaderSubgroupExtendedTypesFeatures,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceShaderSubgroupExtendedTypesFeatures {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceShaderSubgroupExtendedTypesFeaturesBuilder<
        'a,
    > {
        PhysicalDeviceShaderSubgroupExtendedTypesFeaturesBuilder {
            inner: PhysicalDeviceShaderSubgroupExtendedTypesFeatures {
                s_type: StructureType::from_raw(1000175000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceShaderSubgroupExtendedTypesFeaturesBuilder<'a> {
    #[inline]
    pub fn shader_subgroup_extended_types(mut self, value: bool) -> Self {
        self.inner.shader_subgroup_extended_types = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceShaderSubgroupExtendedTypesFeatures`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceShaderSubgroupExtendedTypesFeatures>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDeviceShaderSubgroupExtendedTypesFeaturesBuilder<'a> {
    type Target = PhysicalDeviceShaderSubgroupExtendedTypesFeatures;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceShaderSubgroupExtendedTypesFeaturesBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`BufferMemoryRequirementsInfo2`] with lifetime-tied pNext safety.
pub struct BufferMemoryRequirementsInfo2Builder<'a> {
    inner: BufferMemoryRequirementsInfo2,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl BufferMemoryRequirementsInfo2 {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> BufferMemoryRequirementsInfo2Builder<'a> {
        BufferMemoryRequirementsInfo2Builder {
            inner: BufferMemoryRequirementsInfo2 {
                s_type: StructureType::from_raw(1000146000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> BufferMemoryRequirementsInfo2Builder<'a> {
    #[inline]
    pub fn buffer(mut self, value: Buffer) -> Self {
        self.inner.buffer = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`BufferMemoryRequirementsInfo2`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsBufferMemoryRequirementsInfo2>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for BufferMemoryRequirementsInfo2Builder<'a> {
    type Target = BufferMemoryRequirementsInfo2;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for BufferMemoryRequirementsInfo2Builder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DeviceBufferMemoryRequirements`] with lifetime-tied pNext safety.
pub struct DeviceBufferMemoryRequirementsBuilder<'a> {
    inner: DeviceBufferMemoryRequirements,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DeviceBufferMemoryRequirements {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> DeviceBufferMemoryRequirementsBuilder<'a> {
        DeviceBufferMemoryRequirementsBuilder {
            inner: DeviceBufferMemoryRequirements {
                s_type: StructureType::from_raw(1000413002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DeviceBufferMemoryRequirementsBuilder<'a> {
    #[inline]
    pub fn create_info(mut self, value: &'a BufferCreateInfo) -> Self {
        self.inner.p_create_info = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`DeviceBufferMemoryRequirements`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsDeviceBufferMemoryRequirements>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for DeviceBufferMemoryRequirementsBuilder<'a> {
    type Target = DeviceBufferMemoryRequirements;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for DeviceBufferMemoryRequirementsBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ImageMemoryRequirementsInfo2`] with lifetime-tied pNext safety.
pub struct ImageMemoryRequirementsInfo2Builder<'a> {
    inner: ImageMemoryRequirementsInfo2,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ImageMemoryRequirementsInfo2 {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ImageMemoryRequirementsInfo2Builder<'a> {
        ImageMemoryRequirementsInfo2Builder {
            inner: ImageMemoryRequirementsInfo2 {
                s_type: StructureType::from_raw(1000146001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ImageMemoryRequirementsInfo2Builder<'a> {
    #[inline]
    pub fn image(mut self, value: Image) -> Self {
        self.inner.image = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`ImageMemoryRequirementsInfo2`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsImageMemoryRequirementsInfo2>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for ImageMemoryRequirementsInfo2Builder<'a> {
    type Target = ImageMemoryRequirementsInfo2;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ImageMemoryRequirementsInfo2Builder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ImageSparseMemoryRequirementsInfo2`] with lifetime-tied pNext safety.
pub struct ImageSparseMemoryRequirementsInfo2Builder<'a> {
    inner: ImageSparseMemoryRequirementsInfo2,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ImageSparseMemoryRequirementsInfo2 {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ImageSparseMemoryRequirementsInfo2Builder<'a> {
        ImageSparseMemoryRequirementsInfo2Builder {
            inner: ImageSparseMemoryRequirementsInfo2 {
                s_type: StructureType::from_raw(1000146002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ImageSparseMemoryRequirementsInfo2Builder<'a> {
    #[inline]
    pub fn image(mut self, value: Image) -> Self {
        self.inner.image = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`ImageSparseMemoryRequirementsInfo2`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsImageSparseMemoryRequirementsInfo2>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for ImageSparseMemoryRequirementsInfo2Builder<'a> {
    type Target = ImageSparseMemoryRequirementsInfo2;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ImageSparseMemoryRequirementsInfo2Builder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DeviceImageMemoryRequirements`] with lifetime-tied pNext safety.
pub struct DeviceImageMemoryRequirementsBuilder<'a> {
    inner: DeviceImageMemoryRequirements,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DeviceImageMemoryRequirements {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> DeviceImageMemoryRequirementsBuilder<'a> {
        DeviceImageMemoryRequirementsBuilder {
            inner: DeviceImageMemoryRequirements {
                s_type: StructureType::from_raw(1000413003i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DeviceImageMemoryRequirementsBuilder<'a> {
    #[inline]
    pub fn create_info(mut self, value: &'a ImageCreateInfo) -> Self {
        self.inner.p_create_info = value;
        self
    }
    #[inline]
    pub fn plane_aspect(mut self, value: ImageAspectFlagBits) -> Self {
        self.inner.plane_aspect = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`DeviceImageMemoryRequirements`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsDeviceImageMemoryRequirements>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for DeviceImageMemoryRequirementsBuilder<'a> {
    type Target = DeviceImageMemoryRequirements;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for DeviceImageMemoryRequirementsBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`MemoryRequirements2`] with lifetime-tied pNext safety.
pub struct MemoryRequirements2Builder<'a> {
    inner: MemoryRequirements2,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl MemoryRequirements2 {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> MemoryRequirements2Builder<'a> {
        MemoryRequirements2Builder {
            inner: MemoryRequirements2 {
                s_type: StructureType::from_raw(1000146003i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> MemoryRequirements2Builder<'a> {
    #[inline]
    pub fn memory_requirements(mut self, value: MemoryRequirements) -> Self {
        self.inner.memory_requirements = value;
        self
    }
}
impl<'a> core::ops::Deref for MemoryRequirements2Builder<'a> {
    type Target = MemoryRequirements2;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for MemoryRequirements2Builder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`SparseImageMemoryRequirements2`] with lifetime-tied pNext safety.
pub struct SparseImageMemoryRequirements2Builder<'a> {
    inner: SparseImageMemoryRequirements2,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl SparseImageMemoryRequirements2 {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> SparseImageMemoryRequirements2Builder<'a> {
        SparseImageMemoryRequirements2Builder {
            inner: SparseImageMemoryRequirements2 {
                s_type: StructureType::from_raw(1000146004i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> SparseImageMemoryRequirements2Builder<'a> {
    #[inline]
    pub fn memory_requirements(mut self, value: SparseImageMemoryRequirements) -> Self {
        self.inner.memory_requirements = value;
        self
    }
}
impl<'a> core::ops::Deref for SparseImageMemoryRequirements2Builder<'a> {
    type Target = SparseImageMemoryRequirements2;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for SparseImageMemoryRequirements2Builder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDevicePointClippingProperties`] with lifetime-tied pNext safety.
pub struct PhysicalDevicePointClippingPropertiesBuilder<'a> {
    inner: PhysicalDevicePointClippingProperties,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDevicePointClippingProperties {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDevicePointClippingPropertiesBuilder<'a> {
        PhysicalDevicePointClippingPropertiesBuilder {
            inner: PhysicalDevicePointClippingProperties {
                s_type: StructureType::from_raw(1000117000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDevicePointClippingPropertiesBuilder<'a> {
    #[inline]
    pub fn point_clipping_behavior(mut self, value: PointClippingBehavior) -> Self {
        self.inner.point_clipping_behavior = value;
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDevicePointClippingPropertiesBuilder<'a> {
    type Target = PhysicalDevicePointClippingProperties;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDevicePointClippingPropertiesBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`MemoryDedicatedRequirements`] with lifetime-tied pNext safety.
pub struct MemoryDedicatedRequirementsBuilder<'a> {
    inner: MemoryDedicatedRequirements,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl MemoryDedicatedRequirements {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> MemoryDedicatedRequirementsBuilder<'a> {
        MemoryDedicatedRequirementsBuilder {
            inner: MemoryDedicatedRequirements {
                s_type: StructureType::from_raw(1000127000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> MemoryDedicatedRequirementsBuilder<'a> {
    #[inline]
    pub fn prefers_dedicated_allocation(mut self, value: bool) -> Self {
        self.inner.prefers_dedicated_allocation = value as u32;
        self
    }
    #[inline]
    pub fn requires_dedicated_allocation(mut self, value: bool) -> Self {
        self.inner.requires_dedicated_allocation = value as u32;
        self
    }
}
impl<'a> core::ops::Deref for MemoryDedicatedRequirementsBuilder<'a> {
    type Target = MemoryDedicatedRequirements;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for MemoryDedicatedRequirementsBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`MemoryDedicatedAllocateInfo`] with lifetime-tied pNext safety.
pub struct MemoryDedicatedAllocateInfoBuilder<'a> {
    inner: MemoryDedicatedAllocateInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl MemoryDedicatedAllocateInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> MemoryDedicatedAllocateInfoBuilder<'a> {
        MemoryDedicatedAllocateInfoBuilder {
            inner: MemoryDedicatedAllocateInfo {
                s_type: StructureType::from_raw(1000127001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> MemoryDedicatedAllocateInfoBuilder<'a> {
    #[inline]
    pub fn image(mut self, value: Image) -> Self {
        self.inner.image = value;
        self
    }
    #[inline]
    pub fn buffer(mut self, value: Buffer) -> Self {
        self.inner.buffer = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`MemoryDedicatedAllocateInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsMemoryDedicatedAllocateInfo>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for MemoryDedicatedAllocateInfoBuilder<'a> {
    type Target = MemoryDedicatedAllocateInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for MemoryDedicatedAllocateInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ImageViewUsageCreateInfo`] with lifetime-tied pNext safety.
pub struct ImageViewUsageCreateInfoBuilder<'a> {
    inner: ImageViewUsageCreateInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ImageViewUsageCreateInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ImageViewUsageCreateInfoBuilder<'a> {
        ImageViewUsageCreateInfoBuilder {
            inner: ImageViewUsageCreateInfo {
                s_type: StructureType::from_raw(1000117002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ImageViewUsageCreateInfoBuilder<'a> {
    #[inline]
    pub fn usage(mut self, value: ImageUsageFlags) -> Self {
        self.inner.usage = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`ImageViewUsageCreateInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsImageViewUsageCreateInfo>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for ImageViewUsageCreateInfoBuilder<'a> {
    type Target = ImageViewUsageCreateInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ImageViewUsageCreateInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ImageViewSlicedCreateInfoEXT`] with lifetime-tied pNext safety.
pub struct ImageViewSlicedCreateInfoEXTBuilder<'a> {
    inner: ImageViewSlicedCreateInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ImageViewSlicedCreateInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ImageViewSlicedCreateInfoEXTBuilder<'a> {
        ImageViewSlicedCreateInfoEXTBuilder {
            inner: ImageViewSlicedCreateInfoEXT {
                s_type: StructureType::from_raw(1000418001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ImageViewSlicedCreateInfoEXTBuilder<'a> {
    #[inline]
    pub fn slice_offset(mut self, value: u32) -> Self {
        self.inner.slice_offset = value;
        self
    }
    #[inline]
    pub fn slice_count(mut self, value: u32) -> Self {
        self.inner.slice_count = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`ImageViewSlicedCreateInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsImageViewSlicedCreateInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for ImageViewSlicedCreateInfoEXTBuilder<'a> {
    type Target = ImageViewSlicedCreateInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ImageViewSlicedCreateInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PipelineTessellationDomainOriginStateCreateInfo`] with lifetime-tied pNext safety.
pub struct PipelineTessellationDomainOriginStateCreateInfoBuilder<'a> {
    inner: PipelineTessellationDomainOriginStateCreateInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PipelineTessellationDomainOriginStateCreateInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PipelineTessellationDomainOriginStateCreateInfoBuilder<'a> {
        PipelineTessellationDomainOriginStateCreateInfoBuilder {
            inner: PipelineTessellationDomainOriginStateCreateInfo {
                s_type: StructureType::from_raw(1000117003i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PipelineTessellationDomainOriginStateCreateInfoBuilder<'a> {
    #[inline]
    pub fn domain_origin(mut self, value: TessellationDomainOrigin) -> Self {
        self.inner.domain_origin = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PipelineTessellationDomainOriginStateCreateInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPipelineTessellationDomainOriginStateCreateInfo>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref
for PipelineTessellationDomainOriginStateCreateInfoBuilder<'a> {
    type Target = PipelineTessellationDomainOriginStateCreateInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PipelineTessellationDomainOriginStateCreateInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`SamplerYcbcrConversionInfo`] with lifetime-tied pNext safety.
pub struct SamplerYcbcrConversionInfoBuilder<'a> {
    inner: SamplerYcbcrConversionInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl SamplerYcbcrConversionInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> SamplerYcbcrConversionInfoBuilder<'a> {
        SamplerYcbcrConversionInfoBuilder {
            inner: SamplerYcbcrConversionInfo {
                s_type: StructureType::from_raw(1000156001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> SamplerYcbcrConversionInfoBuilder<'a> {
    #[inline]
    pub fn conversion(mut self, value: SamplerYcbcrConversion) -> Self {
        self.inner.conversion = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`SamplerYcbcrConversionInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsSamplerYcbcrConversionInfo>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for SamplerYcbcrConversionInfoBuilder<'a> {
    type Target = SamplerYcbcrConversionInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for SamplerYcbcrConversionInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`SamplerYcbcrConversionCreateInfo`] with lifetime-tied pNext safety.
pub struct SamplerYcbcrConversionCreateInfoBuilder<'a> {
    inner: SamplerYcbcrConversionCreateInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl SamplerYcbcrConversionCreateInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> SamplerYcbcrConversionCreateInfoBuilder<'a> {
        SamplerYcbcrConversionCreateInfoBuilder {
            inner: SamplerYcbcrConversionCreateInfo {
                s_type: StructureType::from_raw(1000156000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> SamplerYcbcrConversionCreateInfoBuilder<'a> {
    #[inline]
    pub fn format(mut self, value: Format) -> Self {
        self.inner.format = value;
        self
    }
    #[inline]
    pub fn ycbcr_model(mut self, value: SamplerYcbcrModelConversion) -> Self {
        self.inner.ycbcr_model = value;
        self
    }
    #[inline]
    pub fn ycbcr_range(mut self, value: SamplerYcbcrRange) -> Self {
        self.inner.ycbcr_range = value;
        self
    }
    #[inline]
    pub fn components(mut self, value: ComponentMapping) -> Self {
        self.inner.components = value;
        self
    }
    #[inline]
    pub fn x_chroma_offset(mut self, value: ChromaLocation) -> Self {
        self.inner.x_chroma_offset = value;
        self
    }
    #[inline]
    pub fn y_chroma_offset(mut self, value: ChromaLocation) -> Self {
        self.inner.y_chroma_offset = value;
        self
    }
    #[inline]
    pub fn chroma_filter(mut self, value: Filter) -> Self {
        self.inner.chroma_filter = value;
        self
    }
    #[inline]
    pub fn force_explicit_reconstruction(mut self, value: bool) -> Self {
        self.inner.force_explicit_reconstruction = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`SamplerYcbcrConversionCreateInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsSamplerYcbcrConversionCreateInfo>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for SamplerYcbcrConversionCreateInfoBuilder<'a> {
    type Target = SamplerYcbcrConversionCreateInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for SamplerYcbcrConversionCreateInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`BindImagePlaneMemoryInfo`] with lifetime-tied pNext safety.
pub struct BindImagePlaneMemoryInfoBuilder<'a> {
    inner: BindImagePlaneMemoryInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl BindImagePlaneMemoryInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> BindImagePlaneMemoryInfoBuilder<'a> {
        BindImagePlaneMemoryInfoBuilder {
            inner: BindImagePlaneMemoryInfo {
                s_type: StructureType::from_raw(1000156002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> BindImagePlaneMemoryInfoBuilder<'a> {
    #[inline]
    pub fn plane_aspect(mut self, value: ImageAspectFlagBits) -> Self {
        self.inner.plane_aspect = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`BindImagePlaneMemoryInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsBindImagePlaneMemoryInfo>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for BindImagePlaneMemoryInfoBuilder<'a> {
    type Target = BindImagePlaneMemoryInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for BindImagePlaneMemoryInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ImagePlaneMemoryRequirementsInfo`] with lifetime-tied pNext safety.
pub struct ImagePlaneMemoryRequirementsInfoBuilder<'a> {
    inner: ImagePlaneMemoryRequirementsInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ImagePlaneMemoryRequirementsInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ImagePlaneMemoryRequirementsInfoBuilder<'a> {
        ImagePlaneMemoryRequirementsInfoBuilder {
            inner: ImagePlaneMemoryRequirementsInfo {
                s_type: StructureType::from_raw(1000156003i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ImagePlaneMemoryRequirementsInfoBuilder<'a> {
    #[inline]
    pub fn plane_aspect(mut self, value: ImageAspectFlagBits) -> Self {
        self.inner.plane_aspect = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`ImagePlaneMemoryRequirementsInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsImagePlaneMemoryRequirementsInfo>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for ImagePlaneMemoryRequirementsInfoBuilder<'a> {
    type Target = ImagePlaneMemoryRequirementsInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ImagePlaneMemoryRequirementsInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceSamplerYcbcrConversionFeatures`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceSamplerYcbcrConversionFeaturesBuilder<'a> {
    inner: PhysicalDeviceSamplerYcbcrConversionFeatures,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceSamplerYcbcrConversionFeatures {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceSamplerYcbcrConversionFeaturesBuilder<'a> {
        PhysicalDeviceSamplerYcbcrConversionFeaturesBuilder {
            inner: PhysicalDeviceSamplerYcbcrConversionFeatures {
                s_type: StructureType::from_raw(1000156004i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceSamplerYcbcrConversionFeaturesBuilder<'a> {
    #[inline]
    pub fn sampler_ycbcr_conversion(mut self, value: bool) -> Self {
        self.inner.sampler_ycbcr_conversion = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceSamplerYcbcrConversionFeatures`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceSamplerYcbcrConversionFeatures>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceSamplerYcbcrConversionFeaturesBuilder<'a> {
    type Target = PhysicalDeviceSamplerYcbcrConversionFeatures;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceSamplerYcbcrConversionFeaturesBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`SamplerYcbcrConversionImageFormatProperties`] with lifetime-tied pNext safety.
pub struct SamplerYcbcrConversionImageFormatPropertiesBuilder<'a> {
    inner: SamplerYcbcrConversionImageFormatProperties,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl SamplerYcbcrConversionImageFormatProperties {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> SamplerYcbcrConversionImageFormatPropertiesBuilder<'a> {
        SamplerYcbcrConversionImageFormatPropertiesBuilder {
            inner: SamplerYcbcrConversionImageFormatProperties {
                s_type: StructureType::from_raw(1000156005i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> SamplerYcbcrConversionImageFormatPropertiesBuilder<'a> {
    #[inline]
    pub fn combined_image_sampler_descriptor_count(mut self, value: u32) -> Self {
        self.inner.combined_image_sampler_descriptor_count = value;
        self
    }
}
impl<'a> core::ops::Deref for SamplerYcbcrConversionImageFormatPropertiesBuilder<'a> {
    type Target = SamplerYcbcrConversionImageFormatProperties;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for SamplerYcbcrConversionImageFormatPropertiesBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`TextureLODGatherFormatPropertiesAMD`] with lifetime-tied pNext safety.
pub struct TextureLODGatherFormatPropertiesAMDBuilder<'a> {
    inner: TextureLODGatherFormatPropertiesAMD,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl TextureLODGatherFormatPropertiesAMD {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> TextureLODGatherFormatPropertiesAMDBuilder<'a> {
        TextureLODGatherFormatPropertiesAMDBuilder {
            inner: TextureLODGatherFormatPropertiesAMD {
                s_type: StructureType::from_raw(1000041000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> TextureLODGatherFormatPropertiesAMDBuilder<'a> {
    #[inline]
    pub fn supports_texture_gather_lod_bias_amd(mut self, value: bool) -> Self {
        self.inner.supports_texture_gather_lod_bias_amd = value as u32;
        self
    }
}
impl<'a> core::ops::Deref for TextureLODGatherFormatPropertiesAMDBuilder<'a> {
    type Target = TextureLODGatherFormatPropertiesAMD;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for TextureLODGatherFormatPropertiesAMDBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ConditionalRenderingBeginInfoEXT`] with lifetime-tied pNext safety.
pub struct ConditionalRenderingBeginInfoEXTBuilder<'a> {
    inner: ConditionalRenderingBeginInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ConditionalRenderingBeginInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ConditionalRenderingBeginInfoEXTBuilder<'a> {
        ConditionalRenderingBeginInfoEXTBuilder {
            inner: ConditionalRenderingBeginInfoEXT {
                s_type: StructureType::from_raw(1000081002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ConditionalRenderingBeginInfoEXTBuilder<'a> {
    #[inline]
    pub fn buffer(mut self, value: Buffer) -> Self {
        self.inner.buffer = value;
        self
    }
    #[inline]
    pub fn offset(mut self, value: u64) -> Self {
        self.inner.offset = value;
        self
    }
    #[inline]
    pub fn flags(mut self, value: ConditionalRenderingFlagsEXT) -> Self {
        self.inner.flags = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`ConditionalRenderingBeginInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsConditionalRenderingBeginInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for ConditionalRenderingBeginInfoEXTBuilder<'a> {
    type Target = ConditionalRenderingBeginInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ConditionalRenderingBeginInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ProtectedSubmitInfo`] with lifetime-tied pNext safety.
pub struct ProtectedSubmitInfoBuilder<'a> {
    inner: ProtectedSubmitInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ProtectedSubmitInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ProtectedSubmitInfoBuilder<'a> {
        ProtectedSubmitInfoBuilder {
            inner: ProtectedSubmitInfo {
                s_type: StructureType::from_raw(1000145000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ProtectedSubmitInfoBuilder<'a> {
    #[inline]
    pub fn protected_submit(mut self, value: bool) -> Self {
        self.inner.protected_submit = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`ProtectedSubmitInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsProtectedSubmitInfo>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for ProtectedSubmitInfoBuilder<'a> {
    type Target = ProtectedSubmitInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ProtectedSubmitInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceProtectedMemoryFeatures`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceProtectedMemoryFeaturesBuilder<'a> {
    inner: PhysicalDeviceProtectedMemoryFeatures,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceProtectedMemoryFeatures {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceProtectedMemoryFeaturesBuilder<'a> {
        PhysicalDeviceProtectedMemoryFeaturesBuilder {
            inner: PhysicalDeviceProtectedMemoryFeatures {
                s_type: StructureType::from_raw(1000145001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceProtectedMemoryFeaturesBuilder<'a> {
    #[inline]
    pub fn protected_memory(mut self, value: bool) -> Self {
        self.inner.protected_memory = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceProtectedMemoryFeatures`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceProtectedMemoryFeatures>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceProtectedMemoryFeaturesBuilder<'a> {
    type Target = PhysicalDeviceProtectedMemoryFeatures;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceProtectedMemoryFeaturesBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceProtectedMemoryProperties`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceProtectedMemoryPropertiesBuilder<'a> {
    inner: PhysicalDeviceProtectedMemoryProperties,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceProtectedMemoryProperties {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceProtectedMemoryPropertiesBuilder<'a> {
        PhysicalDeviceProtectedMemoryPropertiesBuilder {
            inner: PhysicalDeviceProtectedMemoryProperties {
                s_type: StructureType::from_raw(1000145002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceProtectedMemoryPropertiesBuilder<'a> {
    #[inline]
    pub fn protected_no_fault(mut self, value: bool) -> Self {
        self.inner.protected_no_fault = value as u32;
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceProtectedMemoryPropertiesBuilder<'a> {
    type Target = PhysicalDeviceProtectedMemoryProperties;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceProtectedMemoryPropertiesBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DeviceQueueInfo2`] with lifetime-tied pNext safety.
pub struct DeviceQueueInfo2Builder<'a> {
    inner: DeviceQueueInfo2,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DeviceQueueInfo2 {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> DeviceQueueInfo2Builder<'a> {
        DeviceQueueInfo2Builder {
            inner: DeviceQueueInfo2 {
                s_type: StructureType::from_raw(1000145003i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DeviceQueueInfo2Builder<'a> {
    #[inline]
    pub fn flags(mut self, value: DeviceQueueCreateFlags) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn queue_family_index(mut self, value: u32) -> Self {
        self.inner.queue_family_index = value;
        self
    }
    #[inline]
    pub fn queue_index(mut self, value: u32) -> Self {
        self.inner.queue_index = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`DeviceQueueInfo2`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsDeviceQueueInfo2>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for DeviceQueueInfo2Builder<'a> {
    type Target = DeviceQueueInfo2;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for DeviceQueueInfo2Builder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PipelineCoverageToColorStateCreateInfoNV`] with lifetime-tied pNext safety.
pub struct PipelineCoverageToColorStateCreateInfoNVBuilder<'a> {
    inner: PipelineCoverageToColorStateCreateInfoNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PipelineCoverageToColorStateCreateInfoNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PipelineCoverageToColorStateCreateInfoNVBuilder<'a> {
        PipelineCoverageToColorStateCreateInfoNVBuilder {
            inner: PipelineCoverageToColorStateCreateInfoNV {
                s_type: StructureType::from_raw(1000149000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PipelineCoverageToColorStateCreateInfoNVBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: PipelineCoverageToColorStateCreateFlagsNV) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn coverage_to_color_enable(mut self, value: bool) -> Self {
        self.inner.coverage_to_color_enable = value as u32;
        self
    }
    #[inline]
    pub fn coverage_to_color_location(mut self, value: u32) -> Self {
        self.inner.coverage_to_color_location = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PipelineCoverageToColorStateCreateInfoNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPipelineCoverageToColorStateCreateInfoNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for PipelineCoverageToColorStateCreateInfoNVBuilder<'a> {
    type Target = PipelineCoverageToColorStateCreateInfoNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PipelineCoverageToColorStateCreateInfoNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceSamplerFilterMinmaxProperties`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceSamplerFilterMinmaxPropertiesBuilder<'a> {
    inner: PhysicalDeviceSamplerFilterMinmaxProperties,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceSamplerFilterMinmaxProperties {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceSamplerFilterMinmaxPropertiesBuilder<'a> {
        PhysicalDeviceSamplerFilterMinmaxPropertiesBuilder {
            inner: PhysicalDeviceSamplerFilterMinmaxProperties {
                s_type: StructureType::from_raw(1000130000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceSamplerFilterMinmaxPropertiesBuilder<'a> {
    #[inline]
    pub fn filter_minmax_single_component_formats(mut self, value: bool) -> Self {
        self.inner.filter_minmax_single_component_formats = value as u32;
        self
    }
    #[inline]
    pub fn filter_minmax_image_component_mapping(mut self, value: bool) -> Self {
        self.inner.filter_minmax_image_component_mapping = value as u32;
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceSamplerFilterMinmaxPropertiesBuilder<'a> {
    type Target = PhysicalDeviceSamplerFilterMinmaxProperties;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceSamplerFilterMinmaxPropertiesBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`SampleLocationEXT`].
pub struct SampleLocationEXTBuilder {
    inner: SampleLocationEXT,
}
impl SampleLocationEXT {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> SampleLocationEXTBuilder {
        SampleLocationEXTBuilder {
            inner: SampleLocationEXT {
                ..Default::default()
            },
        }
    }
}
impl SampleLocationEXTBuilder {
    #[inline]
    pub fn x(mut self, value: f32) -> Self {
        self.inner.x = value;
        self
    }
    #[inline]
    pub fn y(mut self, value: f32) -> Self {
        self.inner.y = value;
        self
    }
}
impl core::ops::Deref for SampleLocationEXTBuilder {
    type Target = SampleLocationEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for SampleLocationEXTBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`SampleLocationsInfoEXT`] with lifetime-tied pNext safety.
pub struct SampleLocationsInfoEXTBuilder<'a> {
    inner: SampleLocationsInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl SampleLocationsInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> SampleLocationsInfoEXTBuilder<'a> {
        SampleLocationsInfoEXTBuilder {
            inner: SampleLocationsInfoEXT {
                s_type: StructureType::from_raw(1000143000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> SampleLocationsInfoEXTBuilder<'a> {
    #[inline]
    pub fn sample_locations_per_pixel(mut self, value: SampleCountFlagBits) -> Self {
        self.inner.sample_locations_per_pixel = value;
        self
    }
    #[inline]
    pub fn sample_location_grid_size(mut self, value: Extent2D) -> Self {
        self.inner.sample_location_grid_size = value;
        self
    }
    #[inline]
    pub fn sample_locations(mut self, slice: &'a [SampleLocationEXT]) -> Self {
        self.inner.sample_locations_count = slice.len() as u32;
        self.inner.p_sample_locations = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`SampleLocationsInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsSampleLocationsInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for SampleLocationsInfoEXTBuilder<'a> {
    type Target = SampleLocationsInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for SampleLocationsInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`AttachmentSampleLocationsEXT`].
pub struct AttachmentSampleLocationsEXTBuilder {
    inner: AttachmentSampleLocationsEXT,
}
impl AttachmentSampleLocationsEXT {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> AttachmentSampleLocationsEXTBuilder {
        AttachmentSampleLocationsEXTBuilder {
            inner: AttachmentSampleLocationsEXT {
                ..Default::default()
            },
        }
    }
}
impl AttachmentSampleLocationsEXTBuilder {
    #[inline]
    pub fn attachment_index(mut self, value: u32) -> Self {
        self.inner.attachment_index = value;
        self
    }
    #[inline]
    pub fn sample_locations_info(mut self, value: SampleLocationsInfoEXT) -> Self {
        self.inner.sample_locations_info = value;
        self
    }
}
impl core::ops::Deref for AttachmentSampleLocationsEXTBuilder {
    type Target = AttachmentSampleLocationsEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for AttachmentSampleLocationsEXTBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`SubpassSampleLocationsEXT`].
pub struct SubpassSampleLocationsEXTBuilder {
    inner: SubpassSampleLocationsEXT,
}
impl SubpassSampleLocationsEXT {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> SubpassSampleLocationsEXTBuilder {
        SubpassSampleLocationsEXTBuilder {
            inner: SubpassSampleLocationsEXT {
                ..Default::default()
            },
        }
    }
}
impl SubpassSampleLocationsEXTBuilder {
    #[inline]
    pub fn subpass_index(mut self, value: u32) -> Self {
        self.inner.subpass_index = value;
        self
    }
    #[inline]
    pub fn sample_locations_info(mut self, value: SampleLocationsInfoEXT) -> Self {
        self.inner.sample_locations_info = value;
        self
    }
}
impl core::ops::Deref for SubpassSampleLocationsEXTBuilder {
    type Target = SubpassSampleLocationsEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for SubpassSampleLocationsEXTBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`RenderPassSampleLocationsBeginInfoEXT`] with lifetime-tied pNext safety.
pub struct RenderPassSampleLocationsBeginInfoEXTBuilder<'a> {
    inner: RenderPassSampleLocationsBeginInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl RenderPassSampleLocationsBeginInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> RenderPassSampleLocationsBeginInfoEXTBuilder<'a> {
        RenderPassSampleLocationsBeginInfoEXTBuilder {
            inner: RenderPassSampleLocationsBeginInfoEXT {
                s_type: StructureType::from_raw(1000143001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> RenderPassSampleLocationsBeginInfoEXTBuilder<'a> {
    #[inline]
    pub fn attachment_initial_sample_locations(
        mut self,
        slice: &'a [AttachmentSampleLocationsEXT],
    ) -> Self {
        self.inner.attachment_initial_sample_locations_count = slice.len() as u32;
        self.inner.p_attachment_initial_sample_locations = slice.as_ptr();
        self
    }
    #[inline]
    pub fn post_subpass_sample_locations(
        mut self,
        slice: &'a [SubpassSampleLocationsEXT],
    ) -> Self {
        self.inner.post_subpass_sample_locations_count = slice.len() as u32;
        self.inner.p_post_subpass_sample_locations = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`RenderPassSampleLocationsBeginInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsRenderPassSampleLocationsBeginInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for RenderPassSampleLocationsBeginInfoEXTBuilder<'a> {
    type Target = RenderPassSampleLocationsBeginInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for RenderPassSampleLocationsBeginInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PipelineSampleLocationsStateCreateInfoEXT`] with lifetime-tied pNext safety.
pub struct PipelineSampleLocationsStateCreateInfoEXTBuilder<'a> {
    inner: PipelineSampleLocationsStateCreateInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PipelineSampleLocationsStateCreateInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PipelineSampleLocationsStateCreateInfoEXTBuilder<'a> {
        PipelineSampleLocationsStateCreateInfoEXTBuilder {
            inner: PipelineSampleLocationsStateCreateInfoEXT {
                s_type: StructureType::from_raw(1000143002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PipelineSampleLocationsStateCreateInfoEXTBuilder<'a> {
    #[inline]
    pub fn sample_locations_enable(mut self, value: bool) -> Self {
        self.inner.sample_locations_enable = value as u32;
        self
    }
    #[inline]
    pub fn sample_locations_info(mut self, value: SampleLocationsInfoEXT) -> Self {
        self.inner.sample_locations_info = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PipelineSampleLocationsStateCreateInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPipelineSampleLocationsStateCreateInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for PipelineSampleLocationsStateCreateInfoEXTBuilder<'a> {
    type Target = PipelineSampleLocationsStateCreateInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PipelineSampleLocationsStateCreateInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceSampleLocationsPropertiesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceSampleLocationsPropertiesEXTBuilder<'a> {
    inner: PhysicalDeviceSampleLocationsPropertiesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceSampleLocationsPropertiesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceSampleLocationsPropertiesEXTBuilder<'a> {
        PhysicalDeviceSampleLocationsPropertiesEXTBuilder {
            inner: PhysicalDeviceSampleLocationsPropertiesEXT {
                s_type: StructureType::from_raw(1000143003i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceSampleLocationsPropertiesEXTBuilder<'a> {
    #[inline]
    pub fn sample_location_sample_counts(mut self, value: SampleCountFlags) -> Self {
        self.inner.sample_location_sample_counts = value;
        self
    }
    #[inline]
    pub fn max_sample_location_grid_size(mut self, value: Extent2D) -> Self {
        self.inner.max_sample_location_grid_size = value;
        self
    }
    #[inline]
    pub fn sample_location_coordinate_range(mut self, value: [f32; 2usize]) -> Self {
        self.inner.sample_location_coordinate_range = value;
        self
    }
    #[inline]
    pub fn sample_location_sub_pixel_bits(mut self, value: u32) -> Self {
        self.inner.sample_location_sub_pixel_bits = value;
        self
    }
    #[inline]
    pub fn variable_sample_locations(mut self, value: bool) -> Self {
        self.inner.variable_sample_locations = value as u32;
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceSampleLocationsPropertiesEXTBuilder<'a> {
    type Target = PhysicalDeviceSampleLocationsPropertiesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceSampleLocationsPropertiesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`MultisamplePropertiesEXT`] with lifetime-tied pNext safety.
pub struct MultisamplePropertiesEXTBuilder<'a> {
    inner: MultisamplePropertiesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl MultisamplePropertiesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> MultisamplePropertiesEXTBuilder<'a> {
        MultisamplePropertiesEXTBuilder {
            inner: MultisamplePropertiesEXT {
                s_type: StructureType::from_raw(1000143004i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> MultisamplePropertiesEXTBuilder<'a> {
    #[inline]
    pub fn max_sample_location_grid_size(mut self, value: Extent2D) -> Self {
        self.inner.max_sample_location_grid_size = value;
        self
    }
}
impl<'a> core::ops::Deref for MultisamplePropertiesEXTBuilder<'a> {
    type Target = MultisamplePropertiesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for MultisamplePropertiesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`SamplerReductionModeCreateInfo`] with lifetime-tied pNext safety.
pub struct SamplerReductionModeCreateInfoBuilder<'a> {
    inner: SamplerReductionModeCreateInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl SamplerReductionModeCreateInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> SamplerReductionModeCreateInfoBuilder<'a> {
        SamplerReductionModeCreateInfoBuilder {
            inner: SamplerReductionModeCreateInfo {
                s_type: StructureType::from_raw(1000130001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> SamplerReductionModeCreateInfoBuilder<'a> {
    #[inline]
    pub fn reduction_mode(mut self, value: SamplerReductionMode) -> Self {
        self.inner.reduction_mode = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`SamplerReductionModeCreateInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsSamplerReductionModeCreateInfo>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for SamplerReductionModeCreateInfoBuilder<'a> {
    type Target = SamplerReductionModeCreateInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for SamplerReductionModeCreateInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceBlendOperationAdvancedFeaturesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceBlendOperationAdvancedFeaturesEXTBuilder<'a> {
    inner: PhysicalDeviceBlendOperationAdvancedFeaturesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceBlendOperationAdvancedFeaturesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceBlendOperationAdvancedFeaturesEXTBuilder<'a> {
        PhysicalDeviceBlendOperationAdvancedFeaturesEXTBuilder {
            inner: PhysicalDeviceBlendOperationAdvancedFeaturesEXT {
                s_type: StructureType::from_raw(1000148000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceBlendOperationAdvancedFeaturesEXTBuilder<'a> {
    #[inline]
    pub fn advanced_blend_coherent_operations(mut self, value: bool) -> Self {
        self.inner.advanced_blend_coherent_operations = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceBlendOperationAdvancedFeaturesEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceBlendOperationAdvancedFeaturesEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDeviceBlendOperationAdvancedFeaturesEXTBuilder<'a> {
    type Target = PhysicalDeviceBlendOperationAdvancedFeaturesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceBlendOperationAdvancedFeaturesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceMultiDrawFeaturesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceMultiDrawFeaturesEXTBuilder<'a> {
    inner: PhysicalDeviceMultiDrawFeaturesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceMultiDrawFeaturesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceMultiDrawFeaturesEXTBuilder<'a> {
        PhysicalDeviceMultiDrawFeaturesEXTBuilder {
            inner: PhysicalDeviceMultiDrawFeaturesEXT {
                s_type: StructureType::from_raw(1000392000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceMultiDrawFeaturesEXTBuilder<'a> {
    #[inline]
    pub fn multi_draw(mut self, value: bool) -> Self {
        self.inner.multi_draw = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceMultiDrawFeaturesEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceMultiDrawFeaturesEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceMultiDrawFeaturesEXTBuilder<'a> {
    type Target = PhysicalDeviceMultiDrawFeaturesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceMultiDrawFeaturesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceBlendOperationAdvancedPropertiesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder<'a> {
    inner: PhysicalDeviceBlendOperationAdvancedPropertiesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceBlendOperationAdvancedPropertiesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder<
        'a,
    > {
        PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder {
            inner: PhysicalDeviceBlendOperationAdvancedPropertiesEXT {
                s_type: StructureType::from_raw(1000148001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder<'a> {
    #[inline]
    pub fn advanced_blend_max_color_attachments(mut self, value: u32) -> Self {
        self.inner.advanced_blend_max_color_attachments = value;
        self
    }
    #[inline]
    pub fn advanced_blend_independent_blend(mut self, value: bool) -> Self {
        self.inner.advanced_blend_independent_blend = value as u32;
        self
    }
    #[inline]
    pub fn advanced_blend_non_premultiplied_src_color(mut self, value: bool) -> Self {
        self.inner.advanced_blend_non_premultiplied_src_color = value as u32;
        self
    }
    #[inline]
    pub fn advanced_blend_non_premultiplied_dst_color(mut self, value: bool) -> Self {
        self.inner.advanced_blend_non_premultiplied_dst_color = value as u32;
        self
    }
    #[inline]
    pub fn advanced_blend_correlated_overlap(mut self, value: bool) -> Self {
        self.inner.advanced_blend_correlated_overlap = value as u32;
        self
    }
    #[inline]
    pub fn advanced_blend_all_operations(mut self, value: bool) -> Self {
        self.inner.advanced_blend_all_operations = value as u32;
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder<'a> {
    type Target = PhysicalDeviceBlendOperationAdvancedPropertiesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PipelineColorBlendAdvancedStateCreateInfoEXT`] with lifetime-tied pNext safety.
pub struct PipelineColorBlendAdvancedStateCreateInfoEXTBuilder<'a> {
    inner: PipelineColorBlendAdvancedStateCreateInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PipelineColorBlendAdvancedStateCreateInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PipelineColorBlendAdvancedStateCreateInfoEXTBuilder<'a> {
        PipelineColorBlendAdvancedStateCreateInfoEXTBuilder {
            inner: PipelineColorBlendAdvancedStateCreateInfoEXT {
                s_type: StructureType::from_raw(1000148002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PipelineColorBlendAdvancedStateCreateInfoEXTBuilder<'a> {
    #[inline]
    pub fn src_premultiplied(mut self, value: bool) -> Self {
        self.inner.src_premultiplied = value as u32;
        self
    }
    #[inline]
    pub fn dst_premultiplied(mut self, value: bool) -> Self {
        self.inner.dst_premultiplied = value as u32;
        self
    }
    #[inline]
    pub fn blend_overlap(mut self, value: BlendOverlapEXT) -> Self {
        self.inner.blend_overlap = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PipelineColorBlendAdvancedStateCreateInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPipelineColorBlendAdvancedStateCreateInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for PipelineColorBlendAdvancedStateCreateInfoEXTBuilder<'a> {
    type Target = PipelineColorBlendAdvancedStateCreateInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PipelineColorBlendAdvancedStateCreateInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceInlineUniformBlockFeatures`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceInlineUniformBlockFeaturesBuilder<'a> {
    inner: PhysicalDeviceInlineUniformBlockFeatures,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceInlineUniformBlockFeatures {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceInlineUniformBlockFeaturesBuilder<'a> {
        PhysicalDeviceInlineUniformBlockFeaturesBuilder {
            inner: PhysicalDeviceInlineUniformBlockFeatures {
                s_type: StructureType::from_raw(1000138000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceInlineUniformBlockFeaturesBuilder<'a> {
    #[inline]
    pub fn inline_uniform_block(mut self, value: bool) -> Self {
        self.inner.inline_uniform_block = value as u32;
        self
    }
    #[inline]
    pub fn descriptor_binding_inline_uniform_block_update_after_bind(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.descriptor_binding_inline_uniform_block_update_after_bind = value
            as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceInlineUniformBlockFeatures`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceInlineUniformBlockFeatures>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceInlineUniformBlockFeaturesBuilder<'a> {
    type Target = PhysicalDeviceInlineUniformBlockFeatures;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceInlineUniformBlockFeaturesBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceInlineUniformBlockProperties`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceInlineUniformBlockPropertiesBuilder<'a> {
    inner: PhysicalDeviceInlineUniformBlockProperties,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceInlineUniformBlockProperties {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceInlineUniformBlockPropertiesBuilder<'a> {
        PhysicalDeviceInlineUniformBlockPropertiesBuilder {
            inner: PhysicalDeviceInlineUniformBlockProperties {
                s_type: StructureType::from_raw(1000138001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceInlineUniformBlockPropertiesBuilder<'a> {
    #[inline]
    pub fn max_inline_uniform_block_size(mut self, value: u32) -> Self {
        self.inner.max_inline_uniform_block_size = value;
        self
    }
    #[inline]
    pub fn max_per_stage_descriptor_inline_uniform_blocks(mut self, value: u32) -> Self {
        self.inner.max_per_stage_descriptor_inline_uniform_blocks = value;
        self
    }
    #[inline]
    pub fn max_per_stage_descriptor_update_after_bind_inline_uniform_blocks(
        mut self,
        value: u32,
    ) -> Self {
        self.inner.max_per_stage_descriptor_update_after_bind_inline_uniform_blocks = value;
        self
    }
    #[inline]
    pub fn max_descriptor_set_inline_uniform_blocks(mut self, value: u32) -> Self {
        self.inner.max_descriptor_set_inline_uniform_blocks = value;
        self
    }
    #[inline]
    pub fn max_descriptor_set_update_after_bind_inline_uniform_blocks(
        mut self,
        value: u32,
    ) -> Self {
        self.inner.max_descriptor_set_update_after_bind_inline_uniform_blocks = value;
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceInlineUniformBlockPropertiesBuilder<'a> {
    type Target = PhysicalDeviceInlineUniformBlockProperties;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceInlineUniformBlockPropertiesBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`WriteDescriptorSetInlineUniformBlock`] with lifetime-tied pNext safety.
pub struct WriteDescriptorSetInlineUniformBlockBuilder<'a> {
    inner: WriteDescriptorSetInlineUniformBlock,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl WriteDescriptorSetInlineUniformBlock {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> WriteDescriptorSetInlineUniformBlockBuilder<'a> {
        WriteDescriptorSetInlineUniformBlockBuilder {
            inner: WriteDescriptorSetInlineUniformBlock {
                s_type: StructureType::from_raw(1000138002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> WriteDescriptorSetInlineUniformBlockBuilder<'a> {
    #[inline]
    pub fn data(mut self, slice: &'a [core::ffi::c_void]) -> Self {
        self.inner.data_size = slice.len() as u32;
        self.inner.p_data = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`WriteDescriptorSetInlineUniformBlock`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsWriteDescriptorSetInlineUniformBlock>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for WriteDescriptorSetInlineUniformBlockBuilder<'a> {
    type Target = WriteDescriptorSetInlineUniformBlock;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for WriteDescriptorSetInlineUniformBlockBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DescriptorPoolInlineUniformBlockCreateInfo`] with lifetime-tied pNext safety.
pub struct DescriptorPoolInlineUniformBlockCreateInfoBuilder<'a> {
    inner: DescriptorPoolInlineUniformBlockCreateInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DescriptorPoolInlineUniformBlockCreateInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> DescriptorPoolInlineUniformBlockCreateInfoBuilder<'a> {
        DescriptorPoolInlineUniformBlockCreateInfoBuilder {
            inner: DescriptorPoolInlineUniformBlockCreateInfo {
                s_type: StructureType::from_raw(1000138003i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DescriptorPoolInlineUniformBlockCreateInfoBuilder<'a> {
    #[inline]
    pub fn max_inline_uniform_block_bindings(mut self, value: u32) -> Self {
        self.inner.max_inline_uniform_block_bindings = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`DescriptorPoolInlineUniformBlockCreateInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsDescriptorPoolInlineUniformBlockCreateInfo>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for DescriptorPoolInlineUniformBlockCreateInfoBuilder<'a> {
    type Target = DescriptorPoolInlineUniformBlockCreateInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for DescriptorPoolInlineUniformBlockCreateInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PipelineCoverageModulationStateCreateInfoNV`] with lifetime-tied pNext safety.
pub struct PipelineCoverageModulationStateCreateInfoNVBuilder<'a> {
    inner: PipelineCoverageModulationStateCreateInfoNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PipelineCoverageModulationStateCreateInfoNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PipelineCoverageModulationStateCreateInfoNVBuilder<'a> {
        PipelineCoverageModulationStateCreateInfoNVBuilder {
            inner: PipelineCoverageModulationStateCreateInfoNV {
                s_type: StructureType::from_raw(1000152000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PipelineCoverageModulationStateCreateInfoNVBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: PipelineCoverageModulationStateCreateFlagsNV) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn coverage_modulation_mode(mut self, value: CoverageModulationModeNV) -> Self {
        self.inner.coverage_modulation_mode = value;
        self
    }
    #[inline]
    pub fn coverage_modulation_table_enable(mut self, value: bool) -> Self {
        self.inner.coverage_modulation_table_enable = value as u32;
        self
    }
    #[inline]
    pub fn coverage_modulation_table_count(mut self, value: u32) -> Self {
        self.inner.coverage_modulation_table_count = value;
        self
    }
    #[inline]
    pub fn coverage_modulation_table(mut self, slice: &'a [f32]) -> Self {
        self.inner.coverage_modulation_table_count = slice.len() as u32;
        self.inner.p_coverage_modulation_table = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`PipelineCoverageModulationStateCreateInfoNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPipelineCoverageModulationStateCreateInfoNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for PipelineCoverageModulationStateCreateInfoNVBuilder<'a> {
    type Target = PipelineCoverageModulationStateCreateInfoNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PipelineCoverageModulationStateCreateInfoNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ImageFormatListCreateInfo`] with lifetime-tied pNext safety.
pub struct ImageFormatListCreateInfoBuilder<'a> {
    inner: ImageFormatListCreateInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ImageFormatListCreateInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ImageFormatListCreateInfoBuilder<'a> {
        ImageFormatListCreateInfoBuilder {
            inner: ImageFormatListCreateInfo {
                s_type: StructureType::from_raw(1000147000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ImageFormatListCreateInfoBuilder<'a> {
    #[inline]
    pub fn view_formats(mut self, slice: &'a [Format]) -> Self {
        self.inner.view_format_count = slice.len() as u32;
        self.inner.p_view_formats = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`ImageFormatListCreateInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsImageFormatListCreateInfo>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for ImageFormatListCreateInfoBuilder<'a> {
    type Target = ImageFormatListCreateInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ImageFormatListCreateInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ValidationCacheCreateInfoEXT`] with lifetime-tied pNext safety.
pub struct ValidationCacheCreateInfoEXTBuilder<'a> {
    inner: ValidationCacheCreateInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ValidationCacheCreateInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ValidationCacheCreateInfoEXTBuilder<'a> {
        ValidationCacheCreateInfoEXTBuilder {
            inner: ValidationCacheCreateInfoEXT {
                s_type: StructureType::from_raw(1000160000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ValidationCacheCreateInfoEXTBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: ValidationCacheCreateFlagsEXT) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn initial_data(mut self, slice: &'a [core::ffi::c_void]) -> Self {
        self.inner.initial_data_size = slice.len();
        self.inner.p_initial_data = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`ValidationCacheCreateInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsValidationCacheCreateInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for ValidationCacheCreateInfoEXTBuilder<'a> {
    type Target = ValidationCacheCreateInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ValidationCacheCreateInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ShaderModuleValidationCacheCreateInfoEXT`] with lifetime-tied pNext safety.
pub struct ShaderModuleValidationCacheCreateInfoEXTBuilder<'a> {
    inner: ShaderModuleValidationCacheCreateInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ShaderModuleValidationCacheCreateInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ShaderModuleValidationCacheCreateInfoEXTBuilder<'a> {
        ShaderModuleValidationCacheCreateInfoEXTBuilder {
            inner: ShaderModuleValidationCacheCreateInfoEXT {
                s_type: StructureType::from_raw(1000160001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ShaderModuleValidationCacheCreateInfoEXTBuilder<'a> {
    #[inline]
    pub fn validation_cache(mut self, value: ValidationCacheEXT) -> Self {
        self.inner.validation_cache = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`ShaderModuleValidationCacheCreateInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsShaderModuleValidationCacheCreateInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for ShaderModuleValidationCacheCreateInfoEXTBuilder<'a> {
    type Target = ShaderModuleValidationCacheCreateInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ShaderModuleValidationCacheCreateInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceMaintenance3Properties`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceMaintenance3PropertiesBuilder<'a> {
    inner: PhysicalDeviceMaintenance3Properties,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceMaintenance3Properties {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceMaintenance3PropertiesBuilder<'a> {
        PhysicalDeviceMaintenance3PropertiesBuilder {
            inner: PhysicalDeviceMaintenance3Properties {
                s_type: StructureType::from_raw(1000168000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceMaintenance3PropertiesBuilder<'a> {
    #[inline]
    pub fn max_per_set_descriptors(mut self, value: u32) -> Self {
        self.inner.max_per_set_descriptors = value;
        self
    }
    #[inline]
    pub fn max_memory_allocation_size(mut self, value: u64) -> Self {
        self.inner.max_memory_allocation_size = value;
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceMaintenance3PropertiesBuilder<'a> {
    type Target = PhysicalDeviceMaintenance3Properties;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceMaintenance3PropertiesBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceMaintenance4Features`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceMaintenance4FeaturesBuilder<'a> {
    inner: PhysicalDeviceMaintenance4Features,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceMaintenance4Features {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceMaintenance4FeaturesBuilder<'a> {
        PhysicalDeviceMaintenance4FeaturesBuilder {
            inner: PhysicalDeviceMaintenance4Features {
                s_type: StructureType::from_raw(1000413000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceMaintenance4FeaturesBuilder<'a> {
    #[inline]
    pub fn maintenance4(mut self, value: bool) -> Self {
        self.inner.maintenance4 = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceMaintenance4Features`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceMaintenance4Features>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceMaintenance4FeaturesBuilder<'a> {
    type Target = PhysicalDeviceMaintenance4Features;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceMaintenance4FeaturesBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceMaintenance4Properties`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceMaintenance4PropertiesBuilder<'a> {
    inner: PhysicalDeviceMaintenance4Properties,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceMaintenance4Properties {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceMaintenance4PropertiesBuilder<'a> {
        PhysicalDeviceMaintenance4PropertiesBuilder {
            inner: PhysicalDeviceMaintenance4Properties {
                s_type: StructureType::from_raw(1000413001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceMaintenance4PropertiesBuilder<'a> {
    #[inline]
    pub fn max_buffer_size(mut self, value: u64) -> Self {
        self.inner.max_buffer_size = value;
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceMaintenance4PropertiesBuilder<'a> {
    type Target = PhysicalDeviceMaintenance4Properties;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceMaintenance4PropertiesBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceMaintenance5Features`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceMaintenance5FeaturesBuilder<'a> {
    inner: PhysicalDeviceMaintenance5Features,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceMaintenance5Features {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceMaintenance5FeaturesBuilder<'a> {
        PhysicalDeviceMaintenance5FeaturesBuilder {
            inner: PhysicalDeviceMaintenance5Features {
                s_type: StructureType::from_raw(1000470000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceMaintenance5FeaturesBuilder<'a> {
    #[inline]
    pub fn maintenance5(mut self, value: bool) -> Self {
        self.inner.maintenance5 = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceMaintenance5Features`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceMaintenance5Features>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceMaintenance5FeaturesBuilder<'a> {
    type Target = PhysicalDeviceMaintenance5Features;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceMaintenance5FeaturesBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceMaintenance5Properties`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceMaintenance5PropertiesBuilder<'a> {
    inner: PhysicalDeviceMaintenance5Properties,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceMaintenance5Properties {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceMaintenance5PropertiesBuilder<'a> {
        PhysicalDeviceMaintenance5PropertiesBuilder {
            inner: PhysicalDeviceMaintenance5Properties {
                s_type: StructureType::from_raw(1000470001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceMaintenance5PropertiesBuilder<'a> {
    #[inline]
    pub fn early_fragment_multisample_coverage_after_sample_counting(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.early_fragment_multisample_coverage_after_sample_counting = value
            as u32;
        self
    }
    #[inline]
    pub fn early_fragment_sample_mask_test_before_sample_counting(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.early_fragment_sample_mask_test_before_sample_counting = value as u32;
        self
    }
    #[inline]
    pub fn depth_stencil_swizzle_one_support(mut self, value: bool) -> Self {
        self.inner.depth_stencil_swizzle_one_support = value as u32;
        self
    }
    #[inline]
    pub fn polygon_mode_point_size(mut self, value: bool) -> Self {
        self.inner.polygon_mode_point_size = value as u32;
        self
    }
    #[inline]
    pub fn non_strict_single_pixel_wide_lines_use_parallelogram(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.non_strict_single_pixel_wide_lines_use_parallelogram = value as u32;
        self
    }
    #[inline]
    pub fn non_strict_wide_lines_use_parallelogram(mut self, value: bool) -> Self {
        self.inner.non_strict_wide_lines_use_parallelogram = value as u32;
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceMaintenance5PropertiesBuilder<'a> {
    type Target = PhysicalDeviceMaintenance5Properties;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceMaintenance5PropertiesBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceMaintenance6Features`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceMaintenance6FeaturesBuilder<'a> {
    inner: PhysicalDeviceMaintenance6Features,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceMaintenance6Features {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceMaintenance6FeaturesBuilder<'a> {
        PhysicalDeviceMaintenance6FeaturesBuilder {
            inner: PhysicalDeviceMaintenance6Features {
                s_type: StructureType::from_raw(1000545000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceMaintenance6FeaturesBuilder<'a> {
    #[inline]
    pub fn maintenance6(mut self, value: bool) -> Self {
        self.inner.maintenance6 = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceMaintenance6Features`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceMaintenance6Features>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceMaintenance6FeaturesBuilder<'a> {
    type Target = PhysicalDeviceMaintenance6Features;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceMaintenance6FeaturesBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceMaintenance6Properties`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceMaintenance6PropertiesBuilder<'a> {
    inner: PhysicalDeviceMaintenance6Properties,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceMaintenance6Properties {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceMaintenance6PropertiesBuilder<'a> {
        PhysicalDeviceMaintenance6PropertiesBuilder {
            inner: PhysicalDeviceMaintenance6Properties {
                s_type: StructureType::from_raw(1000545001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceMaintenance6PropertiesBuilder<'a> {
    #[inline]
    pub fn block_texel_view_compatible_multiple_layers(mut self, value: bool) -> Self {
        self.inner.block_texel_view_compatible_multiple_layers = value as u32;
        self
    }
    #[inline]
    pub fn max_combined_image_sampler_descriptor_count(mut self, value: u32) -> Self {
        self.inner.max_combined_image_sampler_descriptor_count = value;
        self
    }
    #[inline]
    pub fn fragment_shading_rate_clamp_combiner_inputs(mut self, value: bool) -> Self {
        self.inner.fragment_shading_rate_clamp_combiner_inputs = value as u32;
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceMaintenance6PropertiesBuilder<'a> {
    type Target = PhysicalDeviceMaintenance6Properties;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceMaintenance6PropertiesBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceMaintenance7FeaturesKHR`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceMaintenance7FeaturesKHRBuilder<'a> {
    inner: PhysicalDeviceMaintenance7FeaturesKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceMaintenance7FeaturesKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceMaintenance7FeaturesKHRBuilder<'a> {
        PhysicalDeviceMaintenance7FeaturesKHRBuilder {
            inner: PhysicalDeviceMaintenance7FeaturesKHR {
                s_type: StructureType::from_raw(1000562000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceMaintenance7FeaturesKHRBuilder<'a> {
    #[inline]
    pub fn maintenance7(mut self, value: bool) -> Self {
        self.inner.maintenance7 = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceMaintenance7FeaturesKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceMaintenance7FeaturesKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceMaintenance7FeaturesKHRBuilder<'a> {
    type Target = PhysicalDeviceMaintenance7FeaturesKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceMaintenance7FeaturesKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceMaintenance7PropertiesKHR`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceMaintenance7PropertiesKHRBuilder<'a> {
    inner: PhysicalDeviceMaintenance7PropertiesKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceMaintenance7PropertiesKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceMaintenance7PropertiesKHRBuilder<'a> {
        PhysicalDeviceMaintenance7PropertiesKHRBuilder {
            inner: PhysicalDeviceMaintenance7PropertiesKHR {
                s_type: StructureType::from_raw(1000562001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceMaintenance7PropertiesKHRBuilder<'a> {
    #[inline]
    pub fn robust_fragment_shading_rate_attachment_access(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.robust_fragment_shading_rate_attachment_access = value as u32;
        self
    }
    #[inline]
    pub fn separate_depth_stencil_attachment_access(mut self, value: bool) -> Self {
        self.inner.separate_depth_stencil_attachment_access = value as u32;
        self
    }
    #[inline]
    pub fn max_descriptor_set_total_uniform_buffers_dynamic(
        mut self,
        value: u32,
    ) -> Self {
        self.inner.max_descriptor_set_total_uniform_buffers_dynamic = value;
        self
    }
    #[inline]
    pub fn max_descriptor_set_total_storage_buffers_dynamic(
        mut self,
        value: u32,
    ) -> Self {
        self.inner.max_descriptor_set_total_storage_buffers_dynamic = value;
        self
    }
    #[inline]
    pub fn max_descriptor_set_total_buffers_dynamic(mut self, value: u32) -> Self {
        self.inner.max_descriptor_set_total_buffers_dynamic = value;
        self
    }
    #[inline]
    pub fn max_descriptor_set_update_after_bind_total_uniform_buffers_dynamic(
        mut self,
        value: u32,
    ) -> Self {
        self.inner.max_descriptor_set_update_after_bind_total_uniform_buffers_dynamic = value;
        self
    }
    #[inline]
    pub fn max_descriptor_set_update_after_bind_total_storage_buffers_dynamic(
        mut self,
        value: u32,
    ) -> Self {
        self.inner.max_descriptor_set_update_after_bind_total_storage_buffers_dynamic = value;
        self
    }
    #[inline]
    pub fn max_descriptor_set_update_after_bind_total_buffers_dynamic(
        mut self,
        value: u32,
    ) -> Self {
        self.inner.max_descriptor_set_update_after_bind_total_buffers_dynamic = value;
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceMaintenance7PropertiesKHRBuilder<'a> {
    type Target = PhysicalDeviceMaintenance7PropertiesKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceMaintenance7PropertiesKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceLayeredApiPropertiesListKHR`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceLayeredApiPropertiesListKHRBuilder<'a> {
    inner: PhysicalDeviceLayeredApiPropertiesListKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceLayeredApiPropertiesListKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceLayeredApiPropertiesListKHRBuilder<'a> {
        PhysicalDeviceLayeredApiPropertiesListKHRBuilder {
            inner: PhysicalDeviceLayeredApiPropertiesListKHR {
                s_type: StructureType::from_raw(1000562002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceLayeredApiPropertiesListKHRBuilder<'a> {
    #[inline]
    pub fn layered_api_count(mut self, value: u32) -> Self {
        self.inner.layered_api_count = value;
        self
    }
    #[inline]
    pub fn layered_apis(
        mut self,
        slice: &'a mut [PhysicalDeviceLayeredApiPropertiesKHR],
    ) -> Self {
        self.inner.layered_api_count = slice.len() as u32;
        self.inner.p_layered_apis = slice.as_mut_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceLayeredApiPropertiesListKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceLayeredApiPropertiesListKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceLayeredApiPropertiesListKHRBuilder<'a> {
    type Target = PhysicalDeviceLayeredApiPropertiesListKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceLayeredApiPropertiesListKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceLayeredApiPropertiesKHR`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceLayeredApiPropertiesKHRBuilder<'a> {
    inner: PhysicalDeviceLayeredApiPropertiesKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceLayeredApiPropertiesKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceLayeredApiPropertiesKHRBuilder<'a> {
        PhysicalDeviceLayeredApiPropertiesKHRBuilder {
            inner: PhysicalDeviceLayeredApiPropertiesKHR {
                s_type: StructureType::from_raw(1000562003i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceLayeredApiPropertiesKHRBuilder<'a> {
    #[inline]
    pub fn vendor_id(mut self, value: u32) -> Self {
        self.inner.vendor_id = value;
        self
    }
    #[inline]
    pub fn device_id(mut self, value: u32) -> Self {
        self.inner.device_id = value;
        self
    }
    #[inline]
    pub fn layered_api(mut self, value: PhysicalDeviceLayeredApiKHR) -> Self {
        self.inner.layered_api = value;
        self
    }
    #[inline]
    pub fn device_name(
        mut self,
        value: crate::StringArray<{ MAX_PHYSICAL_DEVICE_NAME_SIZE as usize }>,
    ) -> Self {
        self.inner.device_name = value;
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceLayeredApiPropertiesKHRBuilder<'a> {
    type Target = PhysicalDeviceLayeredApiPropertiesKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceLayeredApiPropertiesKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceLayeredApiVulkanPropertiesKHR`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceLayeredApiVulkanPropertiesKHRBuilder<'a> {
    inner: PhysicalDeviceLayeredApiVulkanPropertiesKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceLayeredApiVulkanPropertiesKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceLayeredApiVulkanPropertiesKHRBuilder<'a> {
        PhysicalDeviceLayeredApiVulkanPropertiesKHRBuilder {
            inner: PhysicalDeviceLayeredApiVulkanPropertiesKHR {
                s_type: StructureType::from_raw(1000562004i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceLayeredApiVulkanPropertiesKHRBuilder<'a> {
    #[inline]
    pub fn properties(mut self, value: PhysicalDeviceProperties2) -> Self {
        self.inner.properties = value;
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceLayeredApiVulkanPropertiesKHRBuilder<'a> {
    type Target = PhysicalDeviceLayeredApiVulkanPropertiesKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceLayeredApiVulkanPropertiesKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceMaintenance8FeaturesKHR`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceMaintenance8FeaturesKHRBuilder<'a> {
    inner: PhysicalDeviceMaintenance8FeaturesKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceMaintenance8FeaturesKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceMaintenance8FeaturesKHRBuilder<'a> {
        PhysicalDeviceMaintenance8FeaturesKHRBuilder {
            inner: PhysicalDeviceMaintenance8FeaturesKHR {
                s_type: StructureType::from_raw(1000574000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceMaintenance8FeaturesKHRBuilder<'a> {
    #[inline]
    pub fn maintenance8(mut self, value: bool) -> Self {
        self.inner.maintenance8 = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceMaintenance8FeaturesKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceMaintenance8FeaturesKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceMaintenance8FeaturesKHRBuilder<'a> {
    type Target = PhysicalDeviceMaintenance8FeaturesKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceMaintenance8FeaturesKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceMaintenance9FeaturesKHR`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceMaintenance9FeaturesKHRBuilder<'a> {
    inner: PhysicalDeviceMaintenance9FeaturesKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceMaintenance9FeaturesKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceMaintenance9FeaturesKHRBuilder<'a> {
        PhysicalDeviceMaintenance9FeaturesKHRBuilder {
            inner: PhysicalDeviceMaintenance9FeaturesKHR {
                s_type: StructureType::from_raw(1000584000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceMaintenance9FeaturesKHRBuilder<'a> {
    #[inline]
    pub fn maintenance9(mut self, value: bool) -> Self {
        self.inner.maintenance9 = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceMaintenance9FeaturesKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceMaintenance9FeaturesKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceMaintenance9FeaturesKHRBuilder<'a> {
    type Target = PhysicalDeviceMaintenance9FeaturesKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceMaintenance9FeaturesKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceMaintenance9PropertiesKHR`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceMaintenance9PropertiesKHRBuilder<'a> {
    inner: PhysicalDeviceMaintenance9PropertiesKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceMaintenance9PropertiesKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceMaintenance9PropertiesKHRBuilder<'a> {
        PhysicalDeviceMaintenance9PropertiesKHRBuilder {
            inner: PhysicalDeviceMaintenance9PropertiesKHR {
                s_type: StructureType::from_raw(1000584001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceMaintenance9PropertiesKHRBuilder<'a> {
    #[inline]
    pub fn image2_d_view_of3_d_sparse(mut self, value: bool) -> Self {
        self.inner.image2_d_view_of3_d_sparse = value as u32;
        self
    }
    #[inline]
    pub fn default_vertex_attribute_value(
        mut self,
        value: DefaultVertexAttributeValueKHR,
    ) -> Self {
        self.inner.default_vertex_attribute_value = value;
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceMaintenance9PropertiesKHRBuilder<'a> {
    type Target = PhysicalDeviceMaintenance9PropertiesKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceMaintenance9PropertiesKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceMaintenance10PropertiesKHR`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceMaintenance10PropertiesKHRBuilder<'a> {
    inner: PhysicalDeviceMaintenance10PropertiesKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceMaintenance10PropertiesKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceMaintenance10PropertiesKHRBuilder<'a> {
        PhysicalDeviceMaintenance10PropertiesKHRBuilder {
            inner: PhysicalDeviceMaintenance10PropertiesKHR {
                s_type: StructureType::from_raw(1000630001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceMaintenance10PropertiesKHRBuilder<'a> {
    #[inline]
    pub fn rgba4_opaque_black_swizzled(mut self, value: bool) -> Self {
        self.inner.rgba4_opaque_black_swizzled = value as u32;
        self
    }
    #[inline]
    pub fn resolve_srgb_format_applies_transfer_function(mut self, value: bool) -> Self {
        self.inner.resolve_srgb_format_applies_transfer_function = value as u32;
        self
    }
    #[inline]
    pub fn resolve_srgb_format_supports_transfer_function_control(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.resolve_srgb_format_supports_transfer_function_control = value as u32;
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceMaintenance10PropertiesKHRBuilder<'a> {
    type Target = PhysicalDeviceMaintenance10PropertiesKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceMaintenance10PropertiesKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceMaintenance10FeaturesKHR`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceMaintenance10FeaturesKHRBuilder<'a> {
    inner: PhysicalDeviceMaintenance10FeaturesKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceMaintenance10FeaturesKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceMaintenance10FeaturesKHRBuilder<'a> {
        PhysicalDeviceMaintenance10FeaturesKHRBuilder {
            inner: PhysicalDeviceMaintenance10FeaturesKHR {
                s_type: StructureType::from_raw(1000630000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceMaintenance10FeaturesKHRBuilder<'a> {
    #[inline]
    pub fn maintenance10(mut self, value: bool) -> Self {
        self.inner.maintenance10 = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceMaintenance10FeaturesKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceMaintenance10FeaturesKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceMaintenance10FeaturesKHRBuilder<'a> {
    type Target = PhysicalDeviceMaintenance10FeaturesKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceMaintenance10FeaturesKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`QueueFamilyOwnershipTransferPropertiesKHR`] with lifetime-tied pNext safety.
pub struct QueueFamilyOwnershipTransferPropertiesKHRBuilder<'a> {
    inner: QueueFamilyOwnershipTransferPropertiesKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl QueueFamilyOwnershipTransferPropertiesKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> QueueFamilyOwnershipTransferPropertiesKHRBuilder<'a> {
        QueueFamilyOwnershipTransferPropertiesKHRBuilder {
            inner: QueueFamilyOwnershipTransferPropertiesKHR {
                s_type: StructureType::from_raw(1000584002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> QueueFamilyOwnershipTransferPropertiesKHRBuilder<'a> {
    #[inline]
    pub fn optimal_image_transfer_to_queue_families(mut self, value: u32) -> Self {
        self.inner.optimal_image_transfer_to_queue_families = value;
        self
    }
}
impl<'a> core::ops::Deref for QueueFamilyOwnershipTransferPropertiesKHRBuilder<'a> {
    type Target = QueueFamilyOwnershipTransferPropertiesKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for QueueFamilyOwnershipTransferPropertiesKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`RenderingAreaInfo`] with lifetime-tied pNext safety.
pub struct RenderingAreaInfoBuilder<'a> {
    inner: RenderingAreaInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl RenderingAreaInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> RenderingAreaInfoBuilder<'a> {
        RenderingAreaInfoBuilder {
            inner: RenderingAreaInfo {
                s_type: StructureType::from_raw(1000470003i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> RenderingAreaInfoBuilder<'a> {
    #[inline]
    pub fn view_mask(mut self, value: u32) -> Self {
        self.inner.view_mask = value;
        self
    }
    #[inline]
    pub fn color_attachment_formats(mut self, slice: &'a [Format]) -> Self {
        self.inner.color_attachment_count = slice.len() as u32;
        self.inner.p_color_attachment_formats = slice.as_ptr();
        self
    }
    #[inline]
    pub fn depth_attachment_format(mut self, value: Format) -> Self {
        self.inner.depth_attachment_format = value;
        self
    }
    #[inline]
    pub fn stencil_attachment_format(mut self, value: Format) -> Self {
        self.inner.stencil_attachment_format = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`RenderingAreaInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsRenderingAreaInfo>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for RenderingAreaInfoBuilder<'a> {
    type Target = RenderingAreaInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for RenderingAreaInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DescriptorSetLayoutSupport`] with lifetime-tied pNext safety.
pub struct DescriptorSetLayoutSupportBuilder<'a> {
    inner: DescriptorSetLayoutSupport,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DescriptorSetLayoutSupport {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> DescriptorSetLayoutSupportBuilder<'a> {
        DescriptorSetLayoutSupportBuilder {
            inner: DescriptorSetLayoutSupport {
                s_type: StructureType::from_raw(1000168001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DescriptorSetLayoutSupportBuilder<'a> {
    #[inline]
    pub fn supported(mut self, value: bool) -> Self {
        self.inner.supported = value as u32;
        self
    }
}
impl<'a> core::ops::Deref for DescriptorSetLayoutSupportBuilder<'a> {
    type Target = DescriptorSetLayoutSupport;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for DescriptorSetLayoutSupportBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceShaderDrawParametersFeatures`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceShaderDrawParametersFeaturesBuilder<'a> {
    inner: PhysicalDeviceShaderDrawParametersFeatures,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceShaderDrawParametersFeatures {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceShaderDrawParametersFeaturesBuilder<'a> {
        PhysicalDeviceShaderDrawParametersFeaturesBuilder {
            inner: PhysicalDeviceShaderDrawParametersFeatures {
                s_type: StructureType::from_raw(1000063000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceShaderDrawParametersFeaturesBuilder<'a> {
    #[inline]
    pub fn shader_draw_parameters(mut self, value: bool) -> Self {
        self.inner.shader_draw_parameters = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceShaderDrawParametersFeatures`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceShaderDrawParametersFeatures>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceShaderDrawParametersFeaturesBuilder<'a> {
    type Target = PhysicalDeviceShaderDrawParametersFeatures;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceShaderDrawParametersFeaturesBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceShaderFloat16Int8Features`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceShaderFloat16Int8FeaturesBuilder<'a> {
    inner: PhysicalDeviceShaderFloat16Int8Features,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceShaderFloat16Int8Features {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceShaderFloat16Int8FeaturesBuilder<'a> {
        PhysicalDeviceShaderFloat16Int8FeaturesBuilder {
            inner: PhysicalDeviceShaderFloat16Int8Features {
                s_type: StructureType::from_raw(1000082000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceShaderFloat16Int8FeaturesBuilder<'a> {
    #[inline]
    pub fn shader_float16(mut self, value: bool) -> Self {
        self.inner.shader_float16 = value as u32;
        self
    }
    #[inline]
    pub fn shader_int8(mut self, value: bool) -> Self {
        self.inner.shader_int8 = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceShaderFloat16Int8Features`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceShaderFloat16Int8Features>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceShaderFloat16Int8FeaturesBuilder<'a> {
    type Target = PhysicalDeviceShaderFloat16Int8Features;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceShaderFloat16Int8FeaturesBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceFloatControlsProperties`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceFloatControlsPropertiesBuilder<'a> {
    inner: PhysicalDeviceFloatControlsProperties,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceFloatControlsProperties {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceFloatControlsPropertiesBuilder<'a> {
        PhysicalDeviceFloatControlsPropertiesBuilder {
            inner: PhysicalDeviceFloatControlsProperties {
                s_type: StructureType::from_raw(1000197000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceFloatControlsPropertiesBuilder<'a> {
    #[inline]
    pub fn denorm_behavior_independence(
        mut self,
        value: ShaderFloatControlsIndependence,
    ) -> Self {
        self.inner.denorm_behavior_independence = value;
        self
    }
    #[inline]
    pub fn rounding_mode_independence(
        mut self,
        value: ShaderFloatControlsIndependence,
    ) -> Self {
        self.inner.rounding_mode_independence = value;
        self
    }
    #[inline]
    pub fn shader_signed_zero_inf_nan_preserve_float16(mut self, value: bool) -> Self {
        self.inner.shader_signed_zero_inf_nan_preserve_float16 = value as u32;
        self
    }
    #[inline]
    pub fn shader_signed_zero_inf_nan_preserve_float32(mut self, value: bool) -> Self {
        self.inner.shader_signed_zero_inf_nan_preserve_float32 = value as u32;
        self
    }
    #[inline]
    pub fn shader_signed_zero_inf_nan_preserve_float64(mut self, value: bool) -> Self {
        self.inner.shader_signed_zero_inf_nan_preserve_float64 = value as u32;
        self
    }
    #[inline]
    pub fn shader_denorm_preserve_float16(mut self, value: bool) -> Self {
        self.inner.shader_denorm_preserve_float16 = value as u32;
        self
    }
    #[inline]
    pub fn shader_denorm_preserve_float32(mut self, value: bool) -> Self {
        self.inner.shader_denorm_preserve_float32 = value as u32;
        self
    }
    #[inline]
    pub fn shader_denorm_preserve_float64(mut self, value: bool) -> Self {
        self.inner.shader_denorm_preserve_float64 = value as u32;
        self
    }
    #[inline]
    pub fn shader_denorm_flush_to_zero_float16(mut self, value: bool) -> Self {
        self.inner.shader_denorm_flush_to_zero_float16 = value as u32;
        self
    }
    #[inline]
    pub fn shader_denorm_flush_to_zero_float32(mut self, value: bool) -> Self {
        self.inner.shader_denorm_flush_to_zero_float32 = value as u32;
        self
    }
    #[inline]
    pub fn shader_denorm_flush_to_zero_float64(mut self, value: bool) -> Self {
        self.inner.shader_denorm_flush_to_zero_float64 = value as u32;
        self
    }
    #[inline]
    pub fn shader_rounding_mode_rte_float16(mut self, value: bool) -> Self {
        self.inner.shader_rounding_mode_rte_float16 = value as u32;
        self
    }
    #[inline]
    pub fn shader_rounding_mode_rte_float32(mut self, value: bool) -> Self {
        self.inner.shader_rounding_mode_rte_float32 = value as u32;
        self
    }
    #[inline]
    pub fn shader_rounding_mode_rte_float64(mut self, value: bool) -> Self {
        self.inner.shader_rounding_mode_rte_float64 = value as u32;
        self
    }
    #[inline]
    pub fn shader_rounding_mode_rtz_float16(mut self, value: bool) -> Self {
        self.inner.shader_rounding_mode_rtz_float16 = value as u32;
        self
    }
    #[inline]
    pub fn shader_rounding_mode_rtz_float32(mut self, value: bool) -> Self {
        self.inner.shader_rounding_mode_rtz_float32 = value as u32;
        self
    }
    #[inline]
    pub fn shader_rounding_mode_rtz_float64(mut self, value: bool) -> Self {
        self.inner.shader_rounding_mode_rtz_float64 = value as u32;
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceFloatControlsPropertiesBuilder<'a> {
    type Target = PhysicalDeviceFloatControlsProperties;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceFloatControlsPropertiesBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceHostQueryResetFeatures`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceHostQueryResetFeaturesBuilder<'a> {
    inner: PhysicalDeviceHostQueryResetFeatures,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceHostQueryResetFeatures {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceHostQueryResetFeaturesBuilder<'a> {
        PhysicalDeviceHostQueryResetFeaturesBuilder {
            inner: PhysicalDeviceHostQueryResetFeatures {
                s_type: StructureType::from_raw(1000261000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceHostQueryResetFeaturesBuilder<'a> {
    #[inline]
    pub fn host_query_reset(mut self, value: bool) -> Self {
        self.inner.host_query_reset = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceHostQueryResetFeatures`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceHostQueryResetFeatures>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceHostQueryResetFeaturesBuilder<'a> {
    type Target = PhysicalDeviceHostQueryResetFeatures;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceHostQueryResetFeaturesBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`NativeBufferUsage2ANDROID`].
pub struct NativeBufferUsage2ANDROIDBuilder {
    inner: NativeBufferUsage2ANDROID,
}
impl NativeBufferUsage2ANDROID {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> NativeBufferUsage2ANDROIDBuilder {
        NativeBufferUsage2ANDROIDBuilder {
            inner: NativeBufferUsage2ANDROID {
                ..Default::default()
            },
        }
    }
}
impl NativeBufferUsage2ANDROIDBuilder {
    #[inline]
    pub fn consumer(mut self, value: u64) -> Self {
        self.inner.consumer = value;
        self
    }
    #[inline]
    pub fn producer(mut self, value: u64) -> Self {
        self.inner.producer = value;
        self
    }
}
impl core::ops::Deref for NativeBufferUsage2ANDROIDBuilder {
    type Target = NativeBufferUsage2ANDROID;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for NativeBufferUsage2ANDROIDBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`NativeBufferANDROID`] with lifetime-tied pNext safety.
pub struct NativeBufferANDROIDBuilder<'a> {
    inner: NativeBufferANDROID,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl NativeBufferANDROID {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> NativeBufferANDROIDBuilder<'a> {
        NativeBufferANDROIDBuilder {
            inner: NativeBufferANDROID {
                s_type: Default::default(),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> NativeBufferANDROIDBuilder<'a> {
    #[inline]
    pub fn handle(mut self, value: *const core::ffi::c_void) -> Self {
        self.inner.handle = value;
        self
    }
    #[inline]
    pub fn stride(mut self, value: core::ffi::c_int) -> Self {
        self.inner.stride = value;
        self
    }
    #[inline]
    pub fn format(mut self, value: core::ffi::c_int) -> Self {
        self.inner.format = value;
        self
    }
    #[inline]
    pub fn usage(mut self, value: core::ffi::c_int) -> Self {
        self.inner.usage = value;
        self
    }
    #[inline]
    pub fn usage2(mut self, value: NativeBufferUsage2ANDROID) -> Self {
        self.inner.usage2 = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`NativeBufferANDROID`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsNativeBufferANDROID>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for NativeBufferANDROIDBuilder<'a> {
    type Target = NativeBufferANDROID;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for NativeBufferANDROIDBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`SwapchainImageCreateInfoANDROID`] with lifetime-tied pNext safety.
pub struct SwapchainImageCreateInfoANDROIDBuilder<'a> {
    inner: SwapchainImageCreateInfoANDROID,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl SwapchainImageCreateInfoANDROID {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> SwapchainImageCreateInfoANDROIDBuilder<'a> {
        SwapchainImageCreateInfoANDROIDBuilder {
            inner: SwapchainImageCreateInfoANDROID {
                s_type: Default::default(),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> SwapchainImageCreateInfoANDROIDBuilder<'a> {
    #[inline]
    pub fn usage(mut self, value: SwapchainImageUsageFlagsANDROID) -> Self {
        self.inner.usage = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`SwapchainImageCreateInfoANDROID`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsSwapchainImageCreateInfoANDROID>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for SwapchainImageCreateInfoANDROIDBuilder<'a> {
    type Target = SwapchainImageCreateInfoANDROID;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for SwapchainImageCreateInfoANDROIDBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDevicePresentationPropertiesANDROID`] with lifetime-tied pNext safety.
pub struct PhysicalDevicePresentationPropertiesANDROIDBuilder<'a> {
    inner: PhysicalDevicePresentationPropertiesANDROID,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDevicePresentationPropertiesANDROID {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDevicePresentationPropertiesANDROIDBuilder<'a> {
        PhysicalDevicePresentationPropertiesANDROIDBuilder {
            inner: PhysicalDevicePresentationPropertiesANDROID {
                s_type: Default::default(),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDevicePresentationPropertiesANDROIDBuilder<'a> {
    #[inline]
    pub fn shared_image(mut self, value: bool) -> Self {
        self.inner.shared_image = value as u32;
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDevicePresentationPropertiesANDROIDBuilder<'a> {
    type Target = PhysicalDevicePresentationPropertiesANDROID;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDevicePresentationPropertiesANDROIDBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ShaderResourceUsageAMD`].
pub struct ShaderResourceUsageAMDBuilder {
    inner: ShaderResourceUsageAMD,
}
impl ShaderResourceUsageAMD {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> ShaderResourceUsageAMDBuilder {
        ShaderResourceUsageAMDBuilder {
            inner: ShaderResourceUsageAMD {
                ..Default::default()
            },
        }
    }
}
impl ShaderResourceUsageAMDBuilder {
    #[inline]
    pub fn num_used_vgprs(mut self, value: u32) -> Self {
        self.inner.num_used_vgprs = value;
        self
    }
    #[inline]
    pub fn num_used_sgprs(mut self, value: u32) -> Self {
        self.inner.num_used_sgprs = value;
        self
    }
    #[inline]
    pub fn lds_size_per_local_work_group(mut self, value: u32) -> Self {
        self.inner.lds_size_per_local_work_group = value;
        self
    }
    #[inline]
    pub fn lds_usage_size_in_bytes(mut self, value: usize) -> Self {
        self.inner.lds_usage_size_in_bytes = value;
        self
    }
    #[inline]
    pub fn scratch_mem_usage_in_bytes(mut self, value: usize) -> Self {
        self.inner.scratch_mem_usage_in_bytes = value;
        self
    }
}
impl core::ops::Deref for ShaderResourceUsageAMDBuilder {
    type Target = ShaderResourceUsageAMD;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for ShaderResourceUsageAMDBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ShaderStatisticsInfoAMD`].
pub struct ShaderStatisticsInfoAMDBuilder {
    inner: ShaderStatisticsInfoAMD,
}
impl ShaderStatisticsInfoAMD {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> ShaderStatisticsInfoAMDBuilder {
        ShaderStatisticsInfoAMDBuilder {
            inner: ShaderStatisticsInfoAMD {
                ..Default::default()
            },
        }
    }
}
impl ShaderStatisticsInfoAMDBuilder {
    #[inline]
    pub fn shader_stage_mask(mut self, value: ShaderStageFlags) -> Self {
        self.inner.shader_stage_mask = value;
        self
    }
    #[inline]
    pub fn resource_usage(mut self, value: ShaderResourceUsageAMD) -> Self {
        self.inner.resource_usage = value;
        self
    }
    #[inline]
    pub fn num_physical_vgprs(mut self, value: u32) -> Self {
        self.inner.num_physical_vgprs = value;
        self
    }
    #[inline]
    pub fn num_physical_sgprs(mut self, value: u32) -> Self {
        self.inner.num_physical_sgprs = value;
        self
    }
    #[inline]
    pub fn num_available_vgprs(mut self, value: u32) -> Self {
        self.inner.num_available_vgprs = value;
        self
    }
    #[inline]
    pub fn num_available_sgprs(mut self, value: u32) -> Self {
        self.inner.num_available_sgprs = value;
        self
    }
    #[inline]
    pub fn compute_work_group_size(mut self, value: [u32; 3usize]) -> Self {
        self.inner.compute_work_group_size = value;
        self
    }
}
impl core::ops::Deref for ShaderStatisticsInfoAMDBuilder {
    type Target = ShaderStatisticsInfoAMD;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for ShaderStatisticsInfoAMDBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DeviceQueueGlobalPriorityCreateInfo`] with lifetime-tied pNext safety.
pub struct DeviceQueueGlobalPriorityCreateInfoBuilder<'a> {
    inner: DeviceQueueGlobalPriorityCreateInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DeviceQueueGlobalPriorityCreateInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> DeviceQueueGlobalPriorityCreateInfoBuilder<'a> {
        DeviceQueueGlobalPriorityCreateInfoBuilder {
            inner: DeviceQueueGlobalPriorityCreateInfo {
                s_type: StructureType::from_raw(1000174000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DeviceQueueGlobalPriorityCreateInfoBuilder<'a> {
    #[inline]
    pub fn global_priority(mut self, value: QueueGlobalPriority) -> Self {
        self.inner.global_priority = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`DeviceQueueGlobalPriorityCreateInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsDeviceQueueGlobalPriorityCreateInfo>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for DeviceQueueGlobalPriorityCreateInfoBuilder<'a> {
    type Target = DeviceQueueGlobalPriorityCreateInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for DeviceQueueGlobalPriorityCreateInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceGlobalPriorityQueryFeatures`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceGlobalPriorityQueryFeaturesBuilder<'a> {
    inner: PhysicalDeviceGlobalPriorityQueryFeatures,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceGlobalPriorityQueryFeatures {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceGlobalPriorityQueryFeaturesBuilder<'a> {
        PhysicalDeviceGlobalPriorityQueryFeaturesBuilder {
            inner: PhysicalDeviceGlobalPriorityQueryFeatures {
                s_type: StructureType::from_raw(1000388000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceGlobalPriorityQueryFeaturesBuilder<'a> {
    #[inline]
    pub fn global_priority_query(mut self, value: bool) -> Self {
        self.inner.global_priority_query = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceGlobalPriorityQueryFeatures`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceGlobalPriorityQueryFeatures>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceGlobalPriorityQueryFeaturesBuilder<'a> {
    type Target = PhysicalDeviceGlobalPriorityQueryFeatures;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceGlobalPriorityQueryFeaturesBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`QueueFamilyGlobalPriorityProperties`] with lifetime-tied pNext safety.
pub struct QueueFamilyGlobalPriorityPropertiesBuilder<'a> {
    inner: QueueFamilyGlobalPriorityProperties,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl QueueFamilyGlobalPriorityProperties {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> QueueFamilyGlobalPriorityPropertiesBuilder<'a> {
        QueueFamilyGlobalPriorityPropertiesBuilder {
            inner: QueueFamilyGlobalPriorityProperties {
                s_type: StructureType::from_raw(1000388001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> QueueFamilyGlobalPriorityPropertiesBuilder<'a> {
    #[inline]
    pub fn priority_count(mut self, value: u32) -> Self {
        self.inner.priority_count = value;
        self
    }
    #[inline]
    pub fn priorities(
        mut self,
        value: [QueueGlobalPriority; MAX_GLOBAL_PRIORITY_SIZE as usize],
    ) -> Self {
        self.inner.priorities = value;
        self
    }
}
impl<'a> core::ops::Deref for QueueFamilyGlobalPriorityPropertiesBuilder<'a> {
    type Target = QueueFamilyGlobalPriorityProperties;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for QueueFamilyGlobalPriorityPropertiesBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DebugUtilsObjectNameInfoEXT`] with lifetime-tied pNext safety.
pub struct DebugUtilsObjectNameInfoEXTBuilder<'a> {
    inner: DebugUtilsObjectNameInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DebugUtilsObjectNameInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> DebugUtilsObjectNameInfoEXTBuilder<'a> {
        DebugUtilsObjectNameInfoEXTBuilder {
            inner: DebugUtilsObjectNameInfoEXT {
                s_type: StructureType::from_raw(1000128000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DebugUtilsObjectNameInfoEXTBuilder<'a> {
    #[inline]
    pub fn object_type(mut self, value: ObjectType) -> Self {
        self.inner.object_type = value;
        self
    }
    #[inline]
    pub fn object_handle(mut self, value: u64) -> Self {
        self.inner.object_handle = value;
        self
    }
    #[inline]
    pub fn object_name(mut self, value: &'a core::ffi::CStr) -> Self {
        self.inner.p_object_name = value.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`DebugUtilsObjectNameInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsDebugUtilsObjectNameInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for DebugUtilsObjectNameInfoEXTBuilder<'a> {
    type Target = DebugUtilsObjectNameInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for DebugUtilsObjectNameInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DebugUtilsObjectTagInfoEXT`] with lifetime-tied pNext safety.
pub struct DebugUtilsObjectTagInfoEXTBuilder<'a> {
    inner: DebugUtilsObjectTagInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DebugUtilsObjectTagInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> DebugUtilsObjectTagInfoEXTBuilder<'a> {
        DebugUtilsObjectTagInfoEXTBuilder {
            inner: DebugUtilsObjectTagInfoEXT {
                s_type: StructureType::from_raw(1000128001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DebugUtilsObjectTagInfoEXTBuilder<'a> {
    #[inline]
    pub fn object_type(mut self, value: ObjectType) -> Self {
        self.inner.object_type = value;
        self
    }
    #[inline]
    pub fn object_handle(mut self, value: u64) -> Self {
        self.inner.object_handle = value;
        self
    }
    #[inline]
    pub fn tag_name(mut self, value: u64) -> Self {
        self.inner.tag_name = value;
        self
    }
    #[inline]
    pub fn tag(mut self, slice: &'a [core::ffi::c_void]) -> Self {
        self.inner.tag_size = slice.len();
        self.inner.p_tag = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`DebugUtilsObjectTagInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsDebugUtilsObjectTagInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for DebugUtilsObjectTagInfoEXTBuilder<'a> {
    type Target = DebugUtilsObjectTagInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for DebugUtilsObjectTagInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DebugUtilsLabelEXT`] with lifetime-tied pNext safety.
pub struct DebugUtilsLabelEXTBuilder<'a> {
    inner: DebugUtilsLabelEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DebugUtilsLabelEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> DebugUtilsLabelEXTBuilder<'a> {
        DebugUtilsLabelEXTBuilder {
            inner: DebugUtilsLabelEXT {
                s_type: StructureType::from_raw(1000128002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DebugUtilsLabelEXTBuilder<'a> {
    #[inline]
    pub fn label_name(mut self, value: &'a core::ffi::CStr) -> Self {
        self.inner.p_label_name = value.as_ptr();
        self
    }
    #[inline]
    pub fn color(mut self, value: [f32; 4usize]) -> Self {
        self.inner.color = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`DebugUtilsLabelEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsDebugUtilsLabelEXT>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for DebugUtilsLabelEXTBuilder<'a> {
    type Target = DebugUtilsLabelEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for DebugUtilsLabelEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DebugUtilsMessengerCreateInfoEXT`] with lifetime-tied pNext safety.
pub struct DebugUtilsMessengerCreateInfoEXTBuilder<'a> {
    inner: DebugUtilsMessengerCreateInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DebugUtilsMessengerCreateInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> DebugUtilsMessengerCreateInfoEXTBuilder<'a> {
        DebugUtilsMessengerCreateInfoEXTBuilder {
            inner: DebugUtilsMessengerCreateInfoEXT {
                s_type: StructureType::from_raw(1000128004i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DebugUtilsMessengerCreateInfoEXTBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: DebugUtilsMessengerCreateFlagsEXT) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn message_severity(mut self, value: DebugUtilsMessageSeverityFlagsEXT) -> Self {
        self.inner.message_severity = value;
        self
    }
    #[inline]
    pub fn message_type(mut self, value: DebugUtilsMessageTypeFlagsEXT) -> Self {
        self.inner.message_type = value;
        self
    }
    #[inline]
    pub fn pfn_user_callback(
        mut self,
        value: PFN_vkDebugUtilsMessengerCallbackEXT,
    ) -> Self {
        self.inner.pfn_user_callback = value;
        self
    }
    #[inline]
    pub fn user_data(mut self, value: *mut core::ffi::c_void) -> Self {
        self.inner.p_user_data = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`DebugUtilsMessengerCreateInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsDebugUtilsMessengerCreateInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for DebugUtilsMessengerCreateInfoEXTBuilder<'a> {
    type Target = DebugUtilsMessengerCreateInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for DebugUtilsMessengerCreateInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DebugUtilsMessengerCallbackDataEXT`] with lifetime-tied pNext safety.
pub struct DebugUtilsMessengerCallbackDataEXTBuilder<'a> {
    inner: DebugUtilsMessengerCallbackDataEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DebugUtilsMessengerCallbackDataEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> DebugUtilsMessengerCallbackDataEXTBuilder<'a> {
        DebugUtilsMessengerCallbackDataEXTBuilder {
            inner: DebugUtilsMessengerCallbackDataEXT {
                s_type: StructureType::from_raw(1000128003i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DebugUtilsMessengerCallbackDataEXTBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: DebugUtilsMessengerCallbackDataFlagsEXT) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn message_id_name(mut self, value: &'a core::ffi::CStr) -> Self {
        self.inner.p_message_id_name = value.as_ptr();
        self
    }
    #[inline]
    pub fn message_id_number(mut self, value: i32) -> Self {
        self.inner.message_id_number = value;
        self
    }
    #[inline]
    pub fn message(mut self, value: &'a core::ffi::CStr) -> Self {
        self.inner.p_message = value.as_ptr();
        self
    }
    #[inline]
    pub fn queue_labels(mut self, slice: &'a [DebugUtilsLabelEXT]) -> Self {
        self.inner.queue_label_count = slice.len() as u32;
        self.inner.p_queue_labels = slice.as_ptr();
        self
    }
    #[inline]
    pub fn cmd_buf_labels(mut self, slice: &'a [DebugUtilsLabelEXT]) -> Self {
        self.inner.cmd_buf_label_count = slice.len() as u32;
        self.inner.p_cmd_buf_labels = slice.as_ptr();
        self
    }
    #[inline]
    pub fn objects(mut self, slice: &'a [DebugUtilsObjectNameInfoEXT]) -> Self {
        self.inner.object_count = slice.len() as u32;
        self.inner.p_objects = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`DebugUtilsMessengerCallbackDataEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsDebugUtilsMessengerCallbackDataEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for DebugUtilsMessengerCallbackDataEXTBuilder<'a> {
    type Target = DebugUtilsMessengerCallbackDataEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for DebugUtilsMessengerCallbackDataEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceDeviceMemoryReportFeaturesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceDeviceMemoryReportFeaturesEXTBuilder<'a> {
    inner: PhysicalDeviceDeviceMemoryReportFeaturesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceDeviceMemoryReportFeaturesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceDeviceMemoryReportFeaturesEXTBuilder<'a> {
        PhysicalDeviceDeviceMemoryReportFeaturesEXTBuilder {
            inner: PhysicalDeviceDeviceMemoryReportFeaturesEXT {
                s_type: StructureType::from_raw(1000284000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceDeviceMemoryReportFeaturesEXTBuilder<'a> {
    #[inline]
    pub fn device_memory_report(mut self, value: bool) -> Self {
        self.inner.device_memory_report = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceDeviceMemoryReportFeaturesEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceDeviceMemoryReportFeaturesEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceDeviceMemoryReportFeaturesEXTBuilder<'a> {
    type Target = PhysicalDeviceDeviceMemoryReportFeaturesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceDeviceMemoryReportFeaturesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DeviceDeviceMemoryReportCreateInfoEXT`] with lifetime-tied pNext safety.
pub struct DeviceDeviceMemoryReportCreateInfoEXTBuilder<'a> {
    inner: DeviceDeviceMemoryReportCreateInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DeviceDeviceMemoryReportCreateInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> DeviceDeviceMemoryReportCreateInfoEXTBuilder<'a> {
        DeviceDeviceMemoryReportCreateInfoEXTBuilder {
            inner: DeviceDeviceMemoryReportCreateInfoEXT {
                s_type: StructureType::from_raw(1000284001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DeviceDeviceMemoryReportCreateInfoEXTBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: DeviceMemoryReportFlagsEXT) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn pfn_user_callback(
        mut self,
        value: PFN_vkDeviceMemoryReportCallbackEXT,
    ) -> Self {
        self.inner.pfn_user_callback = value;
        self
    }
    #[inline]
    pub fn user_data(mut self, value: *mut core::ffi::c_void) -> Self {
        self.inner.p_user_data = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`DeviceDeviceMemoryReportCreateInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsDeviceDeviceMemoryReportCreateInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for DeviceDeviceMemoryReportCreateInfoEXTBuilder<'a> {
    type Target = DeviceDeviceMemoryReportCreateInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for DeviceDeviceMemoryReportCreateInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DeviceMemoryReportCallbackDataEXT`] with lifetime-tied pNext safety.
pub struct DeviceMemoryReportCallbackDataEXTBuilder<'a> {
    inner: DeviceMemoryReportCallbackDataEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DeviceMemoryReportCallbackDataEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> DeviceMemoryReportCallbackDataEXTBuilder<'a> {
        DeviceMemoryReportCallbackDataEXTBuilder {
            inner: DeviceMemoryReportCallbackDataEXT {
                s_type: StructureType::from_raw(1000284002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DeviceMemoryReportCallbackDataEXTBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: DeviceMemoryReportFlagsEXT) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn r#type(mut self, value: DeviceMemoryReportEventTypeEXT) -> Self {
        self.inner.r#type = value;
        self
    }
    #[inline]
    pub fn memory_object_id(mut self, value: u64) -> Self {
        self.inner.memory_object_id = value;
        self
    }
    #[inline]
    pub fn size(mut self, value: u64) -> Self {
        self.inner.size = value;
        self
    }
    #[inline]
    pub fn object_type(mut self, value: ObjectType) -> Self {
        self.inner.object_type = value;
        self
    }
    #[inline]
    pub fn object_handle(mut self, value: u64) -> Self {
        self.inner.object_handle = value;
        self
    }
    #[inline]
    pub fn heap_index(mut self, value: u32) -> Self {
        self.inner.heap_index = value;
        self
    }
}
impl<'a> core::ops::Deref for DeviceMemoryReportCallbackDataEXTBuilder<'a> {
    type Target = DeviceMemoryReportCallbackDataEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for DeviceMemoryReportCallbackDataEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ImportMemoryHostPointerInfoEXT`] with lifetime-tied pNext safety.
pub struct ImportMemoryHostPointerInfoEXTBuilder<'a> {
    inner: ImportMemoryHostPointerInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ImportMemoryHostPointerInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ImportMemoryHostPointerInfoEXTBuilder<'a> {
        ImportMemoryHostPointerInfoEXTBuilder {
            inner: ImportMemoryHostPointerInfoEXT {
                s_type: StructureType::from_raw(1000178000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ImportMemoryHostPointerInfoEXTBuilder<'a> {
    #[inline]
    pub fn handle_type(mut self, value: ExternalMemoryHandleTypeFlagBits) -> Self {
        self.inner.handle_type = value;
        self
    }
    #[inline]
    pub fn host_pointer(mut self, value: *mut core::ffi::c_void) -> Self {
        self.inner.p_host_pointer = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`ImportMemoryHostPointerInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsImportMemoryHostPointerInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for ImportMemoryHostPointerInfoEXTBuilder<'a> {
    type Target = ImportMemoryHostPointerInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ImportMemoryHostPointerInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`MemoryHostPointerPropertiesEXT`] with lifetime-tied pNext safety.
pub struct MemoryHostPointerPropertiesEXTBuilder<'a> {
    inner: MemoryHostPointerPropertiesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl MemoryHostPointerPropertiesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> MemoryHostPointerPropertiesEXTBuilder<'a> {
        MemoryHostPointerPropertiesEXTBuilder {
            inner: MemoryHostPointerPropertiesEXT {
                s_type: StructureType::from_raw(1000178001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> MemoryHostPointerPropertiesEXTBuilder<'a> {
    #[inline]
    pub fn memory_type_bits(mut self, value: u32) -> Self {
        self.inner.memory_type_bits = value;
        self
    }
}
impl<'a> core::ops::Deref for MemoryHostPointerPropertiesEXTBuilder<'a> {
    type Target = MemoryHostPointerPropertiesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for MemoryHostPointerPropertiesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceExternalMemoryHostPropertiesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceExternalMemoryHostPropertiesEXTBuilder<'a> {
    inner: PhysicalDeviceExternalMemoryHostPropertiesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceExternalMemoryHostPropertiesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceExternalMemoryHostPropertiesEXTBuilder<'a> {
        PhysicalDeviceExternalMemoryHostPropertiesEXTBuilder {
            inner: PhysicalDeviceExternalMemoryHostPropertiesEXT {
                s_type: StructureType::from_raw(1000178002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceExternalMemoryHostPropertiesEXTBuilder<'a> {
    #[inline]
    pub fn min_imported_host_pointer_alignment(mut self, value: u64) -> Self {
        self.inner.min_imported_host_pointer_alignment = value;
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceExternalMemoryHostPropertiesEXTBuilder<'a> {
    type Target = PhysicalDeviceExternalMemoryHostPropertiesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceExternalMemoryHostPropertiesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceConservativeRasterizationPropertiesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a> {
    inner: PhysicalDeviceConservativeRasterizationPropertiesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceConservativeRasterizationPropertiesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<
        'a,
    > {
        PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder {
            inner: PhysicalDeviceConservativeRasterizationPropertiesEXT {
                s_type: StructureType::from_raw(1000101000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a> {
    #[inline]
    pub fn primitive_overestimation_size(mut self, value: f32) -> Self {
        self.inner.primitive_overestimation_size = value;
        self
    }
    #[inline]
    pub fn max_extra_primitive_overestimation_size(mut self, value: f32) -> Self {
        self.inner.max_extra_primitive_overestimation_size = value;
        self
    }
    #[inline]
    pub fn extra_primitive_overestimation_size_granularity(
        mut self,
        value: f32,
    ) -> Self {
        self.inner.extra_primitive_overestimation_size_granularity = value;
        self
    }
    #[inline]
    pub fn primitive_underestimation(mut self, value: bool) -> Self {
        self.inner.primitive_underestimation = value as u32;
        self
    }
    #[inline]
    pub fn conservative_point_and_line_rasterization(mut self, value: bool) -> Self {
        self.inner.conservative_point_and_line_rasterization = value as u32;
        self
    }
    #[inline]
    pub fn degenerate_triangles_rasterized(mut self, value: bool) -> Self {
        self.inner.degenerate_triangles_rasterized = value as u32;
        self
    }
    #[inline]
    pub fn degenerate_lines_rasterized(mut self, value: bool) -> Self {
        self.inner.degenerate_lines_rasterized = value as u32;
        self
    }
    #[inline]
    pub fn fully_covered_fragment_shader_input_variable(mut self, value: bool) -> Self {
        self.inner.fully_covered_fragment_shader_input_variable = value as u32;
        self
    }
    #[inline]
    pub fn conservative_rasterization_post_depth_coverage(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.conservative_rasterization_post_depth_coverage = value as u32;
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a> {
    type Target = PhysicalDeviceConservativeRasterizationPropertiesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`CalibratedTimestampInfoKHR`] with lifetime-tied pNext safety.
pub struct CalibratedTimestampInfoKHRBuilder<'a> {
    inner: CalibratedTimestampInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl CalibratedTimestampInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> CalibratedTimestampInfoKHRBuilder<'a> {
        CalibratedTimestampInfoKHRBuilder {
            inner: CalibratedTimestampInfoKHR {
                s_type: StructureType::from_raw(1000184000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> CalibratedTimestampInfoKHRBuilder<'a> {
    #[inline]
    pub fn time_domain(mut self, value: TimeDomainKHR) -> Self {
        self.inner.time_domain = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`CalibratedTimestampInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsCalibratedTimestampInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for CalibratedTimestampInfoKHRBuilder<'a> {
    type Target = CalibratedTimestampInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for CalibratedTimestampInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceShaderCorePropertiesAMD`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceShaderCorePropertiesAMDBuilder<'a> {
    inner: PhysicalDeviceShaderCorePropertiesAMD,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceShaderCorePropertiesAMD {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceShaderCorePropertiesAMDBuilder<'a> {
        PhysicalDeviceShaderCorePropertiesAMDBuilder {
            inner: PhysicalDeviceShaderCorePropertiesAMD {
                s_type: StructureType::from_raw(1000185000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceShaderCorePropertiesAMDBuilder<'a> {
    #[inline]
    pub fn shader_engine_count(mut self, value: u32) -> Self {
        self.inner.shader_engine_count = value;
        self
    }
    #[inline]
    pub fn shader_arrays_per_engine_count(mut self, value: u32) -> Self {
        self.inner.shader_arrays_per_engine_count = value;
        self
    }
    #[inline]
    pub fn compute_units_per_shader_array(mut self, value: u32) -> Self {
        self.inner.compute_units_per_shader_array = value;
        self
    }
    #[inline]
    pub fn simd_per_compute_unit(mut self, value: u32) -> Self {
        self.inner.simd_per_compute_unit = value;
        self
    }
    #[inline]
    pub fn wavefronts_per_simd(mut self, value: u32) -> Self {
        self.inner.wavefronts_per_simd = value;
        self
    }
    #[inline]
    pub fn wavefront_size(mut self, value: u32) -> Self {
        self.inner.wavefront_size = value;
        self
    }
    #[inline]
    pub fn sgprs_per_simd(mut self, value: u32) -> Self {
        self.inner.sgprs_per_simd = value;
        self
    }
    #[inline]
    pub fn min_sgpr_allocation(mut self, value: u32) -> Self {
        self.inner.min_sgpr_allocation = value;
        self
    }
    #[inline]
    pub fn max_sgpr_allocation(mut self, value: u32) -> Self {
        self.inner.max_sgpr_allocation = value;
        self
    }
    #[inline]
    pub fn sgpr_allocation_granularity(mut self, value: u32) -> Self {
        self.inner.sgpr_allocation_granularity = value;
        self
    }
    #[inline]
    pub fn vgprs_per_simd(mut self, value: u32) -> Self {
        self.inner.vgprs_per_simd = value;
        self
    }
    #[inline]
    pub fn min_vgpr_allocation(mut self, value: u32) -> Self {
        self.inner.min_vgpr_allocation = value;
        self
    }
    #[inline]
    pub fn max_vgpr_allocation(mut self, value: u32) -> Self {
        self.inner.max_vgpr_allocation = value;
        self
    }
    #[inline]
    pub fn vgpr_allocation_granularity(mut self, value: u32) -> Self {
        self.inner.vgpr_allocation_granularity = value;
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceShaderCorePropertiesAMDBuilder<'a> {
    type Target = PhysicalDeviceShaderCorePropertiesAMD;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceShaderCorePropertiesAMDBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceShaderCoreProperties2AMD`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceShaderCoreProperties2AMDBuilder<'a> {
    inner: PhysicalDeviceShaderCoreProperties2AMD,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceShaderCoreProperties2AMD {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceShaderCoreProperties2AMDBuilder<'a> {
        PhysicalDeviceShaderCoreProperties2AMDBuilder {
            inner: PhysicalDeviceShaderCoreProperties2AMD {
                s_type: StructureType::from_raw(1000227000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceShaderCoreProperties2AMDBuilder<'a> {
    #[inline]
    pub fn shader_core_features(mut self, value: ShaderCorePropertiesFlagsAMD) -> Self {
        self.inner.shader_core_features = value;
        self
    }
    #[inline]
    pub fn active_compute_unit_count(mut self, value: u32) -> Self {
        self.inner.active_compute_unit_count = value;
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceShaderCoreProperties2AMDBuilder<'a> {
    type Target = PhysicalDeviceShaderCoreProperties2AMD;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceShaderCoreProperties2AMDBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PipelineRasterizationConservativeStateCreateInfoEXT`] with lifetime-tied pNext safety.
pub struct PipelineRasterizationConservativeStateCreateInfoEXTBuilder<'a> {
    inner: PipelineRasterizationConservativeStateCreateInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PipelineRasterizationConservativeStateCreateInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PipelineRasterizationConservativeStateCreateInfoEXTBuilder<
        'a,
    > {
        PipelineRasterizationConservativeStateCreateInfoEXTBuilder {
            inner: PipelineRasterizationConservativeStateCreateInfoEXT {
                s_type: StructureType::from_raw(1000101001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PipelineRasterizationConservativeStateCreateInfoEXTBuilder<'a> {
    #[inline]
    pub fn flags(
        mut self,
        value: PipelineRasterizationConservativeStateCreateFlagsEXT,
    ) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn conservative_rasterization_mode(
        mut self,
        value: ConservativeRasterizationModeEXT,
    ) -> Self {
        self.inner.conservative_rasterization_mode = value;
        self
    }
    #[inline]
    pub fn extra_primitive_overestimation_size(mut self, value: f32) -> Self {
        self.inner.extra_primitive_overestimation_size = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PipelineRasterizationConservativeStateCreateInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPipelineRasterizationConservativeStateCreateInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref
for PipelineRasterizationConservativeStateCreateInfoEXTBuilder<'a> {
    type Target = PipelineRasterizationConservativeStateCreateInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PipelineRasterizationConservativeStateCreateInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceDescriptorIndexingFeatures`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> {
    inner: PhysicalDeviceDescriptorIndexingFeatures,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceDescriptorIndexingFeatures {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> {
        PhysicalDeviceDescriptorIndexingFeaturesBuilder {
            inner: PhysicalDeviceDescriptorIndexingFeatures {
                s_type: StructureType::from_raw(1000161001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> {
    #[inline]
    pub fn shader_input_attachment_array_dynamic_indexing(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.shader_input_attachment_array_dynamic_indexing = value as u32;
        self
    }
    #[inline]
    pub fn shader_uniform_texel_buffer_array_dynamic_indexing(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.shader_uniform_texel_buffer_array_dynamic_indexing = value as u32;
        self
    }
    #[inline]
    pub fn shader_storage_texel_buffer_array_dynamic_indexing(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.shader_storage_texel_buffer_array_dynamic_indexing = value as u32;
        self
    }
    #[inline]
    pub fn shader_uniform_buffer_array_non_uniform_indexing(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.shader_uniform_buffer_array_non_uniform_indexing = value as u32;
        self
    }
    #[inline]
    pub fn shader_sampled_image_array_non_uniform_indexing(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.shader_sampled_image_array_non_uniform_indexing = value as u32;
        self
    }
    #[inline]
    pub fn shader_storage_buffer_array_non_uniform_indexing(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.shader_storage_buffer_array_non_uniform_indexing = value as u32;
        self
    }
    #[inline]
    pub fn shader_storage_image_array_non_uniform_indexing(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.shader_storage_image_array_non_uniform_indexing = value as u32;
        self
    }
    #[inline]
    pub fn shader_input_attachment_array_non_uniform_indexing(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.shader_input_attachment_array_non_uniform_indexing = value as u32;
        self
    }
    #[inline]
    pub fn shader_uniform_texel_buffer_array_non_uniform_indexing(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.shader_uniform_texel_buffer_array_non_uniform_indexing = value as u32;
        self
    }
    #[inline]
    pub fn shader_storage_texel_buffer_array_non_uniform_indexing(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.shader_storage_texel_buffer_array_non_uniform_indexing = value as u32;
        self
    }
    #[inline]
    pub fn descriptor_binding_uniform_buffer_update_after_bind(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.descriptor_binding_uniform_buffer_update_after_bind = value as u32;
        self
    }
    #[inline]
    pub fn descriptor_binding_sampled_image_update_after_bind(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.descriptor_binding_sampled_image_update_after_bind = value as u32;
        self
    }
    #[inline]
    pub fn descriptor_binding_storage_image_update_after_bind(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.descriptor_binding_storage_image_update_after_bind = value as u32;
        self
    }
    #[inline]
    pub fn descriptor_binding_storage_buffer_update_after_bind(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.descriptor_binding_storage_buffer_update_after_bind = value as u32;
        self
    }
    #[inline]
    pub fn descriptor_binding_uniform_texel_buffer_update_after_bind(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.descriptor_binding_uniform_texel_buffer_update_after_bind = value
            as u32;
        self
    }
    #[inline]
    pub fn descriptor_binding_storage_texel_buffer_update_after_bind(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.descriptor_binding_storage_texel_buffer_update_after_bind = value
            as u32;
        self
    }
    #[inline]
    pub fn descriptor_binding_update_unused_while_pending(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.descriptor_binding_update_unused_while_pending = value as u32;
        self
    }
    #[inline]
    pub fn descriptor_binding_partially_bound(mut self, value: bool) -> Self {
        self.inner.descriptor_binding_partially_bound = value as u32;
        self
    }
    #[inline]
    pub fn descriptor_binding_variable_descriptor_count(mut self, value: bool) -> Self {
        self.inner.descriptor_binding_variable_descriptor_count = value as u32;
        self
    }
    #[inline]
    pub fn runtime_descriptor_array(mut self, value: bool) -> Self {
        self.inner.runtime_descriptor_array = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceDescriptorIndexingFeatures`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceDescriptorIndexingFeatures>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> {
    type Target = PhysicalDeviceDescriptorIndexingFeatures;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceDescriptorIndexingProperties`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> {
    inner: PhysicalDeviceDescriptorIndexingProperties,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceDescriptorIndexingProperties {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> {
        PhysicalDeviceDescriptorIndexingPropertiesBuilder {
            inner: PhysicalDeviceDescriptorIndexingProperties {
                s_type: StructureType::from_raw(1000161002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> {
    #[inline]
    pub fn max_update_after_bind_descriptors_in_all_pools(mut self, value: u32) -> Self {
        self.inner.max_update_after_bind_descriptors_in_all_pools = value;
        self
    }
    #[inline]
    pub fn shader_uniform_buffer_array_non_uniform_indexing_native(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.shader_uniform_buffer_array_non_uniform_indexing_native = value
            as u32;
        self
    }
    #[inline]
    pub fn shader_sampled_image_array_non_uniform_indexing_native(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.shader_sampled_image_array_non_uniform_indexing_native = value as u32;
        self
    }
    #[inline]
    pub fn shader_storage_buffer_array_non_uniform_indexing_native(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.shader_storage_buffer_array_non_uniform_indexing_native = value
            as u32;
        self
    }
    #[inline]
    pub fn shader_storage_image_array_non_uniform_indexing_native(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.shader_storage_image_array_non_uniform_indexing_native = value as u32;
        self
    }
    #[inline]
    pub fn shader_input_attachment_array_non_uniform_indexing_native(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.shader_input_attachment_array_non_uniform_indexing_native = value
            as u32;
        self
    }
    #[inline]
    pub fn robust_buffer_access_update_after_bind(mut self, value: bool) -> Self {
        self.inner.robust_buffer_access_update_after_bind = value as u32;
        self
    }
    #[inline]
    pub fn quad_divergent_implicit_lod(mut self, value: bool) -> Self {
        self.inner.quad_divergent_implicit_lod = value as u32;
        self
    }
    #[inline]
    pub fn max_per_stage_descriptor_update_after_bind_samplers(
        mut self,
        value: u32,
    ) -> Self {
        self.inner.max_per_stage_descriptor_update_after_bind_samplers = value;
        self
    }
    #[inline]
    pub fn max_per_stage_descriptor_update_after_bind_uniform_buffers(
        mut self,
        value: u32,
    ) -> Self {
        self.inner.max_per_stage_descriptor_update_after_bind_uniform_buffers = value;
        self
    }
    #[inline]
    pub fn max_per_stage_descriptor_update_after_bind_storage_buffers(
        mut self,
        value: u32,
    ) -> Self {
        self.inner.max_per_stage_descriptor_update_after_bind_storage_buffers = value;
        self
    }
    #[inline]
    pub fn max_per_stage_descriptor_update_after_bind_sampled_images(
        mut self,
        value: u32,
    ) -> Self {
        self.inner.max_per_stage_descriptor_update_after_bind_sampled_images = value;
        self
    }
    #[inline]
    pub fn max_per_stage_descriptor_update_after_bind_storage_images(
        mut self,
        value: u32,
    ) -> Self {
        self.inner.max_per_stage_descriptor_update_after_bind_storage_images = value;
        self
    }
    #[inline]
    pub fn max_per_stage_descriptor_update_after_bind_input_attachments(
        mut self,
        value: u32,
    ) -> Self {
        self.inner.max_per_stage_descriptor_update_after_bind_input_attachments = value;
        self
    }
    #[inline]
    pub fn max_per_stage_update_after_bind_resources(mut self, value: u32) -> Self {
        self.inner.max_per_stage_update_after_bind_resources = value;
        self
    }
    #[inline]
    pub fn max_descriptor_set_update_after_bind_samplers(mut self, value: u32) -> Self {
        self.inner.max_descriptor_set_update_after_bind_samplers = value;
        self
    }
    #[inline]
    pub fn max_descriptor_set_update_after_bind_uniform_buffers(
        mut self,
        value: u32,
    ) -> Self {
        self.inner.max_descriptor_set_update_after_bind_uniform_buffers = value;
        self
    }
    #[inline]
    pub fn max_descriptor_set_update_after_bind_uniform_buffers_dynamic(
        mut self,
        value: u32,
    ) -> Self {
        self.inner.max_descriptor_set_update_after_bind_uniform_buffers_dynamic = value;
        self
    }
    #[inline]
    pub fn max_descriptor_set_update_after_bind_storage_buffers(
        mut self,
        value: u32,
    ) -> Self {
        self.inner.max_descriptor_set_update_after_bind_storage_buffers = value;
        self
    }
    #[inline]
    pub fn max_descriptor_set_update_after_bind_storage_buffers_dynamic(
        mut self,
        value: u32,
    ) -> Self {
        self.inner.max_descriptor_set_update_after_bind_storage_buffers_dynamic = value;
        self
    }
    #[inline]
    pub fn max_descriptor_set_update_after_bind_sampled_images(
        mut self,
        value: u32,
    ) -> Self {
        self.inner.max_descriptor_set_update_after_bind_sampled_images = value;
        self
    }
    #[inline]
    pub fn max_descriptor_set_update_after_bind_storage_images(
        mut self,
        value: u32,
    ) -> Self {
        self.inner.max_descriptor_set_update_after_bind_storage_images = value;
        self
    }
    #[inline]
    pub fn max_descriptor_set_update_after_bind_input_attachments(
        mut self,
        value: u32,
    ) -> Self {
        self.inner.max_descriptor_set_update_after_bind_input_attachments = value;
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> {
    type Target = PhysicalDeviceDescriptorIndexingProperties;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DescriptorSetLayoutBindingFlagsCreateInfo`] with lifetime-tied pNext safety.
pub struct DescriptorSetLayoutBindingFlagsCreateInfoBuilder<'a> {
    inner: DescriptorSetLayoutBindingFlagsCreateInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DescriptorSetLayoutBindingFlagsCreateInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> DescriptorSetLayoutBindingFlagsCreateInfoBuilder<'a> {
        DescriptorSetLayoutBindingFlagsCreateInfoBuilder {
            inner: DescriptorSetLayoutBindingFlagsCreateInfo {
                s_type: StructureType::from_raw(1000161000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DescriptorSetLayoutBindingFlagsCreateInfoBuilder<'a> {
    #[inline]
    pub fn binding_count(mut self, value: u32) -> Self {
        self.inner.binding_count = value;
        self
    }
    #[inline]
    pub fn binding_flags(mut self, slice: &'a [DescriptorBindingFlags]) -> Self {
        self.inner.binding_count = slice.len() as u32;
        self.inner.p_binding_flags = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`DescriptorSetLayoutBindingFlagsCreateInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsDescriptorSetLayoutBindingFlagsCreateInfo>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for DescriptorSetLayoutBindingFlagsCreateInfoBuilder<'a> {
    type Target = DescriptorSetLayoutBindingFlagsCreateInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for DescriptorSetLayoutBindingFlagsCreateInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DescriptorSetVariableDescriptorCountAllocateInfo`] with lifetime-tied pNext safety.
pub struct DescriptorSetVariableDescriptorCountAllocateInfoBuilder<'a> {
    inner: DescriptorSetVariableDescriptorCountAllocateInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DescriptorSetVariableDescriptorCountAllocateInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> DescriptorSetVariableDescriptorCountAllocateInfoBuilder<'a> {
        DescriptorSetVariableDescriptorCountAllocateInfoBuilder {
            inner: DescriptorSetVariableDescriptorCountAllocateInfo {
                s_type: StructureType::from_raw(1000161003i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DescriptorSetVariableDescriptorCountAllocateInfoBuilder<'a> {
    #[inline]
    pub fn descriptor_counts(mut self, slice: &'a [u32]) -> Self {
        self.inner.descriptor_set_count = slice.len() as u32;
        self.inner.p_descriptor_counts = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`DescriptorSetVariableDescriptorCountAllocateInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsDescriptorSetVariableDescriptorCountAllocateInfo>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref
for DescriptorSetVariableDescriptorCountAllocateInfoBuilder<'a> {
    type Target = DescriptorSetVariableDescriptorCountAllocateInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for DescriptorSetVariableDescriptorCountAllocateInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DescriptorSetVariableDescriptorCountLayoutSupport`] with lifetime-tied pNext safety.
pub struct DescriptorSetVariableDescriptorCountLayoutSupportBuilder<'a> {
    inner: DescriptorSetVariableDescriptorCountLayoutSupport,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DescriptorSetVariableDescriptorCountLayoutSupport {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> DescriptorSetVariableDescriptorCountLayoutSupportBuilder<
        'a,
    > {
        DescriptorSetVariableDescriptorCountLayoutSupportBuilder {
            inner: DescriptorSetVariableDescriptorCountLayoutSupport {
                s_type: StructureType::from_raw(1000161004i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DescriptorSetVariableDescriptorCountLayoutSupportBuilder<'a> {
    #[inline]
    pub fn max_variable_descriptor_count(mut self, value: u32) -> Self {
        self.inner.max_variable_descriptor_count = value;
        self
    }
}
impl<'a> core::ops::Deref
for DescriptorSetVariableDescriptorCountLayoutSupportBuilder<'a> {
    type Target = DescriptorSetVariableDescriptorCountLayoutSupport;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for DescriptorSetVariableDescriptorCountLayoutSupportBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`AttachmentDescription2`] with lifetime-tied pNext safety.
pub struct AttachmentDescription2Builder<'a> {
    inner: AttachmentDescription2,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl AttachmentDescription2 {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> AttachmentDescription2Builder<'a> {
        AttachmentDescription2Builder {
            inner: AttachmentDescription2 {
                s_type: StructureType::from_raw(1000109000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> AttachmentDescription2Builder<'a> {
    #[inline]
    pub fn flags(mut self, value: AttachmentDescriptionFlags) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn format(mut self, value: Format) -> Self {
        self.inner.format = value;
        self
    }
    #[inline]
    pub fn samples(mut self, value: SampleCountFlagBits) -> Self {
        self.inner.samples = value;
        self
    }
    #[inline]
    pub fn load_op(mut self, value: AttachmentLoadOp) -> Self {
        self.inner.load_op = value;
        self
    }
    #[inline]
    pub fn store_op(mut self, value: AttachmentStoreOp) -> Self {
        self.inner.store_op = value;
        self
    }
    #[inline]
    pub fn stencil_load_op(mut self, value: AttachmentLoadOp) -> Self {
        self.inner.stencil_load_op = value;
        self
    }
    #[inline]
    pub fn stencil_store_op(mut self, value: AttachmentStoreOp) -> Self {
        self.inner.stencil_store_op = value;
        self
    }
    #[inline]
    pub fn initial_layout(mut self, value: ImageLayout) -> Self {
        self.inner.initial_layout = value;
        self
    }
    #[inline]
    pub fn final_layout(mut self, value: ImageLayout) -> Self {
        self.inner.final_layout = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`AttachmentDescription2`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsAttachmentDescription2>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for AttachmentDescription2Builder<'a> {
    type Target = AttachmentDescription2;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for AttachmentDescription2Builder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`AttachmentReference2`] with lifetime-tied pNext safety.
pub struct AttachmentReference2Builder<'a> {
    inner: AttachmentReference2,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl AttachmentReference2 {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> AttachmentReference2Builder<'a> {
        AttachmentReference2Builder {
            inner: AttachmentReference2 {
                s_type: StructureType::from_raw(1000109001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> AttachmentReference2Builder<'a> {
    #[inline]
    pub fn attachment(mut self, value: u32) -> Self {
        self.inner.attachment = value;
        self
    }
    #[inline]
    pub fn layout(mut self, value: ImageLayout) -> Self {
        self.inner.layout = value;
        self
    }
    #[inline]
    pub fn aspect_mask(mut self, value: ImageAspectFlags) -> Self {
        self.inner.aspect_mask = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`AttachmentReference2`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsAttachmentReference2>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for AttachmentReference2Builder<'a> {
    type Target = AttachmentReference2;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for AttachmentReference2Builder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`SubpassDescription2`] with lifetime-tied pNext safety.
pub struct SubpassDescription2Builder<'a> {
    inner: SubpassDescription2,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl SubpassDescription2 {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> SubpassDescription2Builder<'a> {
        SubpassDescription2Builder {
            inner: SubpassDescription2 {
                s_type: StructureType::from_raw(1000109002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> SubpassDescription2Builder<'a> {
    #[inline]
    pub fn flags(mut self, value: SubpassDescriptionFlags) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn pipeline_bind_point(mut self, value: PipelineBindPoint) -> Self {
        self.inner.pipeline_bind_point = value;
        self
    }
    #[inline]
    pub fn view_mask(mut self, value: u32) -> Self {
        self.inner.view_mask = value;
        self
    }
    #[inline]
    pub fn input_attachments(mut self, slice: &'a [AttachmentReference2]) -> Self {
        self.inner.input_attachment_count = slice.len() as u32;
        self.inner.p_input_attachments = slice.as_ptr();
        self
    }
    #[inline]
    pub fn color_attachments(mut self, slice: &'a [AttachmentReference2]) -> Self {
        self.inner.color_attachment_count = slice.len() as u32;
        self.inner.p_color_attachments = slice.as_ptr();
        self
    }
    #[inline]
    pub fn resolve_attachments(mut self, slice: &'a [AttachmentReference2]) -> Self {
        self.inner.color_attachment_count = slice.len() as u32;
        self.inner.p_resolve_attachments = slice.as_ptr();
        self
    }
    #[inline]
    pub fn depth_stencil_attachment(mut self, value: &'a AttachmentReference2) -> Self {
        self.inner.p_depth_stencil_attachment = value;
        self
    }
    #[inline]
    pub fn preserve_attachments(mut self, slice: &'a [u32]) -> Self {
        self.inner.preserve_attachment_count = slice.len() as u32;
        self.inner.p_preserve_attachments = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`SubpassDescription2`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsSubpassDescription2>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for SubpassDescription2Builder<'a> {
    type Target = SubpassDescription2;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for SubpassDescription2Builder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`SubpassDependency2`] with lifetime-tied pNext safety.
pub struct SubpassDependency2Builder<'a> {
    inner: SubpassDependency2,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl SubpassDependency2 {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> SubpassDependency2Builder<'a> {
        SubpassDependency2Builder {
            inner: SubpassDependency2 {
                s_type: StructureType::from_raw(1000109003i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> SubpassDependency2Builder<'a> {
    #[inline]
    pub fn src_subpass(mut self, value: u32) -> Self {
        self.inner.src_subpass = value;
        self
    }
    #[inline]
    pub fn dst_subpass(mut self, value: u32) -> Self {
        self.inner.dst_subpass = value;
        self
    }
    #[inline]
    pub fn src_stage_mask(mut self, value: PipelineStageFlags) -> Self {
        self.inner.src_stage_mask = value;
        self
    }
    #[inline]
    pub fn dst_stage_mask(mut self, value: PipelineStageFlags) -> Self {
        self.inner.dst_stage_mask = value;
        self
    }
    #[inline]
    pub fn src_access_mask(mut self, value: AccessFlags) -> Self {
        self.inner.src_access_mask = value;
        self
    }
    #[inline]
    pub fn dst_access_mask(mut self, value: AccessFlags) -> Self {
        self.inner.dst_access_mask = value;
        self
    }
    #[inline]
    pub fn dependency_flags(mut self, value: DependencyFlags) -> Self {
        self.inner.dependency_flags = value;
        self
    }
    #[inline]
    pub fn view_offset(mut self, value: i32) -> Self {
        self.inner.view_offset = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`SubpassDependency2`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsSubpassDependency2>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for SubpassDependency2Builder<'a> {
    type Target = SubpassDependency2;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for SubpassDependency2Builder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`RenderPassCreateInfo2`] with lifetime-tied pNext safety.
pub struct RenderPassCreateInfo2Builder<'a> {
    inner: RenderPassCreateInfo2,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl RenderPassCreateInfo2 {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> RenderPassCreateInfo2Builder<'a> {
        RenderPassCreateInfo2Builder {
            inner: RenderPassCreateInfo2 {
                s_type: StructureType::from_raw(1000109004i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> RenderPassCreateInfo2Builder<'a> {
    #[inline]
    pub fn flags(mut self, value: RenderPassCreateFlags) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn attachments(mut self, slice: &'a [AttachmentDescription2]) -> Self {
        self.inner.attachment_count = slice.len() as u32;
        self.inner.p_attachments = slice.as_ptr();
        self
    }
    #[inline]
    pub fn subpasses(mut self, slice: &'a [SubpassDescription2]) -> Self {
        self.inner.subpass_count = slice.len() as u32;
        self.inner.p_subpasses = slice.as_ptr();
        self
    }
    #[inline]
    pub fn dependencies(mut self, slice: &'a [SubpassDependency2]) -> Self {
        self.inner.dependency_count = slice.len() as u32;
        self.inner.p_dependencies = slice.as_ptr();
        self
    }
    #[inline]
    pub fn correlated_view_masks(mut self, slice: &'a [u32]) -> Self {
        self.inner.correlated_view_mask_count = slice.len() as u32;
        self.inner.p_correlated_view_masks = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`RenderPassCreateInfo2`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsRenderPassCreateInfo2>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for RenderPassCreateInfo2Builder<'a> {
    type Target = RenderPassCreateInfo2;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for RenderPassCreateInfo2Builder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`SubpassBeginInfo`] with lifetime-tied pNext safety.
pub struct SubpassBeginInfoBuilder<'a> {
    inner: SubpassBeginInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl SubpassBeginInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> SubpassBeginInfoBuilder<'a> {
        SubpassBeginInfoBuilder {
            inner: SubpassBeginInfo {
                s_type: StructureType::from_raw(1000109005i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> SubpassBeginInfoBuilder<'a> {
    #[inline]
    pub fn contents(mut self, value: SubpassContents) -> Self {
        self.inner.contents = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`SubpassBeginInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsSubpassBeginInfo>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for SubpassBeginInfoBuilder<'a> {
    type Target = SubpassBeginInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for SubpassBeginInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`SubpassEndInfo`] with lifetime-tied pNext safety.
pub struct SubpassEndInfoBuilder<'a> {
    inner: SubpassEndInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl SubpassEndInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> SubpassEndInfoBuilder<'a> {
        SubpassEndInfoBuilder {
            inner: SubpassEndInfo {
                s_type: StructureType::from_raw(1000109006i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> SubpassEndInfoBuilder<'a> {
    ///Prepend a struct to the pNext chain. See [`SubpassEndInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsSubpassEndInfo>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for SubpassEndInfoBuilder<'a> {
    type Target = SubpassEndInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for SubpassEndInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceTimelineSemaphoreFeatures`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceTimelineSemaphoreFeaturesBuilder<'a> {
    inner: PhysicalDeviceTimelineSemaphoreFeatures,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceTimelineSemaphoreFeatures {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceTimelineSemaphoreFeaturesBuilder<'a> {
        PhysicalDeviceTimelineSemaphoreFeaturesBuilder {
            inner: PhysicalDeviceTimelineSemaphoreFeatures {
                s_type: StructureType::from_raw(1000207000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceTimelineSemaphoreFeaturesBuilder<'a> {
    #[inline]
    pub fn timeline_semaphore(mut self, value: bool) -> Self {
        self.inner.timeline_semaphore = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceTimelineSemaphoreFeatures`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceTimelineSemaphoreFeatures>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceTimelineSemaphoreFeaturesBuilder<'a> {
    type Target = PhysicalDeviceTimelineSemaphoreFeatures;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceTimelineSemaphoreFeaturesBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceTimelineSemaphoreProperties`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceTimelineSemaphorePropertiesBuilder<'a> {
    inner: PhysicalDeviceTimelineSemaphoreProperties,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceTimelineSemaphoreProperties {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceTimelineSemaphorePropertiesBuilder<'a> {
        PhysicalDeviceTimelineSemaphorePropertiesBuilder {
            inner: PhysicalDeviceTimelineSemaphoreProperties {
                s_type: StructureType::from_raw(1000207001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceTimelineSemaphorePropertiesBuilder<'a> {
    #[inline]
    pub fn max_timeline_semaphore_value_difference(mut self, value: u64) -> Self {
        self.inner.max_timeline_semaphore_value_difference = value;
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceTimelineSemaphorePropertiesBuilder<'a> {
    type Target = PhysicalDeviceTimelineSemaphoreProperties;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceTimelineSemaphorePropertiesBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`SemaphoreTypeCreateInfo`] with lifetime-tied pNext safety.
pub struct SemaphoreTypeCreateInfoBuilder<'a> {
    inner: SemaphoreTypeCreateInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl SemaphoreTypeCreateInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> SemaphoreTypeCreateInfoBuilder<'a> {
        SemaphoreTypeCreateInfoBuilder {
            inner: SemaphoreTypeCreateInfo {
                s_type: StructureType::from_raw(1000207002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> SemaphoreTypeCreateInfoBuilder<'a> {
    #[inline]
    pub fn semaphore_type(mut self, value: SemaphoreType) -> Self {
        self.inner.semaphore_type = value;
        self
    }
    #[inline]
    pub fn initial_value(mut self, value: u64) -> Self {
        self.inner.initial_value = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`SemaphoreTypeCreateInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsSemaphoreTypeCreateInfo>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for SemaphoreTypeCreateInfoBuilder<'a> {
    type Target = SemaphoreTypeCreateInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for SemaphoreTypeCreateInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`TimelineSemaphoreSubmitInfo`] with lifetime-tied pNext safety.
pub struct TimelineSemaphoreSubmitInfoBuilder<'a> {
    inner: TimelineSemaphoreSubmitInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl TimelineSemaphoreSubmitInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> TimelineSemaphoreSubmitInfoBuilder<'a> {
        TimelineSemaphoreSubmitInfoBuilder {
            inner: TimelineSemaphoreSubmitInfo {
                s_type: StructureType::from_raw(1000207003i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> TimelineSemaphoreSubmitInfoBuilder<'a> {
    #[inline]
    pub fn wait_semaphore_value_count(mut self, value: u32) -> Self {
        self.inner.wait_semaphore_value_count = value;
        self
    }
    #[inline]
    pub fn wait_semaphore_values(mut self, slice: &'a [u64]) -> Self {
        self.inner.wait_semaphore_value_count = slice.len() as u32;
        self.inner.p_wait_semaphore_values = slice.as_ptr();
        self
    }
    #[inline]
    pub fn signal_semaphore_value_count(mut self, value: u32) -> Self {
        self.inner.signal_semaphore_value_count = value;
        self
    }
    #[inline]
    pub fn signal_semaphore_values(mut self, slice: &'a [u64]) -> Self {
        self.inner.signal_semaphore_value_count = slice.len() as u32;
        self.inner.p_signal_semaphore_values = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`TimelineSemaphoreSubmitInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsTimelineSemaphoreSubmitInfo>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for TimelineSemaphoreSubmitInfoBuilder<'a> {
    type Target = TimelineSemaphoreSubmitInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for TimelineSemaphoreSubmitInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`SemaphoreWaitInfo`] with lifetime-tied pNext safety.
pub struct SemaphoreWaitInfoBuilder<'a> {
    inner: SemaphoreWaitInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl SemaphoreWaitInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> SemaphoreWaitInfoBuilder<'a> {
        SemaphoreWaitInfoBuilder {
            inner: SemaphoreWaitInfo {
                s_type: StructureType::from_raw(1000207004i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> SemaphoreWaitInfoBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: SemaphoreWaitFlags) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn semaphores(mut self, slice: &'a [Semaphore]) -> Self {
        self.inner.semaphore_count = slice.len() as u32;
        self.inner.p_semaphores = slice.as_ptr();
        self
    }
    #[inline]
    pub fn values(mut self, slice: &'a [u64]) -> Self {
        self.inner.semaphore_count = slice.len() as u32;
        self.inner.p_values = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`SemaphoreWaitInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsSemaphoreWaitInfo>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for SemaphoreWaitInfoBuilder<'a> {
    type Target = SemaphoreWaitInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for SemaphoreWaitInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`SemaphoreSignalInfo`] with lifetime-tied pNext safety.
pub struct SemaphoreSignalInfoBuilder<'a> {
    inner: SemaphoreSignalInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl SemaphoreSignalInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> SemaphoreSignalInfoBuilder<'a> {
        SemaphoreSignalInfoBuilder {
            inner: SemaphoreSignalInfo {
                s_type: StructureType::from_raw(1000207005i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> SemaphoreSignalInfoBuilder<'a> {
    #[inline]
    pub fn semaphore(mut self, value: Semaphore) -> Self {
        self.inner.semaphore = value;
        self
    }
    #[inline]
    pub fn value(mut self, value: u64) -> Self {
        self.inner.value = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`SemaphoreSignalInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsSemaphoreSignalInfo>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for SemaphoreSignalInfoBuilder<'a> {
    type Target = SemaphoreSignalInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for SemaphoreSignalInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VertexInputBindingDivisorDescription`].
pub struct VertexInputBindingDivisorDescriptionBuilder {
    inner: VertexInputBindingDivisorDescription,
}
impl VertexInputBindingDivisorDescription {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> VertexInputBindingDivisorDescriptionBuilder {
        VertexInputBindingDivisorDescriptionBuilder {
            inner: VertexInputBindingDivisorDescription {
                ..Default::default()
            },
        }
    }
}
impl VertexInputBindingDivisorDescriptionBuilder {
    #[inline]
    pub fn binding(mut self, value: u32) -> Self {
        self.inner.binding = value;
        self
    }
    #[inline]
    pub fn divisor(mut self, value: u32) -> Self {
        self.inner.divisor = value;
        self
    }
}
impl core::ops::Deref for VertexInputBindingDivisorDescriptionBuilder {
    type Target = VertexInputBindingDivisorDescription;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for VertexInputBindingDivisorDescriptionBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PipelineVertexInputDivisorStateCreateInfo`] with lifetime-tied pNext safety.
pub struct PipelineVertexInputDivisorStateCreateInfoBuilder<'a> {
    inner: PipelineVertexInputDivisorStateCreateInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PipelineVertexInputDivisorStateCreateInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PipelineVertexInputDivisorStateCreateInfoBuilder<'a> {
        PipelineVertexInputDivisorStateCreateInfoBuilder {
            inner: PipelineVertexInputDivisorStateCreateInfo {
                s_type: StructureType::from_raw(1000190001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PipelineVertexInputDivisorStateCreateInfoBuilder<'a> {
    #[inline]
    pub fn vertex_binding_divisors(
        mut self,
        slice: &'a [VertexInputBindingDivisorDescription],
    ) -> Self {
        self.inner.vertex_binding_divisor_count = slice.len() as u32;
        self.inner.p_vertex_binding_divisors = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`PipelineVertexInputDivisorStateCreateInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPipelineVertexInputDivisorStateCreateInfo>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for PipelineVertexInputDivisorStateCreateInfoBuilder<'a> {
    type Target = PipelineVertexInputDivisorStateCreateInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PipelineVertexInputDivisorStateCreateInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceVertexAttributeDivisorPropertiesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceVertexAttributeDivisorPropertiesEXTBuilder<'a> {
    inner: PhysicalDeviceVertexAttributeDivisorPropertiesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceVertexAttributeDivisorPropertiesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceVertexAttributeDivisorPropertiesEXTBuilder<
        'a,
    > {
        PhysicalDeviceVertexAttributeDivisorPropertiesEXTBuilder {
            inner: PhysicalDeviceVertexAttributeDivisorPropertiesEXT {
                s_type: StructureType::from_raw(1000190000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceVertexAttributeDivisorPropertiesEXTBuilder<'a> {
    #[inline]
    pub fn max_vertex_attrib_divisor(mut self, value: u32) -> Self {
        self.inner.max_vertex_attrib_divisor = value;
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDeviceVertexAttributeDivisorPropertiesEXTBuilder<'a> {
    type Target = PhysicalDeviceVertexAttributeDivisorPropertiesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceVertexAttributeDivisorPropertiesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceVertexAttributeDivisorProperties`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceVertexAttributeDivisorPropertiesBuilder<'a> {
    inner: PhysicalDeviceVertexAttributeDivisorProperties,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceVertexAttributeDivisorProperties {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceVertexAttributeDivisorPropertiesBuilder<'a> {
        PhysicalDeviceVertexAttributeDivisorPropertiesBuilder {
            inner: PhysicalDeviceVertexAttributeDivisorProperties {
                s_type: StructureType::from_raw(1000525000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceVertexAttributeDivisorPropertiesBuilder<'a> {
    #[inline]
    pub fn max_vertex_attrib_divisor(mut self, value: u32) -> Self {
        self.inner.max_vertex_attrib_divisor = value;
        self
    }
    #[inline]
    pub fn supports_non_zero_first_instance(mut self, value: bool) -> Self {
        self.inner.supports_non_zero_first_instance = value as u32;
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceVertexAttributeDivisorPropertiesBuilder<'a> {
    type Target = PhysicalDeviceVertexAttributeDivisorProperties;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceVertexAttributeDivisorPropertiesBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDevicePCIBusInfoPropertiesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDevicePCIBusInfoPropertiesEXTBuilder<'a> {
    inner: PhysicalDevicePCIBusInfoPropertiesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDevicePCIBusInfoPropertiesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDevicePCIBusInfoPropertiesEXTBuilder<'a> {
        PhysicalDevicePCIBusInfoPropertiesEXTBuilder {
            inner: PhysicalDevicePCIBusInfoPropertiesEXT {
                s_type: StructureType::from_raw(1000212000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDevicePCIBusInfoPropertiesEXTBuilder<'a> {
    #[inline]
    pub fn pci_domain(mut self, value: u32) -> Self {
        self.inner.pci_domain = value;
        self
    }
    #[inline]
    pub fn pci_bus(mut self, value: u32) -> Self {
        self.inner.pci_bus = value;
        self
    }
    #[inline]
    pub fn pci_device(mut self, value: u32) -> Self {
        self.inner.pci_device = value;
        self
    }
    #[inline]
    pub fn pci_function(mut self, value: u32) -> Self {
        self.inner.pci_function = value;
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDevicePCIBusInfoPropertiesEXTBuilder<'a> {
    type Target = PhysicalDevicePCIBusInfoPropertiesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDevicePCIBusInfoPropertiesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ImportAndroidHardwareBufferInfoANDROID`] with lifetime-tied pNext safety.
pub struct ImportAndroidHardwareBufferInfoANDROIDBuilder<'a> {
    inner: ImportAndroidHardwareBufferInfoANDROID,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ImportAndroidHardwareBufferInfoANDROID {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ImportAndroidHardwareBufferInfoANDROIDBuilder<'a> {
        ImportAndroidHardwareBufferInfoANDROIDBuilder {
            inner: ImportAndroidHardwareBufferInfoANDROID {
                s_type: StructureType::from_raw(1000129003i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ImportAndroidHardwareBufferInfoANDROIDBuilder<'a> {
    #[inline]
    pub fn buffer(mut self, value: *mut core::ffi::c_void) -> Self {
        self.inner.buffer = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`ImportAndroidHardwareBufferInfoANDROID`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsImportAndroidHardwareBufferInfoANDROID>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for ImportAndroidHardwareBufferInfoANDROIDBuilder<'a> {
    type Target = ImportAndroidHardwareBufferInfoANDROID;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ImportAndroidHardwareBufferInfoANDROIDBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`AndroidHardwareBufferUsageANDROID`] with lifetime-tied pNext safety.
pub struct AndroidHardwareBufferUsageANDROIDBuilder<'a> {
    inner: AndroidHardwareBufferUsageANDROID,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl AndroidHardwareBufferUsageANDROID {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> AndroidHardwareBufferUsageANDROIDBuilder<'a> {
        AndroidHardwareBufferUsageANDROIDBuilder {
            inner: AndroidHardwareBufferUsageANDROID {
                s_type: StructureType::from_raw(1000129000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> AndroidHardwareBufferUsageANDROIDBuilder<'a> {
    #[inline]
    pub fn android_hardware_buffer_usage(mut self, value: u64) -> Self {
        self.inner.android_hardware_buffer_usage = value;
        self
    }
}
impl<'a> core::ops::Deref for AndroidHardwareBufferUsageANDROIDBuilder<'a> {
    type Target = AndroidHardwareBufferUsageANDROID;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for AndroidHardwareBufferUsageANDROIDBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`AndroidHardwareBufferPropertiesANDROID`] with lifetime-tied pNext safety.
pub struct AndroidHardwareBufferPropertiesANDROIDBuilder<'a> {
    inner: AndroidHardwareBufferPropertiesANDROID,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl AndroidHardwareBufferPropertiesANDROID {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> AndroidHardwareBufferPropertiesANDROIDBuilder<'a> {
        AndroidHardwareBufferPropertiesANDROIDBuilder {
            inner: AndroidHardwareBufferPropertiesANDROID {
                s_type: StructureType::from_raw(1000129001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> AndroidHardwareBufferPropertiesANDROIDBuilder<'a> {
    #[inline]
    pub fn allocation_size(mut self, value: u64) -> Self {
        self.inner.allocation_size = value;
        self
    }
    #[inline]
    pub fn memory_type_bits(mut self, value: u32) -> Self {
        self.inner.memory_type_bits = value;
        self
    }
}
impl<'a> core::ops::Deref for AndroidHardwareBufferPropertiesANDROIDBuilder<'a> {
    type Target = AndroidHardwareBufferPropertiesANDROID;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for AndroidHardwareBufferPropertiesANDROIDBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`MemoryGetAndroidHardwareBufferInfoANDROID`] with lifetime-tied pNext safety.
pub struct MemoryGetAndroidHardwareBufferInfoANDROIDBuilder<'a> {
    inner: MemoryGetAndroidHardwareBufferInfoANDROID,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl MemoryGetAndroidHardwareBufferInfoANDROID {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> MemoryGetAndroidHardwareBufferInfoANDROIDBuilder<'a> {
        MemoryGetAndroidHardwareBufferInfoANDROIDBuilder {
            inner: MemoryGetAndroidHardwareBufferInfoANDROID {
                s_type: StructureType::from_raw(1000129004i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> MemoryGetAndroidHardwareBufferInfoANDROIDBuilder<'a> {
    #[inline]
    pub fn memory(mut self, value: DeviceMemory) -> Self {
        self.inner.memory = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`MemoryGetAndroidHardwareBufferInfoANDROID`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsMemoryGetAndroidHardwareBufferInfoANDROID>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for MemoryGetAndroidHardwareBufferInfoANDROIDBuilder<'a> {
    type Target = MemoryGetAndroidHardwareBufferInfoANDROID;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for MemoryGetAndroidHardwareBufferInfoANDROIDBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`AndroidHardwareBufferFormatPropertiesANDROID`] with lifetime-tied pNext safety.
pub struct AndroidHardwareBufferFormatPropertiesANDROIDBuilder<'a> {
    inner: AndroidHardwareBufferFormatPropertiesANDROID,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl AndroidHardwareBufferFormatPropertiesANDROID {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> AndroidHardwareBufferFormatPropertiesANDROIDBuilder<'a> {
        AndroidHardwareBufferFormatPropertiesANDROIDBuilder {
            inner: AndroidHardwareBufferFormatPropertiesANDROID {
                s_type: StructureType::from_raw(1000129002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> AndroidHardwareBufferFormatPropertiesANDROIDBuilder<'a> {
    #[inline]
    pub fn format(mut self, value: Format) -> Self {
        self.inner.format = value;
        self
    }
    #[inline]
    pub fn external_format(mut self, value: u64) -> Self {
        self.inner.external_format = value;
        self
    }
    #[inline]
    pub fn format_features(mut self, value: FormatFeatureFlags) -> Self {
        self.inner.format_features = value;
        self
    }
    #[inline]
    pub fn sampler_ycbcr_conversion_components(
        mut self,
        value: ComponentMapping,
    ) -> Self {
        self.inner.sampler_ycbcr_conversion_components = value;
        self
    }
    #[inline]
    pub fn suggested_ycbcr_model(mut self, value: SamplerYcbcrModelConversion) -> Self {
        self.inner.suggested_ycbcr_model = value;
        self
    }
    #[inline]
    pub fn suggested_ycbcr_range(mut self, value: SamplerYcbcrRange) -> Self {
        self.inner.suggested_ycbcr_range = value;
        self
    }
    #[inline]
    pub fn suggested_x_chroma_offset(mut self, value: ChromaLocation) -> Self {
        self.inner.suggested_x_chroma_offset = value;
        self
    }
    #[inline]
    pub fn suggested_y_chroma_offset(mut self, value: ChromaLocation) -> Self {
        self.inner.suggested_y_chroma_offset = value;
        self
    }
}
impl<'a> core::ops::Deref for AndroidHardwareBufferFormatPropertiesANDROIDBuilder<'a> {
    type Target = AndroidHardwareBufferFormatPropertiesANDROID;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for AndroidHardwareBufferFormatPropertiesANDROIDBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`CommandBufferInheritanceConditionalRenderingInfoEXT`] with lifetime-tied pNext safety.
pub struct CommandBufferInheritanceConditionalRenderingInfoEXTBuilder<'a> {
    inner: CommandBufferInheritanceConditionalRenderingInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl CommandBufferInheritanceConditionalRenderingInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> CommandBufferInheritanceConditionalRenderingInfoEXTBuilder<
        'a,
    > {
        CommandBufferInheritanceConditionalRenderingInfoEXTBuilder {
            inner: CommandBufferInheritanceConditionalRenderingInfoEXT {
                s_type: StructureType::from_raw(1000081000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> CommandBufferInheritanceConditionalRenderingInfoEXTBuilder<'a> {
    #[inline]
    pub fn conditional_rendering_enable(mut self, value: bool) -> Self {
        self.inner.conditional_rendering_enable = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`CommandBufferInheritanceConditionalRenderingInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsCommandBufferInheritanceConditionalRenderingInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref
for CommandBufferInheritanceConditionalRenderingInfoEXTBuilder<'a> {
    type Target = CommandBufferInheritanceConditionalRenderingInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for CommandBufferInheritanceConditionalRenderingInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ExternalFormatANDROID`] with lifetime-tied pNext safety.
pub struct ExternalFormatANDROIDBuilder<'a> {
    inner: ExternalFormatANDROID,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ExternalFormatANDROID {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ExternalFormatANDROIDBuilder<'a> {
        ExternalFormatANDROIDBuilder {
            inner: ExternalFormatANDROID {
                s_type: StructureType::from_raw(1000129005i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ExternalFormatANDROIDBuilder<'a> {
    #[inline]
    pub fn external_format(mut self, value: u64) -> Self {
        self.inner.external_format = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`ExternalFormatANDROID`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsExternalFormatANDROID>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for ExternalFormatANDROIDBuilder<'a> {
    type Target = ExternalFormatANDROID;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ExternalFormatANDROIDBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDevice8BitStorageFeatures`] with lifetime-tied pNext safety.
pub struct PhysicalDevice8BitStorageFeaturesBuilder<'a> {
    inner: PhysicalDevice8BitStorageFeatures,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDevice8BitStorageFeatures {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDevice8BitStorageFeaturesBuilder<'a> {
        PhysicalDevice8BitStorageFeaturesBuilder {
            inner: PhysicalDevice8BitStorageFeatures {
                s_type: StructureType::from_raw(1000177000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDevice8BitStorageFeaturesBuilder<'a> {
    #[inline]
    pub fn storage_buffer8_bit_access(mut self, value: bool) -> Self {
        self.inner.storage_buffer8_bit_access = value as u32;
        self
    }
    #[inline]
    pub fn uniform_and_storage_buffer8_bit_access(mut self, value: bool) -> Self {
        self.inner.uniform_and_storage_buffer8_bit_access = value as u32;
        self
    }
    #[inline]
    pub fn storage_push_constant8(mut self, value: bool) -> Self {
        self.inner.storage_push_constant8 = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDevice8BitStorageFeatures`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDevice8BitStorageFeatures>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDevice8BitStorageFeaturesBuilder<'a> {
    type Target = PhysicalDevice8BitStorageFeatures;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDevice8BitStorageFeaturesBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceConditionalRenderingFeaturesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceConditionalRenderingFeaturesEXTBuilder<'a> {
    inner: PhysicalDeviceConditionalRenderingFeaturesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceConditionalRenderingFeaturesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceConditionalRenderingFeaturesEXTBuilder<'a> {
        PhysicalDeviceConditionalRenderingFeaturesEXTBuilder {
            inner: PhysicalDeviceConditionalRenderingFeaturesEXT {
                s_type: StructureType::from_raw(1000081001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceConditionalRenderingFeaturesEXTBuilder<'a> {
    #[inline]
    pub fn conditional_rendering(mut self, value: bool) -> Self {
        self.inner.conditional_rendering = value as u32;
        self
    }
    #[inline]
    pub fn inherited_conditional_rendering(mut self, value: bool) -> Self {
        self.inner.inherited_conditional_rendering = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceConditionalRenderingFeaturesEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceConditionalRenderingFeaturesEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceConditionalRenderingFeaturesEXTBuilder<'a> {
    type Target = PhysicalDeviceConditionalRenderingFeaturesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceConditionalRenderingFeaturesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceVulkanMemoryModelFeatures`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceVulkanMemoryModelFeaturesBuilder<'a> {
    inner: PhysicalDeviceVulkanMemoryModelFeatures,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceVulkanMemoryModelFeatures {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceVulkanMemoryModelFeaturesBuilder<'a> {
        PhysicalDeviceVulkanMemoryModelFeaturesBuilder {
            inner: PhysicalDeviceVulkanMemoryModelFeatures {
                s_type: StructureType::from_raw(1000211000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceVulkanMemoryModelFeaturesBuilder<'a> {
    #[inline]
    pub fn vulkan_memory_model(mut self, value: bool) -> Self {
        self.inner.vulkan_memory_model = value as u32;
        self
    }
    #[inline]
    pub fn vulkan_memory_model_device_scope(mut self, value: bool) -> Self {
        self.inner.vulkan_memory_model_device_scope = value as u32;
        self
    }
    #[inline]
    pub fn vulkan_memory_model_availability_visibility_chains(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.vulkan_memory_model_availability_visibility_chains = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceVulkanMemoryModelFeatures`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceVulkanMemoryModelFeatures>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceVulkanMemoryModelFeaturesBuilder<'a> {
    type Target = PhysicalDeviceVulkanMemoryModelFeatures;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceVulkanMemoryModelFeaturesBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceShaderAtomicInt64Features`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceShaderAtomicInt64FeaturesBuilder<'a> {
    inner: PhysicalDeviceShaderAtomicInt64Features,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceShaderAtomicInt64Features {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceShaderAtomicInt64FeaturesBuilder<'a> {
        PhysicalDeviceShaderAtomicInt64FeaturesBuilder {
            inner: PhysicalDeviceShaderAtomicInt64Features {
                s_type: StructureType::from_raw(1000180000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceShaderAtomicInt64FeaturesBuilder<'a> {
    #[inline]
    pub fn shader_buffer_int64_atomics(mut self, value: bool) -> Self {
        self.inner.shader_buffer_int64_atomics = value as u32;
        self
    }
    #[inline]
    pub fn shader_shared_int64_atomics(mut self, value: bool) -> Self {
        self.inner.shader_shared_int64_atomics = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceShaderAtomicInt64Features`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceShaderAtomicInt64Features>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceShaderAtomicInt64FeaturesBuilder<'a> {
    type Target = PhysicalDeviceShaderAtomicInt64Features;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceShaderAtomicInt64FeaturesBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceShaderAtomicFloatFeaturesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'a> {
    inner: PhysicalDeviceShaderAtomicFloatFeaturesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceShaderAtomicFloatFeaturesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'a> {
        PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder {
            inner: PhysicalDeviceShaderAtomicFloatFeaturesEXT {
                s_type: StructureType::from_raw(1000260000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'a> {
    #[inline]
    pub fn shader_buffer_float32_atomics(mut self, value: bool) -> Self {
        self.inner.shader_buffer_float32_atomics = value as u32;
        self
    }
    #[inline]
    pub fn shader_buffer_float32_atomic_add(mut self, value: bool) -> Self {
        self.inner.shader_buffer_float32_atomic_add = value as u32;
        self
    }
    #[inline]
    pub fn shader_buffer_float64_atomics(mut self, value: bool) -> Self {
        self.inner.shader_buffer_float64_atomics = value as u32;
        self
    }
    #[inline]
    pub fn shader_buffer_float64_atomic_add(mut self, value: bool) -> Self {
        self.inner.shader_buffer_float64_atomic_add = value as u32;
        self
    }
    #[inline]
    pub fn shader_shared_float32_atomics(mut self, value: bool) -> Self {
        self.inner.shader_shared_float32_atomics = value as u32;
        self
    }
    #[inline]
    pub fn shader_shared_float32_atomic_add(mut self, value: bool) -> Self {
        self.inner.shader_shared_float32_atomic_add = value as u32;
        self
    }
    #[inline]
    pub fn shader_shared_float64_atomics(mut self, value: bool) -> Self {
        self.inner.shader_shared_float64_atomics = value as u32;
        self
    }
    #[inline]
    pub fn shader_shared_float64_atomic_add(mut self, value: bool) -> Self {
        self.inner.shader_shared_float64_atomic_add = value as u32;
        self
    }
    #[inline]
    pub fn shader_image_float32_atomics(mut self, value: bool) -> Self {
        self.inner.shader_image_float32_atomics = value as u32;
        self
    }
    #[inline]
    pub fn shader_image_float32_atomic_add(mut self, value: bool) -> Self {
        self.inner.shader_image_float32_atomic_add = value as u32;
        self
    }
    #[inline]
    pub fn sparse_image_float32_atomics(mut self, value: bool) -> Self {
        self.inner.sparse_image_float32_atomics = value as u32;
        self
    }
    #[inline]
    pub fn sparse_image_float32_atomic_add(mut self, value: bool) -> Self {
        self.inner.sparse_image_float32_atomic_add = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceShaderAtomicFloatFeaturesEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceShaderAtomicFloatFeaturesEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'a> {
    type Target = PhysicalDeviceShaderAtomicFloatFeaturesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceShaderAtomicFloat2FeaturesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceShaderAtomicFloat2FeaturesEXTBuilder<'a> {
    inner: PhysicalDeviceShaderAtomicFloat2FeaturesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceShaderAtomicFloat2FeaturesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceShaderAtomicFloat2FeaturesEXTBuilder<'a> {
        PhysicalDeviceShaderAtomicFloat2FeaturesEXTBuilder {
            inner: PhysicalDeviceShaderAtomicFloat2FeaturesEXT {
                s_type: StructureType::from_raw(1000273000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceShaderAtomicFloat2FeaturesEXTBuilder<'a> {
    #[inline]
    pub fn shader_buffer_float16_atomics(mut self, value: bool) -> Self {
        self.inner.shader_buffer_float16_atomics = value as u32;
        self
    }
    #[inline]
    pub fn shader_buffer_float16_atomic_add(mut self, value: bool) -> Self {
        self.inner.shader_buffer_float16_atomic_add = value as u32;
        self
    }
    #[inline]
    pub fn shader_buffer_float16_atomic_min_max(mut self, value: bool) -> Self {
        self.inner.shader_buffer_float16_atomic_min_max = value as u32;
        self
    }
    #[inline]
    pub fn shader_buffer_float32_atomic_min_max(mut self, value: bool) -> Self {
        self.inner.shader_buffer_float32_atomic_min_max = value as u32;
        self
    }
    #[inline]
    pub fn shader_buffer_float64_atomic_min_max(mut self, value: bool) -> Self {
        self.inner.shader_buffer_float64_atomic_min_max = value as u32;
        self
    }
    #[inline]
    pub fn shader_shared_float16_atomics(mut self, value: bool) -> Self {
        self.inner.shader_shared_float16_atomics = value as u32;
        self
    }
    #[inline]
    pub fn shader_shared_float16_atomic_add(mut self, value: bool) -> Self {
        self.inner.shader_shared_float16_atomic_add = value as u32;
        self
    }
    #[inline]
    pub fn shader_shared_float16_atomic_min_max(mut self, value: bool) -> Self {
        self.inner.shader_shared_float16_atomic_min_max = value as u32;
        self
    }
    #[inline]
    pub fn shader_shared_float32_atomic_min_max(mut self, value: bool) -> Self {
        self.inner.shader_shared_float32_atomic_min_max = value as u32;
        self
    }
    #[inline]
    pub fn shader_shared_float64_atomic_min_max(mut self, value: bool) -> Self {
        self.inner.shader_shared_float64_atomic_min_max = value as u32;
        self
    }
    #[inline]
    pub fn shader_image_float32_atomic_min_max(mut self, value: bool) -> Self {
        self.inner.shader_image_float32_atomic_min_max = value as u32;
        self
    }
    #[inline]
    pub fn sparse_image_float32_atomic_min_max(mut self, value: bool) -> Self {
        self.inner.sparse_image_float32_atomic_min_max = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceShaderAtomicFloat2FeaturesEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceShaderAtomicFloat2FeaturesEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceShaderAtomicFloat2FeaturesEXTBuilder<'a> {
    type Target = PhysicalDeviceShaderAtomicFloat2FeaturesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceShaderAtomicFloat2FeaturesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceVertexAttributeDivisorFeatures`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceVertexAttributeDivisorFeaturesBuilder<'a> {
    inner: PhysicalDeviceVertexAttributeDivisorFeatures,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceVertexAttributeDivisorFeatures {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceVertexAttributeDivisorFeaturesBuilder<'a> {
        PhysicalDeviceVertexAttributeDivisorFeaturesBuilder {
            inner: PhysicalDeviceVertexAttributeDivisorFeatures {
                s_type: StructureType::from_raw(1000190002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceVertexAttributeDivisorFeaturesBuilder<'a> {
    #[inline]
    pub fn vertex_attribute_instance_rate_divisor(mut self, value: bool) -> Self {
        self.inner.vertex_attribute_instance_rate_divisor = value as u32;
        self
    }
    #[inline]
    pub fn vertex_attribute_instance_rate_zero_divisor(mut self, value: bool) -> Self {
        self.inner.vertex_attribute_instance_rate_zero_divisor = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceVertexAttributeDivisorFeatures`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceVertexAttributeDivisorFeatures>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceVertexAttributeDivisorFeaturesBuilder<'a> {
    type Target = PhysicalDeviceVertexAttributeDivisorFeatures;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceVertexAttributeDivisorFeaturesBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`QueueFamilyCheckpointPropertiesNV`] with lifetime-tied pNext safety.
pub struct QueueFamilyCheckpointPropertiesNVBuilder<'a> {
    inner: QueueFamilyCheckpointPropertiesNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl QueueFamilyCheckpointPropertiesNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> QueueFamilyCheckpointPropertiesNVBuilder<'a> {
        QueueFamilyCheckpointPropertiesNVBuilder {
            inner: QueueFamilyCheckpointPropertiesNV {
                s_type: StructureType::from_raw(1000206001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> QueueFamilyCheckpointPropertiesNVBuilder<'a> {
    #[inline]
    pub fn checkpoint_execution_stage_mask(mut self, value: PipelineStageFlags) -> Self {
        self.inner.checkpoint_execution_stage_mask = value;
        self
    }
}
impl<'a> core::ops::Deref for QueueFamilyCheckpointPropertiesNVBuilder<'a> {
    type Target = QueueFamilyCheckpointPropertiesNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for QueueFamilyCheckpointPropertiesNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`CheckpointDataNV`] with lifetime-tied pNext safety.
pub struct CheckpointDataNVBuilder<'a> {
    inner: CheckpointDataNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl CheckpointDataNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> CheckpointDataNVBuilder<'a> {
        CheckpointDataNVBuilder {
            inner: CheckpointDataNV {
                s_type: StructureType::from_raw(1000206000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> CheckpointDataNVBuilder<'a> {
    #[inline]
    pub fn stage(mut self, value: PipelineStageFlagBits) -> Self {
        self.inner.stage = value;
        self
    }
    #[inline]
    pub fn checkpoint_marker(mut self, value: *mut core::ffi::c_void) -> Self {
        self.inner.p_checkpoint_marker = value;
        self
    }
}
impl<'a> core::ops::Deref for CheckpointDataNVBuilder<'a> {
    type Target = CheckpointDataNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for CheckpointDataNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceDepthStencilResolveProperties`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceDepthStencilResolvePropertiesBuilder<'a> {
    inner: PhysicalDeviceDepthStencilResolveProperties,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceDepthStencilResolveProperties {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceDepthStencilResolvePropertiesBuilder<'a> {
        PhysicalDeviceDepthStencilResolvePropertiesBuilder {
            inner: PhysicalDeviceDepthStencilResolveProperties {
                s_type: StructureType::from_raw(1000199000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceDepthStencilResolvePropertiesBuilder<'a> {
    #[inline]
    pub fn supported_depth_resolve_modes(mut self, value: ResolveModeFlags) -> Self {
        self.inner.supported_depth_resolve_modes = value;
        self
    }
    #[inline]
    pub fn supported_stencil_resolve_modes(mut self, value: ResolveModeFlags) -> Self {
        self.inner.supported_stencil_resolve_modes = value;
        self
    }
    #[inline]
    pub fn independent_resolve_none(mut self, value: bool) -> Self {
        self.inner.independent_resolve_none = value as u32;
        self
    }
    #[inline]
    pub fn independent_resolve(mut self, value: bool) -> Self {
        self.inner.independent_resolve = value as u32;
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceDepthStencilResolvePropertiesBuilder<'a> {
    type Target = PhysicalDeviceDepthStencilResolveProperties;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceDepthStencilResolvePropertiesBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`SubpassDescriptionDepthStencilResolve`] with lifetime-tied pNext safety.
pub struct SubpassDescriptionDepthStencilResolveBuilder<'a> {
    inner: SubpassDescriptionDepthStencilResolve,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl SubpassDescriptionDepthStencilResolve {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> SubpassDescriptionDepthStencilResolveBuilder<'a> {
        SubpassDescriptionDepthStencilResolveBuilder {
            inner: SubpassDescriptionDepthStencilResolve {
                s_type: StructureType::from_raw(1000199001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> SubpassDescriptionDepthStencilResolveBuilder<'a> {
    #[inline]
    pub fn depth_resolve_mode(mut self, value: ResolveModeFlagBits) -> Self {
        self.inner.depth_resolve_mode = value;
        self
    }
    #[inline]
    pub fn stencil_resolve_mode(mut self, value: ResolveModeFlagBits) -> Self {
        self.inner.stencil_resolve_mode = value;
        self
    }
    #[inline]
    pub fn depth_stencil_resolve_attachment(
        mut self,
        value: &'a AttachmentReference2,
    ) -> Self {
        self.inner.p_depth_stencil_resolve_attachment = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`SubpassDescriptionDepthStencilResolve`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsSubpassDescriptionDepthStencilResolve>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for SubpassDescriptionDepthStencilResolveBuilder<'a> {
    type Target = SubpassDescriptionDepthStencilResolve;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for SubpassDescriptionDepthStencilResolveBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ImageViewASTCDecodeModeEXT`] with lifetime-tied pNext safety.
pub struct ImageViewASTCDecodeModeEXTBuilder<'a> {
    inner: ImageViewASTCDecodeModeEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ImageViewASTCDecodeModeEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ImageViewASTCDecodeModeEXTBuilder<'a> {
        ImageViewASTCDecodeModeEXTBuilder {
            inner: ImageViewASTCDecodeModeEXT {
                s_type: StructureType::from_raw(1000067000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ImageViewASTCDecodeModeEXTBuilder<'a> {
    #[inline]
    pub fn decode_mode(mut self, value: Format) -> Self {
        self.inner.decode_mode = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`ImageViewASTCDecodeModeEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsImageViewASTCDecodeModeEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for ImageViewASTCDecodeModeEXTBuilder<'a> {
    type Target = ImageViewASTCDecodeModeEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ImageViewASTCDecodeModeEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceASTCDecodeFeaturesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceASTCDecodeFeaturesEXTBuilder<'a> {
    inner: PhysicalDeviceASTCDecodeFeaturesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceASTCDecodeFeaturesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceASTCDecodeFeaturesEXTBuilder<'a> {
        PhysicalDeviceASTCDecodeFeaturesEXTBuilder {
            inner: PhysicalDeviceASTCDecodeFeaturesEXT {
                s_type: StructureType::from_raw(1000067001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceASTCDecodeFeaturesEXTBuilder<'a> {
    #[inline]
    pub fn decode_mode_shared_exponent(mut self, value: bool) -> Self {
        self.inner.decode_mode_shared_exponent = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceASTCDecodeFeaturesEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceASTCDecodeFeaturesEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceASTCDecodeFeaturesEXTBuilder<'a> {
    type Target = PhysicalDeviceASTCDecodeFeaturesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceASTCDecodeFeaturesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceTransformFeedbackFeaturesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceTransformFeedbackFeaturesEXTBuilder<'a> {
    inner: PhysicalDeviceTransformFeedbackFeaturesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceTransformFeedbackFeaturesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceTransformFeedbackFeaturesEXTBuilder<'a> {
        PhysicalDeviceTransformFeedbackFeaturesEXTBuilder {
            inner: PhysicalDeviceTransformFeedbackFeaturesEXT {
                s_type: StructureType::from_raw(1000028000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceTransformFeedbackFeaturesEXTBuilder<'a> {
    #[inline]
    pub fn transform_feedback(mut self, value: bool) -> Self {
        self.inner.transform_feedback = value as u32;
        self
    }
    #[inline]
    pub fn geometry_streams(mut self, value: bool) -> Self {
        self.inner.geometry_streams = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceTransformFeedbackFeaturesEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceTransformFeedbackFeaturesEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceTransformFeedbackFeaturesEXTBuilder<'a> {
    type Target = PhysicalDeviceTransformFeedbackFeaturesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceTransformFeedbackFeaturesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceTransformFeedbackPropertiesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceTransformFeedbackPropertiesEXTBuilder<'a> {
    inner: PhysicalDeviceTransformFeedbackPropertiesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceTransformFeedbackPropertiesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceTransformFeedbackPropertiesEXTBuilder<'a> {
        PhysicalDeviceTransformFeedbackPropertiesEXTBuilder {
            inner: PhysicalDeviceTransformFeedbackPropertiesEXT {
                s_type: StructureType::from_raw(1000028001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceTransformFeedbackPropertiesEXTBuilder<'a> {
    #[inline]
    pub fn max_transform_feedback_streams(mut self, value: u32) -> Self {
        self.inner.max_transform_feedback_streams = value;
        self
    }
    #[inline]
    pub fn max_transform_feedback_buffers(mut self, value: u32) -> Self {
        self.inner.max_transform_feedback_buffers = value;
        self
    }
    #[inline]
    pub fn max_transform_feedback_buffer_size(mut self, value: u64) -> Self {
        self.inner.max_transform_feedback_buffer_size = value;
        self
    }
    #[inline]
    pub fn max_transform_feedback_stream_data_size(mut self, value: u32) -> Self {
        self.inner.max_transform_feedback_stream_data_size = value;
        self
    }
    #[inline]
    pub fn max_transform_feedback_buffer_data_size(mut self, value: u32) -> Self {
        self.inner.max_transform_feedback_buffer_data_size = value;
        self
    }
    #[inline]
    pub fn max_transform_feedback_buffer_data_stride(mut self, value: u32) -> Self {
        self.inner.max_transform_feedback_buffer_data_stride = value;
        self
    }
    #[inline]
    pub fn transform_feedback_queries(mut self, value: bool) -> Self {
        self.inner.transform_feedback_queries = value as u32;
        self
    }
    #[inline]
    pub fn transform_feedback_streams_lines_triangles(mut self, value: bool) -> Self {
        self.inner.transform_feedback_streams_lines_triangles = value as u32;
        self
    }
    #[inline]
    pub fn transform_feedback_rasterization_stream_select(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.transform_feedback_rasterization_stream_select = value as u32;
        self
    }
    #[inline]
    pub fn transform_feedback_draw(mut self, value: bool) -> Self {
        self.inner.transform_feedback_draw = value as u32;
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceTransformFeedbackPropertiesEXTBuilder<'a> {
    type Target = PhysicalDeviceTransformFeedbackPropertiesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceTransformFeedbackPropertiesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PipelineRasterizationStateStreamCreateInfoEXT`] with lifetime-tied pNext safety.
pub struct PipelineRasterizationStateStreamCreateInfoEXTBuilder<'a> {
    inner: PipelineRasterizationStateStreamCreateInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PipelineRasterizationStateStreamCreateInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PipelineRasterizationStateStreamCreateInfoEXTBuilder<'a> {
        PipelineRasterizationStateStreamCreateInfoEXTBuilder {
            inner: PipelineRasterizationStateStreamCreateInfoEXT {
                s_type: StructureType::from_raw(1000028002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PipelineRasterizationStateStreamCreateInfoEXTBuilder<'a> {
    #[inline]
    pub fn flags(
        mut self,
        value: PipelineRasterizationStateStreamCreateFlagsEXT,
    ) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn rasterization_stream(mut self, value: u32) -> Self {
        self.inner.rasterization_stream = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PipelineRasterizationStateStreamCreateInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPipelineRasterizationStateStreamCreateInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for PipelineRasterizationStateStreamCreateInfoEXTBuilder<'a> {
    type Target = PipelineRasterizationStateStreamCreateInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PipelineRasterizationStateStreamCreateInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceRepresentativeFragmentTestFeaturesNV`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceRepresentativeFragmentTestFeaturesNVBuilder<'a> {
    inner: PhysicalDeviceRepresentativeFragmentTestFeaturesNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceRepresentativeFragmentTestFeaturesNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceRepresentativeFragmentTestFeaturesNVBuilder<
        'a,
    > {
        PhysicalDeviceRepresentativeFragmentTestFeaturesNVBuilder {
            inner: PhysicalDeviceRepresentativeFragmentTestFeaturesNV {
                s_type: StructureType::from_raw(1000166000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceRepresentativeFragmentTestFeaturesNVBuilder<'a> {
    #[inline]
    pub fn representative_fragment_test(mut self, value: bool) -> Self {
        self.inner.representative_fragment_test = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceRepresentativeFragmentTestFeaturesNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceRepresentativeFragmentTestFeaturesNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDeviceRepresentativeFragmentTestFeaturesNVBuilder<'a> {
    type Target = PhysicalDeviceRepresentativeFragmentTestFeaturesNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceRepresentativeFragmentTestFeaturesNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PipelineRepresentativeFragmentTestStateCreateInfoNV`] with lifetime-tied pNext safety.
pub struct PipelineRepresentativeFragmentTestStateCreateInfoNVBuilder<'a> {
    inner: PipelineRepresentativeFragmentTestStateCreateInfoNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PipelineRepresentativeFragmentTestStateCreateInfoNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PipelineRepresentativeFragmentTestStateCreateInfoNVBuilder<
        'a,
    > {
        PipelineRepresentativeFragmentTestStateCreateInfoNVBuilder {
            inner: PipelineRepresentativeFragmentTestStateCreateInfoNV {
                s_type: StructureType::from_raw(1000166001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PipelineRepresentativeFragmentTestStateCreateInfoNVBuilder<'a> {
    #[inline]
    pub fn representative_fragment_test_enable(mut self, value: bool) -> Self {
        self.inner.representative_fragment_test_enable = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PipelineRepresentativeFragmentTestStateCreateInfoNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPipelineRepresentativeFragmentTestStateCreateInfoNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref
for PipelineRepresentativeFragmentTestStateCreateInfoNVBuilder<'a> {
    type Target = PipelineRepresentativeFragmentTestStateCreateInfoNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PipelineRepresentativeFragmentTestStateCreateInfoNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceExclusiveScissorFeaturesNV`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceExclusiveScissorFeaturesNVBuilder<'a> {
    inner: PhysicalDeviceExclusiveScissorFeaturesNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceExclusiveScissorFeaturesNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceExclusiveScissorFeaturesNVBuilder<'a> {
        PhysicalDeviceExclusiveScissorFeaturesNVBuilder {
            inner: PhysicalDeviceExclusiveScissorFeaturesNV {
                s_type: StructureType::from_raw(1000205002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceExclusiveScissorFeaturesNVBuilder<'a> {
    #[inline]
    pub fn exclusive_scissor(mut self, value: bool) -> Self {
        self.inner.exclusive_scissor = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceExclusiveScissorFeaturesNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceExclusiveScissorFeaturesNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceExclusiveScissorFeaturesNVBuilder<'a> {
    type Target = PhysicalDeviceExclusiveScissorFeaturesNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceExclusiveScissorFeaturesNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PipelineViewportExclusiveScissorStateCreateInfoNV`] with lifetime-tied pNext safety.
pub struct PipelineViewportExclusiveScissorStateCreateInfoNVBuilder<'a> {
    inner: PipelineViewportExclusiveScissorStateCreateInfoNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PipelineViewportExclusiveScissorStateCreateInfoNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PipelineViewportExclusiveScissorStateCreateInfoNVBuilder<
        'a,
    > {
        PipelineViewportExclusiveScissorStateCreateInfoNVBuilder {
            inner: PipelineViewportExclusiveScissorStateCreateInfoNV {
                s_type: StructureType::from_raw(1000205000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PipelineViewportExclusiveScissorStateCreateInfoNVBuilder<'a> {
    #[inline]
    pub fn exclusive_scissors(mut self, slice: &'a [Rect2D]) -> Self {
        self.inner.exclusive_scissor_count = slice.len() as u32;
        self.inner.p_exclusive_scissors = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`PipelineViewportExclusiveScissorStateCreateInfoNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPipelineViewportExclusiveScissorStateCreateInfoNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref
for PipelineViewportExclusiveScissorStateCreateInfoNVBuilder<'a> {
    type Target = PipelineViewportExclusiveScissorStateCreateInfoNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PipelineViewportExclusiveScissorStateCreateInfoNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceCornerSampledImageFeaturesNV`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceCornerSampledImageFeaturesNVBuilder<'a> {
    inner: PhysicalDeviceCornerSampledImageFeaturesNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceCornerSampledImageFeaturesNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceCornerSampledImageFeaturesNVBuilder<'a> {
        PhysicalDeviceCornerSampledImageFeaturesNVBuilder {
            inner: PhysicalDeviceCornerSampledImageFeaturesNV {
                s_type: StructureType::from_raw(1000050000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceCornerSampledImageFeaturesNVBuilder<'a> {
    #[inline]
    pub fn corner_sampled_image(mut self, value: bool) -> Self {
        self.inner.corner_sampled_image = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceCornerSampledImageFeaturesNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceCornerSampledImageFeaturesNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceCornerSampledImageFeaturesNVBuilder<'a> {
    type Target = PhysicalDeviceCornerSampledImageFeaturesNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceCornerSampledImageFeaturesNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceComputeShaderDerivativesFeaturesKHR`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceComputeShaderDerivativesFeaturesKHRBuilder<'a> {
    inner: PhysicalDeviceComputeShaderDerivativesFeaturesKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceComputeShaderDerivativesFeaturesKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceComputeShaderDerivativesFeaturesKHRBuilder<
        'a,
    > {
        PhysicalDeviceComputeShaderDerivativesFeaturesKHRBuilder {
            inner: PhysicalDeviceComputeShaderDerivativesFeaturesKHR {
                s_type: StructureType::from_raw(1000201000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceComputeShaderDerivativesFeaturesKHRBuilder<'a> {
    #[inline]
    pub fn compute_derivative_group_quads(mut self, value: bool) -> Self {
        self.inner.compute_derivative_group_quads = value as u32;
        self
    }
    #[inline]
    pub fn compute_derivative_group_linear(mut self, value: bool) -> Self {
        self.inner.compute_derivative_group_linear = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceComputeShaderDerivativesFeaturesKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceComputeShaderDerivativesFeaturesKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDeviceComputeShaderDerivativesFeaturesKHRBuilder<'a> {
    type Target = PhysicalDeviceComputeShaderDerivativesFeaturesKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceComputeShaderDerivativesFeaturesKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceComputeShaderDerivativesPropertiesKHR`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceComputeShaderDerivativesPropertiesKHRBuilder<'a> {
    inner: PhysicalDeviceComputeShaderDerivativesPropertiesKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceComputeShaderDerivativesPropertiesKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceComputeShaderDerivativesPropertiesKHRBuilder<
        'a,
    > {
        PhysicalDeviceComputeShaderDerivativesPropertiesKHRBuilder {
            inner: PhysicalDeviceComputeShaderDerivativesPropertiesKHR {
                s_type: StructureType::from_raw(1000511000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceComputeShaderDerivativesPropertiesKHRBuilder<'a> {
    #[inline]
    pub fn mesh_and_task_shader_derivatives(mut self, value: bool) -> Self {
        self.inner.mesh_and_task_shader_derivatives = value as u32;
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDeviceComputeShaderDerivativesPropertiesKHRBuilder<'a> {
    type Target = PhysicalDeviceComputeShaderDerivativesPropertiesKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceComputeShaderDerivativesPropertiesKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceShaderImageFootprintFeaturesNV`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceShaderImageFootprintFeaturesNVBuilder<'a> {
    inner: PhysicalDeviceShaderImageFootprintFeaturesNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceShaderImageFootprintFeaturesNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceShaderImageFootprintFeaturesNVBuilder<'a> {
        PhysicalDeviceShaderImageFootprintFeaturesNVBuilder {
            inner: PhysicalDeviceShaderImageFootprintFeaturesNV {
                s_type: StructureType::from_raw(1000204000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceShaderImageFootprintFeaturesNVBuilder<'a> {
    #[inline]
    pub fn image_footprint(mut self, value: bool) -> Self {
        self.inner.image_footprint = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceShaderImageFootprintFeaturesNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceShaderImageFootprintFeaturesNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceShaderImageFootprintFeaturesNVBuilder<'a> {
    type Target = PhysicalDeviceShaderImageFootprintFeaturesNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceShaderImageFootprintFeaturesNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNVBuilder<'a> {
    inner: PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNVBuilder<
        'a,
    > {
        PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNVBuilder {
            inner: PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV {
                s_type: StructureType::from_raw(1000240000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNVBuilder<'a> {
    #[inline]
    pub fn dedicated_allocation_image_aliasing(mut self, value: bool) -> Self {
        self.inner.dedicated_allocation_image_aliasing = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNVBuilder<'a> {
    type Target = PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceCopyMemoryIndirectFeaturesKHR`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceCopyMemoryIndirectFeaturesKHRBuilder<'a> {
    inner: PhysicalDeviceCopyMemoryIndirectFeaturesKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceCopyMemoryIndirectFeaturesKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceCopyMemoryIndirectFeaturesKHRBuilder<'a> {
        PhysicalDeviceCopyMemoryIndirectFeaturesKHRBuilder {
            inner: PhysicalDeviceCopyMemoryIndirectFeaturesKHR {
                s_type: StructureType::from_raw(1000549000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceCopyMemoryIndirectFeaturesKHRBuilder<'a> {
    #[inline]
    pub fn indirect_memory_copy(mut self, value: bool) -> Self {
        self.inner.indirect_memory_copy = value as u32;
        self
    }
    #[inline]
    pub fn indirect_memory_to_image_copy(mut self, value: bool) -> Self {
        self.inner.indirect_memory_to_image_copy = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceCopyMemoryIndirectFeaturesKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceCopyMemoryIndirectFeaturesKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceCopyMemoryIndirectFeaturesKHRBuilder<'a> {
    type Target = PhysicalDeviceCopyMemoryIndirectFeaturesKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceCopyMemoryIndirectFeaturesKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceCopyMemoryIndirectFeaturesNV`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceCopyMemoryIndirectFeaturesNVBuilder<'a> {
    inner: PhysicalDeviceCopyMemoryIndirectFeaturesNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceCopyMemoryIndirectFeaturesNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceCopyMemoryIndirectFeaturesNVBuilder<'a> {
        PhysicalDeviceCopyMemoryIndirectFeaturesNVBuilder {
            inner: PhysicalDeviceCopyMemoryIndirectFeaturesNV {
                s_type: StructureType::from_raw(1000426000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceCopyMemoryIndirectFeaturesNVBuilder<'a> {
    #[inline]
    pub fn indirect_copy(mut self, value: bool) -> Self {
        self.inner.indirect_copy = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceCopyMemoryIndirectFeaturesNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceCopyMemoryIndirectFeaturesNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceCopyMemoryIndirectFeaturesNVBuilder<'a> {
    type Target = PhysicalDeviceCopyMemoryIndirectFeaturesNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceCopyMemoryIndirectFeaturesNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceCopyMemoryIndirectPropertiesKHR`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceCopyMemoryIndirectPropertiesKHRBuilder<'a> {
    inner: PhysicalDeviceCopyMemoryIndirectPropertiesKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceCopyMemoryIndirectPropertiesKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceCopyMemoryIndirectPropertiesKHRBuilder<'a> {
        PhysicalDeviceCopyMemoryIndirectPropertiesKHRBuilder {
            inner: PhysicalDeviceCopyMemoryIndirectPropertiesKHR {
                s_type: StructureType::from_raw(1000426001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceCopyMemoryIndirectPropertiesKHRBuilder<'a> {
    #[inline]
    pub fn supported_queues(mut self, value: QueueFlags) -> Self {
        self.inner.supported_queues = value;
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceCopyMemoryIndirectPropertiesKHRBuilder<'a> {
    type Target = PhysicalDeviceCopyMemoryIndirectPropertiesKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceCopyMemoryIndirectPropertiesKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceMemoryDecompressionFeaturesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceMemoryDecompressionFeaturesEXTBuilder<'a> {
    inner: PhysicalDeviceMemoryDecompressionFeaturesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceMemoryDecompressionFeaturesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceMemoryDecompressionFeaturesEXTBuilder<'a> {
        PhysicalDeviceMemoryDecompressionFeaturesEXTBuilder {
            inner: PhysicalDeviceMemoryDecompressionFeaturesEXT {
                s_type: StructureType::from_raw(1000427000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceMemoryDecompressionFeaturesEXTBuilder<'a> {
    #[inline]
    pub fn memory_decompression(mut self, value: bool) -> Self {
        self.inner.memory_decompression = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceMemoryDecompressionFeaturesEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceMemoryDecompressionFeaturesEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceMemoryDecompressionFeaturesEXTBuilder<'a> {
    type Target = PhysicalDeviceMemoryDecompressionFeaturesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceMemoryDecompressionFeaturesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceMemoryDecompressionPropertiesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceMemoryDecompressionPropertiesEXTBuilder<'a> {
    inner: PhysicalDeviceMemoryDecompressionPropertiesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceMemoryDecompressionPropertiesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceMemoryDecompressionPropertiesEXTBuilder<'a> {
        PhysicalDeviceMemoryDecompressionPropertiesEXTBuilder {
            inner: PhysicalDeviceMemoryDecompressionPropertiesEXT {
                s_type: StructureType::from_raw(1000427001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceMemoryDecompressionPropertiesEXTBuilder<'a> {
    #[inline]
    pub fn decompression_methods(
        mut self,
        value: MemoryDecompressionMethodFlagsEXT,
    ) -> Self {
        self.inner.decompression_methods = value;
        self
    }
    #[inline]
    pub fn max_decompression_indirect_count(mut self, value: u64) -> Self {
        self.inner.max_decompression_indirect_count = value;
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceMemoryDecompressionPropertiesEXTBuilder<'a> {
    type Target = PhysicalDeviceMemoryDecompressionPropertiesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceMemoryDecompressionPropertiesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ShadingRatePaletteNV`].
pub struct ShadingRatePaletteNVBuilder<'a> {
    inner: ShadingRatePaletteNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ShadingRatePaletteNV {
    /// Start building this struct.
    #[inline]
    pub fn builder<'a>() -> ShadingRatePaletteNVBuilder<'a> {
        ShadingRatePaletteNVBuilder {
            inner: ShadingRatePaletteNV {
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ShadingRatePaletteNVBuilder<'a> {
    #[inline]
    pub fn shading_rate_palette_entries(
        mut self,
        slice: &'a [ShadingRatePaletteEntryNV],
    ) -> Self {
        self.inner.shading_rate_palette_entry_count = slice.len() as u32;
        self.inner.p_shading_rate_palette_entries = slice.as_ptr();
        self
    }
}
impl<'a> core::ops::Deref for ShadingRatePaletteNVBuilder<'a> {
    type Target = ShadingRatePaletteNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ShadingRatePaletteNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PipelineViewportShadingRateImageStateCreateInfoNV`] with lifetime-tied pNext safety.
pub struct PipelineViewportShadingRateImageStateCreateInfoNVBuilder<'a> {
    inner: PipelineViewportShadingRateImageStateCreateInfoNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PipelineViewportShadingRateImageStateCreateInfoNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PipelineViewportShadingRateImageStateCreateInfoNVBuilder<
        'a,
    > {
        PipelineViewportShadingRateImageStateCreateInfoNVBuilder {
            inner: PipelineViewportShadingRateImageStateCreateInfoNV {
                s_type: StructureType::from_raw(1000164000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PipelineViewportShadingRateImageStateCreateInfoNVBuilder<'a> {
    #[inline]
    pub fn shading_rate_image_enable(mut self, value: bool) -> Self {
        self.inner.shading_rate_image_enable = value as u32;
        self
    }
    #[inline]
    pub fn shading_rate_palettes(mut self, slice: &'a [ShadingRatePaletteNV]) -> Self {
        self.inner.viewport_count = slice.len() as u32;
        self.inner.p_shading_rate_palettes = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`PipelineViewportShadingRateImageStateCreateInfoNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPipelineViewportShadingRateImageStateCreateInfoNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref
for PipelineViewportShadingRateImageStateCreateInfoNVBuilder<'a> {
    type Target = PipelineViewportShadingRateImageStateCreateInfoNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PipelineViewportShadingRateImageStateCreateInfoNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceShadingRateImageFeaturesNV`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceShadingRateImageFeaturesNVBuilder<'a> {
    inner: PhysicalDeviceShadingRateImageFeaturesNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceShadingRateImageFeaturesNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceShadingRateImageFeaturesNVBuilder<'a> {
        PhysicalDeviceShadingRateImageFeaturesNVBuilder {
            inner: PhysicalDeviceShadingRateImageFeaturesNV {
                s_type: StructureType::from_raw(1000164001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceShadingRateImageFeaturesNVBuilder<'a> {
    #[inline]
    pub fn shading_rate_image(mut self, value: bool) -> Self {
        self.inner.shading_rate_image = value as u32;
        self
    }
    #[inline]
    pub fn shading_rate_coarse_sample_order(mut self, value: bool) -> Self {
        self.inner.shading_rate_coarse_sample_order = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceShadingRateImageFeaturesNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceShadingRateImageFeaturesNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceShadingRateImageFeaturesNVBuilder<'a> {
    type Target = PhysicalDeviceShadingRateImageFeaturesNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceShadingRateImageFeaturesNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceShadingRateImagePropertiesNV`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceShadingRateImagePropertiesNVBuilder<'a> {
    inner: PhysicalDeviceShadingRateImagePropertiesNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceShadingRateImagePropertiesNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceShadingRateImagePropertiesNVBuilder<'a> {
        PhysicalDeviceShadingRateImagePropertiesNVBuilder {
            inner: PhysicalDeviceShadingRateImagePropertiesNV {
                s_type: StructureType::from_raw(1000164002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceShadingRateImagePropertiesNVBuilder<'a> {
    #[inline]
    pub fn shading_rate_texel_size(mut self, value: Extent2D) -> Self {
        self.inner.shading_rate_texel_size = value;
        self
    }
    #[inline]
    pub fn shading_rate_palette_size(mut self, value: u32) -> Self {
        self.inner.shading_rate_palette_size = value;
        self
    }
    #[inline]
    pub fn shading_rate_max_coarse_samples(mut self, value: u32) -> Self {
        self.inner.shading_rate_max_coarse_samples = value;
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceShadingRateImagePropertiesNVBuilder<'a> {
    type Target = PhysicalDeviceShadingRateImagePropertiesNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceShadingRateImagePropertiesNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceInvocationMaskFeaturesHUAWEI`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceInvocationMaskFeaturesHUAWEIBuilder<'a> {
    inner: PhysicalDeviceInvocationMaskFeaturesHUAWEI,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceInvocationMaskFeaturesHUAWEI {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceInvocationMaskFeaturesHUAWEIBuilder<'a> {
        PhysicalDeviceInvocationMaskFeaturesHUAWEIBuilder {
            inner: PhysicalDeviceInvocationMaskFeaturesHUAWEI {
                s_type: StructureType::from_raw(1000370000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceInvocationMaskFeaturesHUAWEIBuilder<'a> {
    #[inline]
    pub fn invocation_mask(mut self, value: bool) -> Self {
        self.inner.invocation_mask = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceInvocationMaskFeaturesHUAWEI`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceInvocationMaskFeaturesHUAWEI>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceInvocationMaskFeaturesHUAWEIBuilder<'a> {
    type Target = PhysicalDeviceInvocationMaskFeaturesHUAWEI;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceInvocationMaskFeaturesHUAWEIBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`CoarseSampleLocationNV`].
pub struct CoarseSampleLocationNVBuilder {
    inner: CoarseSampleLocationNV,
}
impl CoarseSampleLocationNV {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> CoarseSampleLocationNVBuilder {
        CoarseSampleLocationNVBuilder {
            inner: CoarseSampleLocationNV {
                ..Default::default()
            },
        }
    }
}
impl CoarseSampleLocationNVBuilder {
    #[inline]
    pub fn pixel_x(mut self, value: u32) -> Self {
        self.inner.pixel_x = value;
        self
    }
    #[inline]
    pub fn pixel_y(mut self, value: u32) -> Self {
        self.inner.pixel_y = value;
        self
    }
    #[inline]
    pub fn sample(mut self, value: u32) -> Self {
        self.inner.sample = value;
        self
    }
}
impl core::ops::Deref for CoarseSampleLocationNVBuilder {
    type Target = CoarseSampleLocationNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for CoarseSampleLocationNVBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`CoarseSampleOrderCustomNV`].
pub struct CoarseSampleOrderCustomNVBuilder<'a> {
    inner: CoarseSampleOrderCustomNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl CoarseSampleOrderCustomNV {
    /// Start building this struct.
    #[inline]
    pub fn builder<'a>() -> CoarseSampleOrderCustomNVBuilder<'a> {
        CoarseSampleOrderCustomNVBuilder {
            inner: CoarseSampleOrderCustomNV {
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> CoarseSampleOrderCustomNVBuilder<'a> {
    #[inline]
    pub fn shading_rate(mut self, value: ShadingRatePaletteEntryNV) -> Self {
        self.inner.shading_rate = value;
        self
    }
    #[inline]
    pub fn sample_count(mut self, value: u32) -> Self {
        self.inner.sample_count = value;
        self
    }
    #[inline]
    pub fn sample_locations(mut self, slice: &'a [CoarseSampleLocationNV]) -> Self {
        self.inner.sample_location_count = slice.len() as u32;
        self.inner.p_sample_locations = slice.as_ptr();
        self
    }
}
impl<'a> core::ops::Deref for CoarseSampleOrderCustomNVBuilder<'a> {
    type Target = CoarseSampleOrderCustomNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for CoarseSampleOrderCustomNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PipelineViewportCoarseSampleOrderStateCreateInfoNV`] with lifetime-tied pNext safety.
pub struct PipelineViewportCoarseSampleOrderStateCreateInfoNVBuilder<'a> {
    inner: PipelineViewportCoarseSampleOrderStateCreateInfoNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PipelineViewportCoarseSampleOrderStateCreateInfoNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PipelineViewportCoarseSampleOrderStateCreateInfoNVBuilder<
        'a,
    > {
        PipelineViewportCoarseSampleOrderStateCreateInfoNVBuilder {
            inner: PipelineViewportCoarseSampleOrderStateCreateInfoNV {
                s_type: StructureType::from_raw(1000164005i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PipelineViewportCoarseSampleOrderStateCreateInfoNVBuilder<'a> {
    #[inline]
    pub fn sample_order_type(mut self, value: CoarseSampleOrderTypeNV) -> Self {
        self.inner.sample_order_type = value;
        self
    }
    #[inline]
    pub fn custom_sample_orders(
        mut self,
        slice: &'a [CoarseSampleOrderCustomNV],
    ) -> Self {
        self.inner.custom_sample_order_count = slice.len() as u32;
        self.inner.p_custom_sample_orders = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`PipelineViewportCoarseSampleOrderStateCreateInfoNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPipelineViewportCoarseSampleOrderStateCreateInfoNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref
for PipelineViewportCoarseSampleOrderStateCreateInfoNVBuilder<'a> {
    type Target = PipelineViewportCoarseSampleOrderStateCreateInfoNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PipelineViewportCoarseSampleOrderStateCreateInfoNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceMeshShaderFeaturesNV`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceMeshShaderFeaturesNVBuilder<'a> {
    inner: PhysicalDeviceMeshShaderFeaturesNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceMeshShaderFeaturesNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceMeshShaderFeaturesNVBuilder<'a> {
        PhysicalDeviceMeshShaderFeaturesNVBuilder {
            inner: PhysicalDeviceMeshShaderFeaturesNV {
                s_type: StructureType::from_raw(1000202000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceMeshShaderFeaturesNVBuilder<'a> {
    #[inline]
    pub fn task_shader(mut self, value: bool) -> Self {
        self.inner.task_shader = value as u32;
        self
    }
    #[inline]
    pub fn mesh_shader(mut self, value: bool) -> Self {
        self.inner.mesh_shader = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceMeshShaderFeaturesNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceMeshShaderFeaturesNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceMeshShaderFeaturesNVBuilder<'a> {
    type Target = PhysicalDeviceMeshShaderFeaturesNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceMeshShaderFeaturesNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceMeshShaderPropertiesNV`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceMeshShaderPropertiesNVBuilder<'a> {
    inner: PhysicalDeviceMeshShaderPropertiesNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceMeshShaderPropertiesNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceMeshShaderPropertiesNVBuilder<'a> {
        PhysicalDeviceMeshShaderPropertiesNVBuilder {
            inner: PhysicalDeviceMeshShaderPropertiesNV {
                s_type: StructureType::from_raw(1000202001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceMeshShaderPropertiesNVBuilder<'a> {
    #[inline]
    pub fn max_draw_mesh_tasks_count(mut self, value: u32) -> Self {
        self.inner.max_draw_mesh_tasks_count = value;
        self
    }
    #[inline]
    pub fn max_task_work_group_invocations(mut self, value: u32) -> Self {
        self.inner.max_task_work_group_invocations = value;
        self
    }
    #[inline]
    pub fn max_task_work_group_size(mut self, value: [u32; 3usize]) -> Self {
        self.inner.max_task_work_group_size = value;
        self
    }
    #[inline]
    pub fn max_task_total_memory_size(mut self, value: u32) -> Self {
        self.inner.max_task_total_memory_size = value;
        self
    }
    #[inline]
    pub fn max_task_output_count(mut self, value: u32) -> Self {
        self.inner.max_task_output_count = value;
        self
    }
    #[inline]
    pub fn max_mesh_work_group_invocations(mut self, value: u32) -> Self {
        self.inner.max_mesh_work_group_invocations = value;
        self
    }
    #[inline]
    pub fn max_mesh_work_group_size(mut self, value: [u32; 3usize]) -> Self {
        self.inner.max_mesh_work_group_size = value;
        self
    }
    #[inline]
    pub fn max_mesh_total_memory_size(mut self, value: u32) -> Self {
        self.inner.max_mesh_total_memory_size = value;
        self
    }
    #[inline]
    pub fn max_mesh_output_vertices(mut self, value: u32) -> Self {
        self.inner.max_mesh_output_vertices = value;
        self
    }
    #[inline]
    pub fn max_mesh_output_primitives(mut self, value: u32) -> Self {
        self.inner.max_mesh_output_primitives = value;
        self
    }
    #[inline]
    pub fn max_mesh_multiview_view_count(mut self, value: u32) -> Self {
        self.inner.max_mesh_multiview_view_count = value;
        self
    }
    #[inline]
    pub fn mesh_output_per_vertex_granularity(mut self, value: u32) -> Self {
        self.inner.mesh_output_per_vertex_granularity = value;
        self
    }
    #[inline]
    pub fn mesh_output_per_primitive_granularity(mut self, value: u32) -> Self {
        self.inner.mesh_output_per_primitive_granularity = value;
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceMeshShaderPropertiesNVBuilder<'a> {
    type Target = PhysicalDeviceMeshShaderPropertiesNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceMeshShaderPropertiesNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DrawMeshTasksIndirectCommandNV`].
pub struct DrawMeshTasksIndirectCommandNVBuilder {
    inner: DrawMeshTasksIndirectCommandNV,
}
impl DrawMeshTasksIndirectCommandNV {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> DrawMeshTasksIndirectCommandNVBuilder {
        DrawMeshTasksIndirectCommandNVBuilder {
            inner: DrawMeshTasksIndirectCommandNV {
                ..Default::default()
            },
        }
    }
}
impl DrawMeshTasksIndirectCommandNVBuilder {
    #[inline]
    pub fn task_count(mut self, value: u32) -> Self {
        self.inner.task_count = value;
        self
    }
    #[inline]
    pub fn first_task(mut self, value: u32) -> Self {
        self.inner.first_task = value;
        self
    }
}
impl core::ops::Deref for DrawMeshTasksIndirectCommandNVBuilder {
    type Target = DrawMeshTasksIndirectCommandNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for DrawMeshTasksIndirectCommandNVBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceMeshShaderFeaturesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceMeshShaderFeaturesEXTBuilder<'a> {
    inner: PhysicalDeviceMeshShaderFeaturesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceMeshShaderFeaturesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceMeshShaderFeaturesEXTBuilder<'a> {
        PhysicalDeviceMeshShaderFeaturesEXTBuilder {
            inner: PhysicalDeviceMeshShaderFeaturesEXT {
                s_type: StructureType::from_raw(1000328000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceMeshShaderFeaturesEXTBuilder<'a> {
    #[inline]
    pub fn task_shader(mut self, value: bool) -> Self {
        self.inner.task_shader = value as u32;
        self
    }
    #[inline]
    pub fn mesh_shader(mut self, value: bool) -> Self {
        self.inner.mesh_shader = value as u32;
        self
    }
    #[inline]
    pub fn multiview_mesh_shader(mut self, value: bool) -> Self {
        self.inner.multiview_mesh_shader = value as u32;
        self
    }
    #[inline]
    pub fn primitive_fragment_shading_rate_mesh_shader(mut self, value: bool) -> Self {
        self.inner.primitive_fragment_shading_rate_mesh_shader = value as u32;
        self
    }
    #[inline]
    pub fn mesh_shader_queries(mut self, value: bool) -> Self {
        self.inner.mesh_shader_queries = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceMeshShaderFeaturesEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceMeshShaderFeaturesEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceMeshShaderFeaturesEXTBuilder<'a> {
    type Target = PhysicalDeviceMeshShaderFeaturesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceMeshShaderFeaturesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceMeshShaderPropertiesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceMeshShaderPropertiesEXTBuilder<'a> {
    inner: PhysicalDeviceMeshShaderPropertiesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceMeshShaderPropertiesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceMeshShaderPropertiesEXTBuilder<'a> {
        PhysicalDeviceMeshShaderPropertiesEXTBuilder {
            inner: PhysicalDeviceMeshShaderPropertiesEXT {
                s_type: StructureType::from_raw(1000328001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceMeshShaderPropertiesEXTBuilder<'a> {
    #[inline]
    pub fn max_task_work_group_total_count(mut self, value: u32) -> Self {
        self.inner.max_task_work_group_total_count = value;
        self
    }
    #[inline]
    pub fn max_task_work_group_count(mut self, value: [u32; 3usize]) -> Self {
        self.inner.max_task_work_group_count = value;
        self
    }
    #[inline]
    pub fn max_task_work_group_invocations(mut self, value: u32) -> Self {
        self.inner.max_task_work_group_invocations = value;
        self
    }
    #[inline]
    pub fn max_task_work_group_size(mut self, value: [u32; 3usize]) -> Self {
        self.inner.max_task_work_group_size = value;
        self
    }
    #[inline]
    pub fn max_task_payload_size(mut self, value: u32) -> Self {
        self.inner.max_task_payload_size = value;
        self
    }
    #[inline]
    pub fn max_task_shared_memory_size(mut self, value: u32) -> Self {
        self.inner.max_task_shared_memory_size = value;
        self
    }
    #[inline]
    pub fn max_task_payload_and_shared_memory_size(mut self, value: u32) -> Self {
        self.inner.max_task_payload_and_shared_memory_size = value;
        self
    }
    #[inline]
    pub fn max_mesh_work_group_total_count(mut self, value: u32) -> Self {
        self.inner.max_mesh_work_group_total_count = value;
        self
    }
    #[inline]
    pub fn max_mesh_work_group_count(mut self, value: [u32; 3usize]) -> Self {
        self.inner.max_mesh_work_group_count = value;
        self
    }
    #[inline]
    pub fn max_mesh_work_group_invocations(mut self, value: u32) -> Self {
        self.inner.max_mesh_work_group_invocations = value;
        self
    }
    #[inline]
    pub fn max_mesh_work_group_size(mut self, value: [u32; 3usize]) -> Self {
        self.inner.max_mesh_work_group_size = value;
        self
    }
    #[inline]
    pub fn max_mesh_shared_memory_size(mut self, value: u32) -> Self {
        self.inner.max_mesh_shared_memory_size = value;
        self
    }
    #[inline]
    pub fn max_mesh_payload_and_shared_memory_size(mut self, value: u32) -> Self {
        self.inner.max_mesh_payload_and_shared_memory_size = value;
        self
    }
    #[inline]
    pub fn max_mesh_output_memory_size(mut self, value: u32) -> Self {
        self.inner.max_mesh_output_memory_size = value;
        self
    }
    #[inline]
    pub fn max_mesh_payload_and_output_memory_size(mut self, value: u32) -> Self {
        self.inner.max_mesh_payload_and_output_memory_size = value;
        self
    }
    #[inline]
    pub fn max_mesh_output_components(mut self, value: u32) -> Self {
        self.inner.max_mesh_output_components = value;
        self
    }
    #[inline]
    pub fn max_mesh_output_vertices(mut self, value: u32) -> Self {
        self.inner.max_mesh_output_vertices = value;
        self
    }
    #[inline]
    pub fn max_mesh_output_primitives(mut self, value: u32) -> Self {
        self.inner.max_mesh_output_primitives = value;
        self
    }
    #[inline]
    pub fn max_mesh_output_layers(mut self, value: u32) -> Self {
        self.inner.max_mesh_output_layers = value;
        self
    }
    #[inline]
    pub fn max_mesh_multiview_view_count(mut self, value: u32) -> Self {
        self.inner.max_mesh_multiview_view_count = value;
        self
    }
    #[inline]
    pub fn mesh_output_per_vertex_granularity(mut self, value: u32) -> Self {
        self.inner.mesh_output_per_vertex_granularity = value;
        self
    }
    #[inline]
    pub fn mesh_output_per_primitive_granularity(mut self, value: u32) -> Self {
        self.inner.mesh_output_per_primitive_granularity = value;
        self
    }
    #[inline]
    pub fn max_preferred_task_work_group_invocations(mut self, value: u32) -> Self {
        self.inner.max_preferred_task_work_group_invocations = value;
        self
    }
    #[inline]
    pub fn max_preferred_mesh_work_group_invocations(mut self, value: u32) -> Self {
        self.inner.max_preferred_mesh_work_group_invocations = value;
        self
    }
    #[inline]
    pub fn prefers_local_invocation_vertex_output(mut self, value: bool) -> Self {
        self.inner.prefers_local_invocation_vertex_output = value as u32;
        self
    }
    #[inline]
    pub fn prefers_local_invocation_primitive_output(mut self, value: bool) -> Self {
        self.inner.prefers_local_invocation_primitive_output = value as u32;
        self
    }
    #[inline]
    pub fn prefers_compact_vertex_output(mut self, value: bool) -> Self {
        self.inner.prefers_compact_vertex_output = value as u32;
        self
    }
    #[inline]
    pub fn prefers_compact_primitive_output(mut self, value: bool) -> Self {
        self.inner.prefers_compact_primitive_output = value as u32;
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceMeshShaderPropertiesEXTBuilder<'a> {
    type Target = PhysicalDeviceMeshShaderPropertiesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceMeshShaderPropertiesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DrawMeshTasksIndirectCommandEXT`].
pub struct DrawMeshTasksIndirectCommandEXTBuilder {
    inner: DrawMeshTasksIndirectCommandEXT,
}
impl DrawMeshTasksIndirectCommandEXT {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> DrawMeshTasksIndirectCommandEXTBuilder {
        DrawMeshTasksIndirectCommandEXTBuilder {
            inner: DrawMeshTasksIndirectCommandEXT {
                ..Default::default()
            },
        }
    }
}
impl DrawMeshTasksIndirectCommandEXTBuilder {
    #[inline]
    pub fn group_count_x(mut self, value: u32) -> Self {
        self.inner.group_count_x = value;
        self
    }
    #[inline]
    pub fn group_count_y(mut self, value: u32) -> Self {
        self.inner.group_count_y = value;
        self
    }
    #[inline]
    pub fn group_count_z(mut self, value: u32) -> Self {
        self.inner.group_count_z = value;
        self
    }
}
impl core::ops::Deref for DrawMeshTasksIndirectCommandEXTBuilder {
    type Target = DrawMeshTasksIndirectCommandEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for DrawMeshTasksIndirectCommandEXTBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`RayTracingShaderGroupCreateInfoNV`] with lifetime-tied pNext safety.
pub struct RayTracingShaderGroupCreateInfoNVBuilder<'a> {
    inner: RayTracingShaderGroupCreateInfoNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl RayTracingShaderGroupCreateInfoNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> RayTracingShaderGroupCreateInfoNVBuilder<'a> {
        RayTracingShaderGroupCreateInfoNVBuilder {
            inner: RayTracingShaderGroupCreateInfoNV {
                s_type: StructureType::from_raw(1000165011i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> RayTracingShaderGroupCreateInfoNVBuilder<'a> {
    #[inline]
    pub fn r#type(mut self, value: RayTracingShaderGroupTypeKHR) -> Self {
        self.inner.r#type = value;
        self
    }
    #[inline]
    pub fn general_shader(mut self, value: u32) -> Self {
        self.inner.general_shader = value;
        self
    }
    #[inline]
    pub fn closest_hit_shader(mut self, value: u32) -> Self {
        self.inner.closest_hit_shader = value;
        self
    }
    #[inline]
    pub fn any_hit_shader(mut self, value: u32) -> Self {
        self.inner.any_hit_shader = value;
        self
    }
    #[inline]
    pub fn intersection_shader(mut self, value: u32) -> Self {
        self.inner.intersection_shader = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`RayTracingShaderGroupCreateInfoNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsRayTracingShaderGroupCreateInfoNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for RayTracingShaderGroupCreateInfoNVBuilder<'a> {
    type Target = RayTracingShaderGroupCreateInfoNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for RayTracingShaderGroupCreateInfoNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`RayTracingShaderGroupCreateInfoKHR`] with lifetime-tied pNext safety.
pub struct RayTracingShaderGroupCreateInfoKHRBuilder<'a> {
    inner: RayTracingShaderGroupCreateInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl RayTracingShaderGroupCreateInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> RayTracingShaderGroupCreateInfoKHRBuilder<'a> {
        RayTracingShaderGroupCreateInfoKHRBuilder {
            inner: RayTracingShaderGroupCreateInfoKHR {
                s_type: StructureType::from_raw(1000150016i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> RayTracingShaderGroupCreateInfoKHRBuilder<'a> {
    #[inline]
    pub fn r#type(mut self, value: RayTracingShaderGroupTypeKHR) -> Self {
        self.inner.r#type = value;
        self
    }
    #[inline]
    pub fn general_shader(mut self, value: u32) -> Self {
        self.inner.general_shader = value;
        self
    }
    #[inline]
    pub fn closest_hit_shader(mut self, value: u32) -> Self {
        self.inner.closest_hit_shader = value;
        self
    }
    #[inline]
    pub fn any_hit_shader(mut self, value: u32) -> Self {
        self.inner.any_hit_shader = value;
        self
    }
    #[inline]
    pub fn intersection_shader(mut self, value: u32) -> Self {
        self.inner.intersection_shader = value;
        self
    }
    #[inline]
    pub fn shader_group_capture_replay_handle(
        mut self,
        value: *const core::ffi::c_void,
    ) -> Self {
        self.inner.p_shader_group_capture_replay_handle = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`RayTracingShaderGroupCreateInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsRayTracingShaderGroupCreateInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for RayTracingShaderGroupCreateInfoKHRBuilder<'a> {
    type Target = RayTracingShaderGroupCreateInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for RayTracingShaderGroupCreateInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`RayTracingPipelineCreateInfoNV`] with lifetime-tied pNext safety.
pub struct RayTracingPipelineCreateInfoNVBuilder<'a> {
    inner: RayTracingPipelineCreateInfoNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl RayTracingPipelineCreateInfoNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> RayTracingPipelineCreateInfoNVBuilder<'a> {
        RayTracingPipelineCreateInfoNVBuilder {
            inner: RayTracingPipelineCreateInfoNV {
                s_type: StructureType::from_raw(1000165000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> RayTracingPipelineCreateInfoNVBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: PipelineCreateFlags) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn stages(mut self, slice: &'a [PipelineShaderStageCreateInfo]) -> Self {
        self.inner.stage_count = slice.len() as u32;
        self.inner.p_stages = slice.as_ptr();
        self
    }
    #[inline]
    pub fn groups(mut self, slice: &'a [RayTracingShaderGroupCreateInfoNV]) -> Self {
        self.inner.group_count = slice.len() as u32;
        self.inner.p_groups = slice.as_ptr();
        self
    }
    #[inline]
    pub fn max_recursion_depth(mut self, value: u32) -> Self {
        self.inner.max_recursion_depth = value;
        self
    }
    #[inline]
    pub fn layout(mut self, value: PipelineLayout) -> Self {
        self.inner.layout = value;
        self
    }
    #[inline]
    pub fn base_pipeline_handle(mut self, value: Pipeline) -> Self {
        self.inner.base_pipeline_handle = value;
        self
    }
    #[inline]
    pub fn base_pipeline_index(mut self, value: i32) -> Self {
        self.inner.base_pipeline_index = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`RayTracingPipelineCreateInfoNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsRayTracingPipelineCreateInfoNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for RayTracingPipelineCreateInfoNVBuilder<'a> {
    type Target = RayTracingPipelineCreateInfoNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for RayTracingPipelineCreateInfoNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`RayTracingPipelineCreateInfoKHR`] with lifetime-tied pNext safety.
pub struct RayTracingPipelineCreateInfoKHRBuilder<'a> {
    inner: RayTracingPipelineCreateInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl RayTracingPipelineCreateInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> RayTracingPipelineCreateInfoKHRBuilder<'a> {
        RayTracingPipelineCreateInfoKHRBuilder {
            inner: RayTracingPipelineCreateInfoKHR {
                s_type: StructureType::from_raw(1000150015i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> RayTracingPipelineCreateInfoKHRBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: PipelineCreateFlags) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn stages(mut self, slice: &'a [PipelineShaderStageCreateInfo]) -> Self {
        self.inner.stage_count = slice.len() as u32;
        self.inner.p_stages = slice.as_ptr();
        self
    }
    #[inline]
    pub fn groups(mut self, slice: &'a [RayTracingShaderGroupCreateInfoKHR]) -> Self {
        self.inner.group_count = slice.len() as u32;
        self.inner.p_groups = slice.as_ptr();
        self
    }
    #[inline]
    pub fn max_pipeline_ray_recursion_depth(mut self, value: u32) -> Self {
        self.inner.max_pipeline_ray_recursion_depth = value;
        self
    }
    #[inline]
    pub fn library_info(mut self, value: &'a PipelineLibraryCreateInfoKHR) -> Self {
        self.inner.p_library_info = value;
        self
    }
    #[inline]
    pub fn library_interface(
        mut self,
        value: &'a RayTracingPipelineInterfaceCreateInfoKHR,
    ) -> Self {
        self.inner.p_library_interface = value;
        self
    }
    #[inline]
    pub fn dynamic_state(mut self, value: &'a PipelineDynamicStateCreateInfo) -> Self {
        self.inner.p_dynamic_state = value;
        self
    }
    #[inline]
    pub fn layout(mut self, value: PipelineLayout) -> Self {
        self.inner.layout = value;
        self
    }
    #[inline]
    pub fn base_pipeline_handle(mut self, value: Pipeline) -> Self {
        self.inner.base_pipeline_handle = value;
        self
    }
    #[inline]
    pub fn base_pipeline_index(mut self, value: i32) -> Self {
        self.inner.base_pipeline_index = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`RayTracingPipelineCreateInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsRayTracingPipelineCreateInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for RayTracingPipelineCreateInfoKHRBuilder<'a> {
    type Target = RayTracingPipelineCreateInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for RayTracingPipelineCreateInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`GeometryTrianglesNV`] with lifetime-tied pNext safety.
pub struct GeometryTrianglesNVBuilder<'a> {
    inner: GeometryTrianglesNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl GeometryTrianglesNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> GeometryTrianglesNVBuilder<'a> {
        GeometryTrianglesNVBuilder {
            inner: GeometryTrianglesNV {
                s_type: StructureType::from_raw(1000165004i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> GeometryTrianglesNVBuilder<'a> {
    #[inline]
    pub fn vertex_data(mut self, value: Buffer) -> Self {
        self.inner.vertex_data = value;
        self
    }
    #[inline]
    pub fn vertex_offset(mut self, value: u64) -> Self {
        self.inner.vertex_offset = value;
        self
    }
    #[inline]
    pub fn vertex_count(mut self, value: u32) -> Self {
        self.inner.vertex_count = value;
        self
    }
    #[inline]
    pub fn vertex_stride(mut self, value: u64) -> Self {
        self.inner.vertex_stride = value;
        self
    }
    #[inline]
    pub fn vertex_format(mut self, value: Format) -> Self {
        self.inner.vertex_format = value;
        self
    }
    #[inline]
    pub fn index_data(mut self, value: Buffer) -> Self {
        self.inner.index_data = value;
        self
    }
    #[inline]
    pub fn index_offset(mut self, value: u64) -> Self {
        self.inner.index_offset = value;
        self
    }
    #[inline]
    pub fn index_count(mut self, value: u32) -> Self {
        self.inner.index_count = value;
        self
    }
    #[inline]
    pub fn index_type(mut self, value: IndexType) -> Self {
        self.inner.index_type = value;
        self
    }
    #[inline]
    pub fn transform_data(mut self, value: Buffer) -> Self {
        self.inner.transform_data = value;
        self
    }
    #[inline]
    pub fn transform_offset(mut self, value: u64) -> Self {
        self.inner.transform_offset = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`GeometryTrianglesNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsGeometryTrianglesNV>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for GeometryTrianglesNVBuilder<'a> {
    type Target = GeometryTrianglesNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for GeometryTrianglesNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`GeometryAABBNV`] with lifetime-tied pNext safety.
pub struct GeometryAABBNVBuilder<'a> {
    inner: GeometryAABBNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl GeometryAABBNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> GeometryAABBNVBuilder<'a> {
        GeometryAABBNVBuilder {
            inner: GeometryAABBNV {
                s_type: StructureType::from_raw(1000165005i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> GeometryAABBNVBuilder<'a> {
    #[inline]
    pub fn aabb_data(mut self, value: Buffer) -> Self {
        self.inner.aabb_data = value;
        self
    }
    #[inline]
    pub fn num_aab_bs(mut self, value: u32) -> Self {
        self.inner.num_aab_bs = value;
        self
    }
    #[inline]
    pub fn stride(mut self, value: u32) -> Self {
        self.inner.stride = value;
        self
    }
    #[inline]
    pub fn offset(mut self, value: u64) -> Self {
        self.inner.offset = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`GeometryAABBNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsGeometryAABBNV>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for GeometryAABBNVBuilder<'a> {
    type Target = GeometryAABBNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for GeometryAABBNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`GeometryDataNV`].
pub struct GeometryDataNVBuilder {
    inner: GeometryDataNV,
}
impl GeometryDataNV {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> GeometryDataNVBuilder {
        GeometryDataNVBuilder {
            inner: GeometryDataNV {
                ..Default::default()
            },
        }
    }
}
impl GeometryDataNVBuilder {
    #[inline]
    pub fn triangles(mut self, value: GeometryTrianglesNV) -> Self {
        self.inner.triangles = value;
        self
    }
    #[inline]
    pub fn aabbs(mut self, value: GeometryAABBNV) -> Self {
        self.inner.aabbs = value;
        self
    }
}
impl core::ops::Deref for GeometryDataNVBuilder {
    type Target = GeometryDataNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for GeometryDataNVBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`GeometryNV`] with lifetime-tied pNext safety.
pub struct GeometryNVBuilder<'a> {
    inner: GeometryNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl GeometryNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> GeometryNVBuilder<'a> {
        GeometryNVBuilder {
            inner: GeometryNV {
                s_type: StructureType::from_raw(1000165003i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> GeometryNVBuilder<'a> {
    #[inline]
    pub fn geometry_type(mut self, value: GeometryTypeKHR) -> Self {
        self.inner.geometry_type = value;
        self
    }
    #[inline]
    pub fn geometry(mut self, value: GeometryDataNV) -> Self {
        self.inner.geometry = value;
        self
    }
    #[inline]
    pub fn flags(mut self, value: GeometryFlagsKHR) -> Self {
        self.inner.flags = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`GeometryNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsGeometryNV>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for GeometryNVBuilder<'a> {
    type Target = GeometryNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for GeometryNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`AccelerationStructureInfoNV`] with lifetime-tied pNext safety.
pub struct AccelerationStructureInfoNVBuilder<'a> {
    inner: AccelerationStructureInfoNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl AccelerationStructureInfoNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> AccelerationStructureInfoNVBuilder<'a> {
        AccelerationStructureInfoNVBuilder {
            inner: AccelerationStructureInfoNV {
                s_type: StructureType::from_raw(1000165012i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> AccelerationStructureInfoNVBuilder<'a> {
    #[inline]
    pub fn r#type(mut self, value: AccelerationStructureTypeNV) -> Self {
        self.inner.r#type = value;
        self
    }
    #[inline]
    pub fn flags(mut self, value: BuildAccelerationStructureFlagsNV) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn instance_count(mut self, value: u32) -> Self {
        self.inner.instance_count = value;
        self
    }
    #[inline]
    pub fn geometries(mut self, slice: &'a [GeometryNV]) -> Self {
        self.inner.geometry_count = slice.len() as u32;
        self.inner.p_geometries = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`AccelerationStructureInfoNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsAccelerationStructureInfoNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for AccelerationStructureInfoNVBuilder<'a> {
    type Target = AccelerationStructureInfoNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for AccelerationStructureInfoNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`AccelerationStructureCreateInfoNV`] with lifetime-tied pNext safety.
pub struct AccelerationStructureCreateInfoNVBuilder<'a> {
    inner: AccelerationStructureCreateInfoNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl AccelerationStructureCreateInfoNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> AccelerationStructureCreateInfoNVBuilder<'a> {
        AccelerationStructureCreateInfoNVBuilder {
            inner: AccelerationStructureCreateInfoNV {
                s_type: StructureType::from_raw(1000165001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> AccelerationStructureCreateInfoNVBuilder<'a> {
    #[inline]
    pub fn compacted_size(mut self, value: u64) -> Self {
        self.inner.compacted_size = value;
        self
    }
    #[inline]
    pub fn info(mut self, value: AccelerationStructureInfoNV) -> Self {
        self.inner.info = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`AccelerationStructureCreateInfoNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsAccelerationStructureCreateInfoNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for AccelerationStructureCreateInfoNVBuilder<'a> {
    type Target = AccelerationStructureCreateInfoNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for AccelerationStructureCreateInfoNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`BindAccelerationStructureMemoryInfoNV`] with lifetime-tied pNext safety.
pub struct BindAccelerationStructureMemoryInfoNVBuilder<'a> {
    inner: BindAccelerationStructureMemoryInfoNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl BindAccelerationStructureMemoryInfoNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> BindAccelerationStructureMemoryInfoNVBuilder<'a> {
        BindAccelerationStructureMemoryInfoNVBuilder {
            inner: BindAccelerationStructureMemoryInfoNV {
                s_type: StructureType::from_raw(1000165006i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> BindAccelerationStructureMemoryInfoNVBuilder<'a> {
    #[inline]
    pub fn acceleration_structure(mut self, value: AccelerationStructureNV) -> Self {
        self.inner.acceleration_structure = value;
        self
    }
    #[inline]
    pub fn memory(mut self, value: DeviceMemory) -> Self {
        self.inner.memory = value;
        self
    }
    #[inline]
    pub fn memory_offset(mut self, value: u64) -> Self {
        self.inner.memory_offset = value;
        self
    }
    #[inline]
    pub fn device_indices(mut self, slice: &'a [u32]) -> Self {
        self.inner.device_index_count = slice.len() as u32;
        self.inner.p_device_indices = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`BindAccelerationStructureMemoryInfoNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsBindAccelerationStructureMemoryInfoNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for BindAccelerationStructureMemoryInfoNVBuilder<'a> {
    type Target = BindAccelerationStructureMemoryInfoNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for BindAccelerationStructureMemoryInfoNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`WriteDescriptorSetAccelerationStructureKHR`] with lifetime-tied pNext safety.
pub struct WriteDescriptorSetAccelerationStructureKHRBuilder<'a> {
    inner: WriteDescriptorSetAccelerationStructureKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl WriteDescriptorSetAccelerationStructureKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> WriteDescriptorSetAccelerationStructureKHRBuilder<'a> {
        WriteDescriptorSetAccelerationStructureKHRBuilder {
            inner: WriteDescriptorSetAccelerationStructureKHR {
                s_type: StructureType::from_raw(1000150007i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> WriteDescriptorSetAccelerationStructureKHRBuilder<'a> {
    #[inline]
    pub fn acceleration_structure_count(mut self, value: u32) -> Self {
        self.inner.acceleration_structure_count = value;
        self
    }
    #[inline]
    pub fn acceleration_structures(
        mut self,
        slice: &'a [AccelerationStructureKHR],
    ) -> Self {
        self.inner.acceleration_structure_count = slice.len() as u32;
        self.inner.p_acceleration_structures = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`WriteDescriptorSetAccelerationStructureKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsWriteDescriptorSetAccelerationStructureKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for WriteDescriptorSetAccelerationStructureKHRBuilder<'a> {
    type Target = WriteDescriptorSetAccelerationStructureKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for WriteDescriptorSetAccelerationStructureKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`WriteDescriptorSetAccelerationStructureNV`] with lifetime-tied pNext safety.
pub struct WriteDescriptorSetAccelerationStructureNVBuilder<'a> {
    inner: WriteDescriptorSetAccelerationStructureNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl WriteDescriptorSetAccelerationStructureNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> WriteDescriptorSetAccelerationStructureNVBuilder<'a> {
        WriteDescriptorSetAccelerationStructureNVBuilder {
            inner: WriteDescriptorSetAccelerationStructureNV {
                s_type: StructureType::from_raw(1000165007i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> WriteDescriptorSetAccelerationStructureNVBuilder<'a> {
    #[inline]
    pub fn acceleration_structure_count(mut self, value: u32) -> Self {
        self.inner.acceleration_structure_count = value;
        self
    }
    #[inline]
    pub fn acceleration_structures(
        mut self,
        slice: &'a [AccelerationStructureNV],
    ) -> Self {
        self.inner.acceleration_structure_count = slice.len() as u32;
        self.inner.p_acceleration_structures = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`WriteDescriptorSetAccelerationStructureNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsWriteDescriptorSetAccelerationStructureNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for WriteDescriptorSetAccelerationStructureNVBuilder<'a> {
    type Target = WriteDescriptorSetAccelerationStructureNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for WriteDescriptorSetAccelerationStructureNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`AccelerationStructureMemoryRequirementsInfoNV`] with lifetime-tied pNext safety.
pub struct AccelerationStructureMemoryRequirementsInfoNVBuilder<'a> {
    inner: AccelerationStructureMemoryRequirementsInfoNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl AccelerationStructureMemoryRequirementsInfoNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> AccelerationStructureMemoryRequirementsInfoNVBuilder<'a> {
        AccelerationStructureMemoryRequirementsInfoNVBuilder {
            inner: AccelerationStructureMemoryRequirementsInfoNV {
                s_type: StructureType::from_raw(1000165008i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> AccelerationStructureMemoryRequirementsInfoNVBuilder<'a> {
    #[inline]
    pub fn r#type(
        mut self,
        value: AccelerationStructureMemoryRequirementsTypeNV,
    ) -> Self {
        self.inner.r#type = value;
        self
    }
    #[inline]
    pub fn acceleration_structure(mut self, value: AccelerationStructureNV) -> Self {
        self.inner.acceleration_structure = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`AccelerationStructureMemoryRequirementsInfoNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsAccelerationStructureMemoryRequirementsInfoNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for AccelerationStructureMemoryRequirementsInfoNVBuilder<'a> {
    type Target = AccelerationStructureMemoryRequirementsInfoNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for AccelerationStructureMemoryRequirementsInfoNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceAccelerationStructureFeaturesKHR`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceAccelerationStructureFeaturesKHRBuilder<'a> {
    inner: PhysicalDeviceAccelerationStructureFeaturesKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceAccelerationStructureFeaturesKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceAccelerationStructureFeaturesKHRBuilder<'a> {
        PhysicalDeviceAccelerationStructureFeaturesKHRBuilder {
            inner: PhysicalDeviceAccelerationStructureFeaturesKHR {
                s_type: StructureType::from_raw(1000150013i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceAccelerationStructureFeaturesKHRBuilder<'a> {
    #[inline]
    pub fn acceleration_structure(mut self, value: bool) -> Self {
        self.inner.acceleration_structure = value as u32;
        self
    }
    #[inline]
    pub fn acceleration_structure_capture_replay(mut self, value: bool) -> Self {
        self.inner.acceleration_structure_capture_replay = value as u32;
        self
    }
    #[inline]
    pub fn acceleration_structure_indirect_build(mut self, value: bool) -> Self {
        self.inner.acceleration_structure_indirect_build = value as u32;
        self
    }
    #[inline]
    pub fn acceleration_structure_host_commands(mut self, value: bool) -> Self {
        self.inner.acceleration_structure_host_commands = value as u32;
        self
    }
    #[inline]
    pub fn descriptor_binding_acceleration_structure_update_after_bind(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.descriptor_binding_acceleration_structure_update_after_bind = value
            as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceAccelerationStructureFeaturesKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceAccelerationStructureFeaturesKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceAccelerationStructureFeaturesKHRBuilder<'a> {
    type Target = PhysicalDeviceAccelerationStructureFeaturesKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceAccelerationStructureFeaturesKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceRayTracingPipelineFeaturesKHR`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceRayTracingPipelineFeaturesKHRBuilder<'a> {
    inner: PhysicalDeviceRayTracingPipelineFeaturesKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceRayTracingPipelineFeaturesKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceRayTracingPipelineFeaturesKHRBuilder<'a> {
        PhysicalDeviceRayTracingPipelineFeaturesKHRBuilder {
            inner: PhysicalDeviceRayTracingPipelineFeaturesKHR {
                s_type: StructureType::from_raw(1000347000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceRayTracingPipelineFeaturesKHRBuilder<'a> {
    #[inline]
    pub fn ray_tracing_pipeline(mut self, value: bool) -> Self {
        self.inner.ray_tracing_pipeline = value as u32;
        self
    }
    #[inline]
    pub fn ray_tracing_pipeline_shader_group_handle_capture_replay(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.ray_tracing_pipeline_shader_group_handle_capture_replay = value
            as u32;
        self
    }
    #[inline]
    pub fn ray_tracing_pipeline_shader_group_handle_capture_replay_mixed(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.ray_tracing_pipeline_shader_group_handle_capture_replay_mixed = value
            as u32;
        self
    }
    #[inline]
    pub fn ray_tracing_pipeline_trace_rays_indirect(mut self, value: bool) -> Self {
        self.inner.ray_tracing_pipeline_trace_rays_indirect = value as u32;
        self
    }
    #[inline]
    pub fn ray_traversal_primitive_culling(mut self, value: bool) -> Self {
        self.inner.ray_traversal_primitive_culling = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceRayTracingPipelineFeaturesKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceRayTracingPipelineFeaturesKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceRayTracingPipelineFeaturesKHRBuilder<'a> {
    type Target = PhysicalDeviceRayTracingPipelineFeaturesKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceRayTracingPipelineFeaturesKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceRayQueryFeaturesKHR`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceRayQueryFeaturesKHRBuilder<'a> {
    inner: PhysicalDeviceRayQueryFeaturesKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceRayQueryFeaturesKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceRayQueryFeaturesKHRBuilder<'a> {
        PhysicalDeviceRayQueryFeaturesKHRBuilder {
            inner: PhysicalDeviceRayQueryFeaturesKHR {
                s_type: StructureType::from_raw(1000348013i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceRayQueryFeaturesKHRBuilder<'a> {
    #[inline]
    pub fn ray_query(mut self, value: bool) -> Self {
        self.inner.ray_query = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceRayQueryFeaturesKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceRayQueryFeaturesKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceRayQueryFeaturesKHRBuilder<'a> {
    type Target = PhysicalDeviceRayQueryFeaturesKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceRayQueryFeaturesKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceAccelerationStructurePropertiesKHR`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceAccelerationStructurePropertiesKHRBuilder<'a> {
    inner: PhysicalDeviceAccelerationStructurePropertiesKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceAccelerationStructurePropertiesKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceAccelerationStructurePropertiesKHRBuilder<'a> {
        PhysicalDeviceAccelerationStructurePropertiesKHRBuilder {
            inner: PhysicalDeviceAccelerationStructurePropertiesKHR {
                s_type: StructureType::from_raw(1000150014i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceAccelerationStructurePropertiesKHRBuilder<'a> {
    #[inline]
    pub fn max_geometry_count(mut self, value: u64) -> Self {
        self.inner.max_geometry_count = value;
        self
    }
    #[inline]
    pub fn max_instance_count(mut self, value: u64) -> Self {
        self.inner.max_instance_count = value;
        self
    }
    #[inline]
    pub fn max_primitive_count(mut self, value: u64) -> Self {
        self.inner.max_primitive_count = value;
        self
    }
    #[inline]
    pub fn max_per_stage_descriptor_acceleration_structures(
        mut self,
        value: u32,
    ) -> Self {
        self.inner.max_per_stage_descriptor_acceleration_structures = value;
        self
    }
    #[inline]
    pub fn max_per_stage_descriptor_update_after_bind_acceleration_structures(
        mut self,
        value: u32,
    ) -> Self {
        self.inner.max_per_stage_descriptor_update_after_bind_acceleration_structures = value;
        self
    }
    #[inline]
    pub fn max_descriptor_set_acceleration_structures(mut self, value: u32) -> Self {
        self.inner.max_descriptor_set_acceleration_structures = value;
        self
    }
    #[inline]
    pub fn max_descriptor_set_update_after_bind_acceleration_structures(
        mut self,
        value: u32,
    ) -> Self {
        self.inner.max_descriptor_set_update_after_bind_acceleration_structures = value;
        self
    }
    #[inline]
    pub fn min_acceleration_structure_scratch_offset_alignment(
        mut self,
        value: u32,
    ) -> Self {
        self.inner.min_acceleration_structure_scratch_offset_alignment = value;
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDeviceAccelerationStructurePropertiesKHRBuilder<'a> {
    type Target = PhysicalDeviceAccelerationStructurePropertiesKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceAccelerationStructurePropertiesKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceRayTracingPipelinePropertiesKHR`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceRayTracingPipelinePropertiesKHRBuilder<'a> {
    inner: PhysicalDeviceRayTracingPipelinePropertiesKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceRayTracingPipelinePropertiesKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceRayTracingPipelinePropertiesKHRBuilder<'a> {
        PhysicalDeviceRayTracingPipelinePropertiesKHRBuilder {
            inner: PhysicalDeviceRayTracingPipelinePropertiesKHR {
                s_type: StructureType::from_raw(1000347001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceRayTracingPipelinePropertiesKHRBuilder<'a> {
    #[inline]
    pub fn shader_group_handle_size(mut self, value: u32) -> Self {
        self.inner.shader_group_handle_size = value;
        self
    }
    #[inline]
    pub fn max_ray_recursion_depth(mut self, value: u32) -> Self {
        self.inner.max_ray_recursion_depth = value;
        self
    }
    #[inline]
    pub fn max_shader_group_stride(mut self, value: u32) -> Self {
        self.inner.max_shader_group_stride = value;
        self
    }
    #[inline]
    pub fn shader_group_base_alignment(mut self, value: u32) -> Self {
        self.inner.shader_group_base_alignment = value;
        self
    }
    #[inline]
    pub fn shader_group_handle_capture_replay_size(mut self, value: u32) -> Self {
        self.inner.shader_group_handle_capture_replay_size = value;
        self
    }
    #[inline]
    pub fn max_ray_dispatch_invocation_count(mut self, value: u32) -> Self {
        self.inner.max_ray_dispatch_invocation_count = value;
        self
    }
    #[inline]
    pub fn shader_group_handle_alignment(mut self, value: u32) -> Self {
        self.inner.shader_group_handle_alignment = value;
        self
    }
    #[inline]
    pub fn max_ray_hit_attribute_size(mut self, value: u32) -> Self {
        self.inner.max_ray_hit_attribute_size = value;
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceRayTracingPipelinePropertiesKHRBuilder<'a> {
    type Target = PhysicalDeviceRayTracingPipelinePropertiesKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceRayTracingPipelinePropertiesKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceRayTracingPropertiesNV`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceRayTracingPropertiesNVBuilder<'a> {
    inner: PhysicalDeviceRayTracingPropertiesNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceRayTracingPropertiesNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceRayTracingPropertiesNVBuilder<'a> {
        PhysicalDeviceRayTracingPropertiesNVBuilder {
            inner: PhysicalDeviceRayTracingPropertiesNV {
                s_type: StructureType::from_raw(1000165009i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceRayTracingPropertiesNVBuilder<'a> {
    #[inline]
    pub fn shader_group_handle_size(mut self, value: u32) -> Self {
        self.inner.shader_group_handle_size = value;
        self
    }
    #[inline]
    pub fn max_recursion_depth(mut self, value: u32) -> Self {
        self.inner.max_recursion_depth = value;
        self
    }
    #[inline]
    pub fn max_shader_group_stride(mut self, value: u32) -> Self {
        self.inner.max_shader_group_stride = value;
        self
    }
    #[inline]
    pub fn shader_group_base_alignment(mut self, value: u32) -> Self {
        self.inner.shader_group_base_alignment = value;
        self
    }
    #[inline]
    pub fn max_geometry_count(mut self, value: u64) -> Self {
        self.inner.max_geometry_count = value;
        self
    }
    #[inline]
    pub fn max_instance_count(mut self, value: u64) -> Self {
        self.inner.max_instance_count = value;
        self
    }
    #[inline]
    pub fn max_triangle_count(mut self, value: u64) -> Self {
        self.inner.max_triangle_count = value;
        self
    }
    #[inline]
    pub fn max_descriptor_set_acceleration_structures(mut self, value: u32) -> Self {
        self.inner.max_descriptor_set_acceleration_structures = value;
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceRayTracingPropertiesNVBuilder<'a> {
    type Target = PhysicalDeviceRayTracingPropertiesNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceRayTracingPropertiesNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`StridedDeviceAddressRegionKHR`].
pub struct StridedDeviceAddressRegionKHRBuilder {
    inner: StridedDeviceAddressRegionKHR,
}
impl StridedDeviceAddressRegionKHR {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> StridedDeviceAddressRegionKHRBuilder {
        StridedDeviceAddressRegionKHRBuilder {
            inner: StridedDeviceAddressRegionKHR {
                ..Default::default()
            },
        }
    }
}
impl StridedDeviceAddressRegionKHRBuilder {
    #[inline]
    pub fn device_address(mut self, value: u64) -> Self {
        self.inner.device_address = value;
        self
    }
    #[inline]
    pub fn stride(mut self, value: u64) -> Self {
        self.inner.stride = value;
        self
    }
    #[inline]
    pub fn size(mut self, value: u64) -> Self {
        self.inner.size = value;
        self
    }
}
impl core::ops::Deref for StridedDeviceAddressRegionKHRBuilder {
    type Target = StridedDeviceAddressRegionKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for StridedDeviceAddressRegionKHRBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`TraceRaysIndirectCommandKHR`].
pub struct TraceRaysIndirectCommandKHRBuilder {
    inner: TraceRaysIndirectCommandKHR,
}
impl TraceRaysIndirectCommandKHR {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> TraceRaysIndirectCommandKHRBuilder {
        TraceRaysIndirectCommandKHRBuilder {
            inner: TraceRaysIndirectCommandKHR {
                ..Default::default()
            },
        }
    }
}
impl TraceRaysIndirectCommandKHRBuilder {
    #[inline]
    pub fn width(mut self, value: u32) -> Self {
        self.inner.width = value;
        self
    }
    #[inline]
    pub fn height(mut self, value: u32) -> Self {
        self.inner.height = value;
        self
    }
    #[inline]
    pub fn depth(mut self, value: u32) -> Self {
        self.inner.depth = value;
        self
    }
}
impl core::ops::Deref for TraceRaysIndirectCommandKHRBuilder {
    type Target = TraceRaysIndirectCommandKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for TraceRaysIndirectCommandKHRBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`TraceRaysIndirectCommand2KHR`].
pub struct TraceRaysIndirectCommand2KHRBuilder {
    inner: TraceRaysIndirectCommand2KHR,
}
impl TraceRaysIndirectCommand2KHR {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> TraceRaysIndirectCommand2KHRBuilder {
        TraceRaysIndirectCommand2KHRBuilder {
            inner: TraceRaysIndirectCommand2KHR {
                ..Default::default()
            },
        }
    }
}
impl TraceRaysIndirectCommand2KHRBuilder {
    #[inline]
    pub fn raygen_shader_record_address(mut self, value: u64) -> Self {
        self.inner.raygen_shader_record_address = value;
        self
    }
    #[inline]
    pub fn raygen_shader_record_size(mut self, value: u64) -> Self {
        self.inner.raygen_shader_record_size = value;
        self
    }
    #[inline]
    pub fn miss_shader_binding_table_address(mut self, value: u64) -> Self {
        self.inner.miss_shader_binding_table_address = value;
        self
    }
    #[inline]
    pub fn miss_shader_binding_table_size(mut self, value: u64) -> Self {
        self.inner.miss_shader_binding_table_size = value;
        self
    }
    #[inline]
    pub fn miss_shader_binding_table_stride(mut self, value: u64) -> Self {
        self.inner.miss_shader_binding_table_stride = value;
        self
    }
    #[inline]
    pub fn hit_shader_binding_table_address(mut self, value: u64) -> Self {
        self.inner.hit_shader_binding_table_address = value;
        self
    }
    #[inline]
    pub fn hit_shader_binding_table_size(mut self, value: u64) -> Self {
        self.inner.hit_shader_binding_table_size = value;
        self
    }
    #[inline]
    pub fn hit_shader_binding_table_stride(mut self, value: u64) -> Self {
        self.inner.hit_shader_binding_table_stride = value;
        self
    }
    #[inline]
    pub fn callable_shader_binding_table_address(mut self, value: u64) -> Self {
        self.inner.callable_shader_binding_table_address = value;
        self
    }
    #[inline]
    pub fn callable_shader_binding_table_size(mut self, value: u64) -> Self {
        self.inner.callable_shader_binding_table_size = value;
        self
    }
    #[inline]
    pub fn callable_shader_binding_table_stride(mut self, value: u64) -> Self {
        self.inner.callable_shader_binding_table_stride = value;
        self
    }
    #[inline]
    pub fn width(mut self, value: u32) -> Self {
        self.inner.width = value;
        self
    }
    #[inline]
    pub fn height(mut self, value: u32) -> Self {
        self.inner.height = value;
        self
    }
    #[inline]
    pub fn depth(mut self, value: u32) -> Self {
        self.inner.depth = value;
        self
    }
}
impl core::ops::Deref for TraceRaysIndirectCommand2KHRBuilder {
    type Target = TraceRaysIndirectCommand2KHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for TraceRaysIndirectCommand2KHRBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceRayTracingMaintenance1FeaturesKHR`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceRayTracingMaintenance1FeaturesKHRBuilder<'a> {
    inner: PhysicalDeviceRayTracingMaintenance1FeaturesKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceRayTracingMaintenance1FeaturesKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceRayTracingMaintenance1FeaturesKHRBuilder<'a> {
        PhysicalDeviceRayTracingMaintenance1FeaturesKHRBuilder {
            inner: PhysicalDeviceRayTracingMaintenance1FeaturesKHR {
                s_type: StructureType::from_raw(1000386000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceRayTracingMaintenance1FeaturesKHRBuilder<'a> {
    #[inline]
    pub fn ray_tracing_maintenance1(mut self, value: bool) -> Self {
        self.inner.ray_tracing_maintenance1 = value as u32;
        self
    }
    #[inline]
    pub fn ray_tracing_pipeline_trace_rays_indirect2(mut self, value: bool) -> Self {
        self.inner.ray_tracing_pipeline_trace_rays_indirect2 = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceRayTracingMaintenance1FeaturesKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceRayTracingMaintenance1FeaturesKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDeviceRayTracingMaintenance1FeaturesKHRBuilder<'a> {
    type Target = PhysicalDeviceRayTracingMaintenance1FeaturesKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceRayTracingMaintenance1FeaturesKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DrmFormatModifierPropertiesListEXT`] with lifetime-tied pNext safety.
pub struct DrmFormatModifierPropertiesListEXTBuilder<'a> {
    inner: DrmFormatModifierPropertiesListEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DrmFormatModifierPropertiesListEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> DrmFormatModifierPropertiesListEXTBuilder<'a> {
        DrmFormatModifierPropertiesListEXTBuilder {
            inner: DrmFormatModifierPropertiesListEXT {
                s_type: StructureType::from_raw(1000158000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DrmFormatModifierPropertiesListEXTBuilder<'a> {
    #[inline]
    pub fn drm_format_modifier_count(mut self, value: u32) -> Self {
        self.inner.drm_format_modifier_count = value;
        self
    }
    #[inline]
    pub fn drm_format_modifier_properties(
        mut self,
        slice: &'a mut [DrmFormatModifierPropertiesEXT],
    ) -> Self {
        self.inner.drm_format_modifier_count = slice.len() as u32;
        self.inner.p_drm_format_modifier_properties = slice.as_mut_ptr();
        self
    }
}
impl<'a> core::ops::Deref for DrmFormatModifierPropertiesListEXTBuilder<'a> {
    type Target = DrmFormatModifierPropertiesListEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for DrmFormatModifierPropertiesListEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DrmFormatModifierPropertiesEXT`].
pub struct DrmFormatModifierPropertiesEXTBuilder {
    inner: DrmFormatModifierPropertiesEXT,
}
impl DrmFormatModifierPropertiesEXT {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> DrmFormatModifierPropertiesEXTBuilder {
        DrmFormatModifierPropertiesEXTBuilder {
            inner: DrmFormatModifierPropertiesEXT {
                ..Default::default()
            },
        }
    }
}
impl DrmFormatModifierPropertiesEXTBuilder {
    #[inline]
    pub fn drm_format_modifier(mut self, value: u64) -> Self {
        self.inner.drm_format_modifier = value;
        self
    }
    #[inline]
    pub fn drm_format_modifier_plane_count(mut self, value: u32) -> Self {
        self.inner.drm_format_modifier_plane_count = value;
        self
    }
    #[inline]
    pub fn drm_format_modifier_tiling_features(
        mut self,
        value: FormatFeatureFlags,
    ) -> Self {
        self.inner.drm_format_modifier_tiling_features = value;
        self
    }
}
impl core::ops::Deref for DrmFormatModifierPropertiesEXTBuilder {
    type Target = DrmFormatModifierPropertiesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for DrmFormatModifierPropertiesEXTBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceImageDrmFormatModifierInfoEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceImageDrmFormatModifierInfoEXTBuilder<'a> {
    inner: PhysicalDeviceImageDrmFormatModifierInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceImageDrmFormatModifierInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceImageDrmFormatModifierInfoEXTBuilder<'a> {
        PhysicalDeviceImageDrmFormatModifierInfoEXTBuilder {
            inner: PhysicalDeviceImageDrmFormatModifierInfoEXT {
                s_type: StructureType::from_raw(1000158002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceImageDrmFormatModifierInfoEXTBuilder<'a> {
    #[inline]
    pub fn drm_format_modifier(mut self, value: u64) -> Self {
        self.inner.drm_format_modifier = value;
        self
    }
    #[inline]
    pub fn sharing_mode(mut self, value: SharingMode) -> Self {
        self.inner.sharing_mode = value;
        self
    }
    #[inline]
    pub fn queue_family_indices(mut self, slice: &'a [u32]) -> Self {
        self.inner.queue_family_index_count = slice.len() as u32;
        self.inner.p_queue_family_indices = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceImageDrmFormatModifierInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceImageDrmFormatModifierInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceImageDrmFormatModifierInfoEXTBuilder<'a> {
    type Target = PhysicalDeviceImageDrmFormatModifierInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceImageDrmFormatModifierInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ImageDrmFormatModifierListCreateInfoEXT`] with lifetime-tied pNext safety.
pub struct ImageDrmFormatModifierListCreateInfoEXTBuilder<'a> {
    inner: ImageDrmFormatModifierListCreateInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ImageDrmFormatModifierListCreateInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ImageDrmFormatModifierListCreateInfoEXTBuilder<'a> {
        ImageDrmFormatModifierListCreateInfoEXTBuilder {
            inner: ImageDrmFormatModifierListCreateInfoEXT {
                s_type: StructureType::from_raw(1000158003i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ImageDrmFormatModifierListCreateInfoEXTBuilder<'a> {
    #[inline]
    pub fn drm_format_modifiers(mut self, slice: &'a [u64]) -> Self {
        self.inner.drm_format_modifier_count = slice.len() as u32;
        self.inner.p_drm_format_modifiers = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`ImageDrmFormatModifierListCreateInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsImageDrmFormatModifierListCreateInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for ImageDrmFormatModifierListCreateInfoEXTBuilder<'a> {
    type Target = ImageDrmFormatModifierListCreateInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ImageDrmFormatModifierListCreateInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ImageDrmFormatModifierExplicitCreateInfoEXT`] with lifetime-tied pNext safety.
pub struct ImageDrmFormatModifierExplicitCreateInfoEXTBuilder<'a> {
    inner: ImageDrmFormatModifierExplicitCreateInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ImageDrmFormatModifierExplicitCreateInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ImageDrmFormatModifierExplicitCreateInfoEXTBuilder<'a> {
        ImageDrmFormatModifierExplicitCreateInfoEXTBuilder {
            inner: ImageDrmFormatModifierExplicitCreateInfoEXT {
                s_type: StructureType::from_raw(1000158004i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ImageDrmFormatModifierExplicitCreateInfoEXTBuilder<'a> {
    #[inline]
    pub fn drm_format_modifier(mut self, value: u64) -> Self {
        self.inner.drm_format_modifier = value;
        self
    }
    #[inline]
    pub fn plane_layouts(mut self, slice: &'a [SubresourceLayout]) -> Self {
        self.inner.drm_format_modifier_plane_count = slice.len() as u32;
        self.inner.p_plane_layouts = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`ImageDrmFormatModifierExplicitCreateInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsImageDrmFormatModifierExplicitCreateInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for ImageDrmFormatModifierExplicitCreateInfoEXTBuilder<'a> {
    type Target = ImageDrmFormatModifierExplicitCreateInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ImageDrmFormatModifierExplicitCreateInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ImageDrmFormatModifierPropertiesEXT`] with lifetime-tied pNext safety.
pub struct ImageDrmFormatModifierPropertiesEXTBuilder<'a> {
    inner: ImageDrmFormatModifierPropertiesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ImageDrmFormatModifierPropertiesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ImageDrmFormatModifierPropertiesEXTBuilder<'a> {
        ImageDrmFormatModifierPropertiesEXTBuilder {
            inner: ImageDrmFormatModifierPropertiesEXT {
                s_type: StructureType::from_raw(1000158005i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ImageDrmFormatModifierPropertiesEXTBuilder<'a> {
    #[inline]
    pub fn drm_format_modifier(mut self, value: u64) -> Self {
        self.inner.drm_format_modifier = value;
        self
    }
}
impl<'a> core::ops::Deref for ImageDrmFormatModifierPropertiesEXTBuilder<'a> {
    type Target = ImageDrmFormatModifierPropertiesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ImageDrmFormatModifierPropertiesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ImageStencilUsageCreateInfo`] with lifetime-tied pNext safety.
pub struct ImageStencilUsageCreateInfoBuilder<'a> {
    inner: ImageStencilUsageCreateInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ImageStencilUsageCreateInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ImageStencilUsageCreateInfoBuilder<'a> {
        ImageStencilUsageCreateInfoBuilder {
            inner: ImageStencilUsageCreateInfo {
                s_type: StructureType::from_raw(1000246000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ImageStencilUsageCreateInfoBuilder<'a> {
    #[inline]
    pub fn stencil_usage(mut self, value: ImageUsageFlags) -> Self {
        self.inner.stencil_usage = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`ImageStencilUsageCreateInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsImageStencilUsageCreateInfo>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for ImageStencilUsageCreateInfoBuilder<'a> {
    type Target = ImageStencilUsageCreateInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ImageStencilUsageCreateInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DeviceMemoryOverallocationCreateInfoAMD`] with lifetime-tied pNext safety.
pub struct DeviceMemoryOverallocationCreateInfoAMDBuilder<'a> {
    inner: DeviceMemoryOverallocationCreateInfoAMD,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DeviceMemoryOverallocationCreateInfoAMD {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> DeviceMemoryOverallocationCreateInfoAMDBuilder<'a> {
        DeviceMemoryOverallocationCreateInfoAMDBuilder {
            inner: DeviceMemoryOverallocationCreateInfoAMD {
                s_type: StructureType::from_raw(1000189000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DeviceMemoryOverallocationCreateInfoAMDBuilder<'a> {
    #[inline]
    pub fn overallocation_behavior(
        mut self,
        value: MemoryOverallocationBehaviorAMD,
    ) -> Self {
        self.inner.overallocation_behavior = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`DeviceMemoryOverallocationCreateInfoAMD`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsDeviceMemoryOverallocationCreateInfoAMD>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for DeviceMemoryOverallocationCreateInfoAMDBuilder<'a> {
    type Target = DeviceMemoryOverallocationCreateInfoAMD;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for DeviceMemoryOverallocationCreateInfoAMDBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceFragmentDensityMapFeaturesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'a> {
    inner: PhysicalDeviceFragmentDensityMapFeaturesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceFragmentDensityMapFeaturesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'a> {
        PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder {
            inner: PhysicalDeviceFragmentDensityMapFeaturesEXT {
                s_type: StructureType::from_raw(1000218000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'a> {
    #[inline]
    pub fn fragment_density_map(mut self, value: bool) -> Self {
        self.inner.fragment_density_map = value as u32;
        self
    }
    #[inline]
    pub fn fragment_density_map_dynamic(mut self, value: bool) -> Self {
        self.inner.fragment_density_map_dynamic = value as u32;
        self
    }
    #[inline]
    pub fn fragment_density_map_non_subsampled_images(mut self, value: bool) -> Self {
        self.inner.fragment_density_map_non_subsampled_images = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceFragmentDensityMapFeaturesEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceFragmentDensityMapFeaturesEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'a> {
    type Target = PhysicalDeviceFragmentDensityMapFeaturesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceFragmentDensityMap2FeaturesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceFragmentDensityMap2FeaturesEXTBuilder<'a> {
    inner: PhysicalDeviceFragmentDensityMap2FeaturesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceFragmentDensityMap2FeaturesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceFragmentDensityMap2FeaturesEXTBuilder<'a> {
        PhysicalDeviceFragmentDensityMap2FeaturesEXTBuilder {
            inner: PhysicalDeviceFragmentDensityMap2FeaturesEXT {
                s_type: StructureType::from_raw(1000332000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceFragmentDensityMap2FeaturesEXTBuilder<'a> {
    #[inline]
    pub fn fragment_density_map_deferred(mut self, value: bool) -> Self {
        self.inner.fragment_density_map_deferred = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceFragmentDensityMap2FeaturesEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceFragmentDensityMap2FeaturesEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceFragmentDensityMap2FeaturesEXTBuilder<'a> {
    type Target = PhysicalDeviceFragmentDensityMap2FeaturesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceFragmentDensityMap2FeaturesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceFragmentDensityMapOffsetFeaturesEXTBuilder<'a> {
    inner: PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceFragmentDensityMapOffsetFeaturesEXTBuilder<
        'a,
    > {
        PhysicalDeviceFragmentDensityMapOffsetFeaturesEXTBuilder {
            inner: PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT {
                s_type: StructureType::from_raw(1000425000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceFragmentDensityMapOffsetFeaturesEXTBuilder<'a> {
    #[inline]
    pub fn fragment_density_map_offset(mut self, value: bool) -> Self {
        self.inner.fragment_density_map_offset = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDeviceFragmentDensityMapOffsetFeaturesEXTBuilder<'a> {
    type Target = PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceFragmentDensityMapOffsetFeaturesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceFragmentDensityMapPropertiesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder<'a> {
    inner: PhysicalDeviceFragmentDensityMapPropertiesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceFragmentDensityMapPropertiesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder<'a> {
        PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder {
            inner: PhysicalDeviceFragmentDensityMapPropertiesEXT {
                s_type: StructureType::from_raw(1000218001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder<'a> {
    #[inline]
    pub fn min_fragment_density_texel_size(mut self, value: Extent2D) -> Self {
        self.inner.min_fragment_density_texel_size = value;
        self
    }
    #[inline]
    pub fn max_fragment_density_texel_size(mut self, value: Extent2D) -> Self {
        self.inner.max_fragment_density_texel_size = value;
        self
    }
    #[inline]
    pub fn fragment_density_invocations(mut self, value: bool) -> Self {
        self.inner.fragment_density_invocations = value as u32;
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder<'a> {
    type Target = PhysicalDeviceFragmentDensityMapPropertiesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceFragmentDensityMap2PropertiesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceFragmentDensityMap2PropertiesEXTBuilder<'a> {
    inner: PhysicalDeviceFragmentDensityMap2PropertiesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceFragmentDensityMap2PropertiesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceFragmentDensityMap2PropertiesEXTBuilder<'a> {
        PhysicalDeviceFragmentDensityMap2PropertiesEXTBuilder {
            inner: PhysicalDeviceFragmentDensityMap2PropertiesEXT {
                s_type: StructureType::from_raw(1000332001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceFragmentDensityMap2PropertiesEXTBuilder<'a> {
    #[inline]
    pub fn subsampled_loads(mut self, value: bool) -> Self {
        self.inner.subsampled_loads = value as u32;
        self
    }
    #[inline]
    pub fn subsampled_coarse_reconstruction_early_access(mut self, value: bool) -> Self {
        self.inner.subsampled_coarse_reconstruction_early_access = value as u32;
        self
    }
    #[inline]
    pub fn max_subsampled_array_layers(mut self, value: u32) -> Self {
        self.inner.max_subsampled_array_layers = value;
        self
    }
    #[inline]
    pub fn max_descriptor_set_subsampled_samplers(mut self, value: u32) -> Self {
        self.inner.max_descriptor_set_subsampled_samplers = value;
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceFragmentDensityMap2PropertiesEXTBuilder<'a> {
    type Target = PhysicalDeviceFragmentDensityMap2PropertiesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceFragmentDensityMap2PropertiesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceFragmentDensityMapOffsetPropertiesEXTBuilder<'a> {
    inner: PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceFragmentDensityMapOffsetPropertiesEXTBuilder<
        'a,
    > {
        PhysicalDeviceFragmentDensityMapOffsetPropertiesEXTBuilder {
            inner: PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT {
                s_type: StructureType::from_raw(1000425001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceFragmentDensityMapOffsetPropertiesEXTBuilder<'a> {
    #[inline]
    pub fn fragment_density_offset_granularity(mut self, value: Extent2D) -> Self {
        self.inner.fragment_density_offset_granularity = value;
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDeviceFragmentDensityMapOffsetPropertiesEXTBuilder<'a> {
    type Target = PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceFragmentDensityMapOffsetPropertiesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`RenderPassFragmentDensityMapCreateInfoEXT`] with lifetime-tied pNext safety.
pub struct RenderPassFragmentDensityMapCreateInfoEXTBuilder<'a> {
    inner: RenderPassFragmentDensityMapCreateInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl RenderPassFragmentDensityMapCreateInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> RenderPassFragmentDensityMapCreateInfoEXTBuilder<'a> {
        RenderPassFragmentDensityMapCreateInfoEXTBuilder {
            inner: RenderPassFragmentDensityMapCreateInfoEXT {
                s_type: StructureType::from_raw(1000218002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> RenderPassFragmentDensityMapCreateInfoEXTBuilder<'a> {
    #[inline]
    pub fn fragment_density_map_attachment(
        mut self,
        value: AttachmentReference,
    ) -> Self {
        self.inner.fragment_density_map_attachment = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`RenderPassFragmentDensityMapCreateInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsRenderPassFragmentDensityMapCreateInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for RenderPassFragmentDensityMapCreateInfoEXTBuilder<'a> {
    type Target = RenderPassFragmentDensityMapCreateInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for RenderPassFragmentDensityMapCreateInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`RenderPassFragmentDensityMapOffsetEndInfoEXT`] with lifetime-tied pNext safety.
pub struct RenderPassFragmentDensityMapOffsetEndInfoEXTBuilder<'a> {
    inner: RenderPassFragmentDensityMapOffsetEndInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl RenderPassFragmentDensityMapOffsetEndInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> RenderPassFragmentDensityMapOffsetEndInfoEXTBuilder<'a> {
        RenderPassFragmentDensityMapOffsetEndInfoEXTBuilder {
            inner: RenderPassFragmentDensityMapOffsetEndInfoEXT {
                s_type: StructureType::from_raw(1000425002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> RenderPassFragmentDensityMapOffsetEndInfoEXTBuilder<'a> {
    #[inline]
    pub fn fragment_density_offsets(mut self, slice: &'a [Offset2D]) -> Self {
        self.inner.fragment_density_offset_count = slice.len() as u32;
        self.inner.p_fragment_density_offsets = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`RenderPassFragmentDensityMapOffsetEndInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsRenderPassFragmentDensityMapOffsetEndInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for RenderPassFragmentDensityMapOffsetEndInfoEXTBuilder<'a> {
    type Target = RenderPassFragmentDensityMapOffsetEndInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for RenderPassFragmentDensityMapOffsetEndInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceScalarBlockLayoutFeatures`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceScalarBlockLayoutFeaturesBuilder<'a> {
    inner: PhysicalDeviceScalarBlockLayoutFeatures,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceScalarBlockLayoutFeatures {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceScalarBlockLayoutFeaturesBuilder<'a> {
        PhysicalDeviceScalarBlockLayoutFeaturesBuilder {
            inner: PhysicalDeviceScalarBlockLayoutFeatures {
                s_type: StructureType::from_raw(1000221000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceScalarBlockLayoutFeaturesBuilder<'a> {
    #[inline]
    pub fn scalar_block_layout(mut self, value: bool) -> Self {
        self.inner.scalar_block_layout = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceScalarBlockLayoutFeatures`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceScalarBlockLayoutFeatures>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceScalarBlockLayoutFeaturesBuilder<'a> {
    type Target = PhysicalDeviceScalarBlockLayoutFeatures;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceScalarBlockLayoutFeaturesBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`SurfaceProtectedCapabilitiesKHR`] with lifetime-tied pNext safety.
pub struct SurfaceProtectedCapabilitiesKHRBuilder<'a> {
    inner: SurfaceProtectedCapabilitiesKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl SurfaceProtectedCapabilitiesKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> SurfaceProtectedCapabilitiesKHRBuilder<'a> {
        SurfaceProtectedCapabilitiesKHRBuilder {
            inner: SurfaceProtectedCapabilitiesKHR {
                s_type: StructureType::from_raw(1000239000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> SurfaceProtectedCapabilitiesKHRBuilder<'a> {
    #[inline]
    pub fn supports_protected(mut self, value: bool) -> Self {
        self.inner.supports_protected = value as u32;
        self
    }
}
impl<'a> core::ops::Deref for SurfaceProtectedCapabilitiesKHRBuilder<'a> {
    type Target = SurfaceProtectedCapabilitiesKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for SurfaceProtectedCapabilitiesKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceUniformBufferStandardLayoutFeatures`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceUniformBufferStandardLayoutFeaturesBuilder<'a> {
    inner: PhysicalDeviceUniformBufferStandardLayoutFeatures,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceUniformBufferStandardLayoutFeatures {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceUniformBufferStandardLayoutFeaturesBuilder<
        'a,
    > {
        PhysicalDeviceUniformBufferStandardLayoutFeaturesBuilder {
            inner: PhysicalDeviceUniformBufferStandardLayoutFeatures {
                s_type: StructureType::from_raw(1000253000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceUniformBufferStandardLayoutFeaturesBuilder<'a> {
    #[inline]
    pub fn uniform_buffer_standard_layout(mut self, value: bool) -> Self {
        self.inner.uniform_buffer_standard_layout = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceUniformBufferStandardLayoutFeatures`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceUniformBufferStandardLayoutFeatures>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDeviceUniformBufferStandardLayoutFeaturesBuilder<'a> {
    type Target = PhysicalDeviceUniformBufferStandardLayoutFeatures;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceUniformBufferStandardLayoutFeaturesBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceDepthClipEnableFeaturesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceDepthClipEnableFeaturesEXTBuilder<'a> {
    inner: PhysicalDeviceDepthClipEnableFeaturesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceDepthClipEnableFeaturesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceDepthClipEnableFeaturesEXTBuilder<'a> {
        PhysicalDeviceDepthClipEnableFeaturesEXTBuilder {
            inner: PhysicalDeviceDepthClipEnableFeaturesEXT {
                s_type: StructureType::from_raw(1000102000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceDepthClipEnableFeaturesEXTBuilder<'a> {
    #[inline]
    pub fn depth_clip_enable(mut self, value: bool) -> Self {
        self.inner.depth_clip_enable = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceDepthClipEnableFeaturesEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceDepthClipEnableFeaturesEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceDepthClipEnableFeaturesEXTBuilder<'a> {
    type Target = PhysicalDeviceDepthClipEnableFeaturesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceDepthClipEnableFeaturesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PipelineRasterizationDepthClipStateCreateInfoEXT`] with lifetime-tied pNext safety.
pub struct PipelineRasterizationDepthClipStateCreateInfoEXTBuilder<'a> {
    inner: PipelineRasterizationDepthClipStateCreateInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PipelineRasterizationDepthClipStateCreateInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PipelineRasterizationDepthClipStateCreateInfoEXTBuilder<'a> {
        PipelineRasterizationDepthClipStateCreateInfoEXTBuilder {
            inner: PipelineRasterizationDepthClipStateCreateInfoEXT {
                s_type: StructureType::from_raw(1000102001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PipelineRasterizationDepthClipStateCreateInfoEXTBuilder<'a> {
    #[inline]
    pub fn flags(
        mut self,
        value: PipelineRasterizationDepthClipStateCreateFlagsEXT,
    ) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn depth_clip_enable(mut self, value: bool) -> Self {
        self.inner.depth_clip_enable = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PipelineRasterizationDepthClipStateCreateInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPipelineRasterizationDepthClipStateCreateInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref
for PipelineRasterizationDepthClipStateCreateInfoEXTBuilder<'a> {
    type Target = PipelineRasterizationDepthClipStateCreateInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PipelineRasterizationDepthClipStateCreateInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceMemoryBudgetPropertiesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceMemoryBudgetPropertiesEXTBuilder<'a> {
    inner: PhysicalDeviceMemoryBudgetPropertiesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceMemoryBudgetPropertiesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceMemoryBudgetPropertiesEXTBuilder<'a> {
        PhysicalDeviceMemoryBudgetPropertiesEXTBuilder {
            inner: PhysicalDeviceMemoryBudgetPropertiesEXT {
                s_type: StructureType::from_raw(1000237000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceMemoryBudgetPropertiesEXTBuilder<'a> {
    #[inline]
    pub fn heap_budget(mut self, value: [u64; MAX_MEMORY_HEAPS as usize]) -> Self {
        self.inner.heap_budget = value;
        self
    }
    #[inline]
    pub fn heap_usage(mut self, value: [u64; MAX_MEMORY_HEAPS as usize]) -> Self {
        self.inner.heap_usage = value;
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceMemoryBudgetPropertiesEXTBuilder<'a> {
    type Target = PhysicalDeviceMemoryBudgetPropertiesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceMemoryBudgetPropertiesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceMemoryPriorityFeaturesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceMemoryPriorityFeaturesEXTBuilder<'a> {
    inner: PhysicalDeviceMemoryPriorityFeaturesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceMemoryPriorityFeaturesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceMemoryPriorityFeaturesEXTBuilder<'a> {
        PhysicalDeviceMemoryPriorityFeaturesEXTBuilder {
            inner: PhysicalDeviceMemoryPriorityFeaturesEXT {
                s_type: StructureType::from_raw(1000238000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceMemoryPriorityFeaturesEXTBuilder<'a> {
    #[inline]
    pub fn memory_priority(mut self, value: bool) -> Self {
        self.inner.memory_priority = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceMemoryPriorityFeaturesEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceMemoryPriorityFeaturesEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceMemoryPriorityFeaturesEXTBuilder<'a> {
    type Target = PhysicalDeviceMemoryPriorityFeaturesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceMemoryPriorityFeaturesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`MemoryPriorityAllocateInfoEXT`] with lifetime-tied pNext safety.
pub struct MemoryPriorityAllocateInfoEXTBuilder<'a> {
    inner: MemoryPriorityAllocateInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl MemoryPriorityAllocateInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> MemoryPriorityAllocateInfoEXTBuilder<'a> {
        MemoryPriorityAllocateInfoEXTBuilder {
            inner: MemoryPriorityAllocateInfoEXT {
                s_type: StructureType::from_raw(1000238001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> MemoryPriorityAllocateInfoEXTBuilder<'a> {
    #[inline]
    pub fn priority(mut self, value: f32) -> Self {
        self.inner.priority = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`MemoryPriorityAllocateInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsMemoryPriorityAllocateInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for MemoryPriorityAllocateInfoEXTBuilder<'a> {
    type Target = MemoryPriorityAllocateInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for MemoryPriorityAllocateInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDevicePageableDeviceLocalMemoryFeaturesEXTBuilder<'a> {
    inner: PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDevicePageableDeviceLocalMemoryFeaturesEXTBuilder<
        'a,
    > {
        PhysicalDevicePageableDeviceLocalMemoryFeaturesEXTBuilder {
            inner: PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT {
                s_type: StructureType::from_raw(1000412000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDevicePageableDeviceLocalMemoryFeaturesEXTBuilder<'a> {
    #[inline]
    pub fn pageable_device_local_memory(mut self, value: bool) -> Self {
        self.inner.pageable_device_local_memory = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDevicePageableDeviceLocalMemoryFeaturesEXTBuilder<'a> {
    type Target = PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDevicePageableDeviceLocalMemoryFeaturesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceBufferDeviceAddressFeatures`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceBufferDeviceAddressFeaturesBuilder<'a> {
    inner: PhysicalDeviceBufferDeviceAddressFeatures,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceBufferDeviceAddressFeatures {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceBufferDeviceAddressFeaturesBuilder<'a> {
        PhysicalDeviceBufferDeviceAddressFeaturesBuilder {
            inner: PhysicalDeviceBufferDeviceAddressFeatures {
                s_type: StructureType::from_raw(1000257000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceBufferDeviceAddressFeaturesBuilder<'a> {
    #[inline]
    pub fn buffer_device_address(mut self, value: bool) -> Self {
        self.inner.buffer_device_address = value as u32;
        self
    }
    #[inline]
    pub fn buffer_device_address_capture_replay(mut self, value: bool) -> Self {
        self.inner.buffer_device_address_capture_replay = value as u32;
        self
    }
    #[inline]
    pub fn buffer_device_address_multi_device(mut self, value: bool) -> Self {
        self.inner.buffer_device_address_multi_device = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceBufferDeviceAddressFeatures`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceBufferDeviceAddressFeatures>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceBufferDeviceAddressFeaturesBuilder<'a> {
    type Target = PhysicalDeviceBufferDeviceAddressFeatures;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceBufferDeviceAddressFeaturesBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceBufferDeviceAddressFeaturesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceBufferDeviceAddressFeaturesEXTBuilder<'a> {
    inner: PhysicalDeviceBufferDeviceAddressFeaturesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceBufferDeviceAddressFeaturesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceBufferDeviceAddressFeaturesEXTBuilder<'a> {
        PhysicalDeviceBufferDeviceAddressFeaturesEXTBuilder {
            inner: PhysicalDeviceBufferDeviceAddressFeaturesEXT {
                s_type: StructureType::from_raw(1000244000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceBufferDeviceAddressFeaturesEXTBuilder<'a> {
    #[inline]
    pub fn buffer_device_address(mut self, value: bool) -> Self {
        self.inner.buffer_device_address = value as u32;
        self
    }
    #[inline]
    pub fn buffer_device_address_capture_replay(mut self, value: bool) -> Self {
        self.inner.buffer_device_address_capture_replay = value as u32;
        self
    }
    #[inline]
    pub fn buffer_device_address_multi_device(mut self, value: bool) -> Self {
        self.inner.buffer_device_address_multi_device = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceBufferDeviceAddressFeaturesEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceBufferDeviceAddressFeaturesEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceBufferDeviceAddressFeaturesEXTBuilder<'a> {
    type Target = PhysicalDeviceBufferDeviceAddressFeaturesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceBufferDeviceAddressFeaturesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`BufferDeviceAddressInfo`] with lifetime-tied pNext safety.
pub struct BufferDeviceAddressInfoBuilder<'a> {
    inner: BufferDeviceAddressInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl BufferDeviceAddressInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> BufferDeviceAddressInfoBuilder<'a> {
        BufferDeviceAddressInfoBuilder {
            inner: BufferDeviceAddressInfo {
                s_type: StructureType::from_raw(1000244001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> BufferDeviceAddressInfoBuilder<'a> {
    #[inline]
    pub fn buffer(mut self, value: Buffer) -> Self {
        self.inner.buffer = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`BufferDeviceAddressInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsBufferDeviceAddressInfo>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for BufferDeviceAddressInfoBuilder<'a> {
    type Target = BufferDeviceAddressInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for BufferDeviceAddressInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`BufferOpaqueCaptureAddressCreateInfo`] with lifetime-tied pNext safety.
pub struct BufferOpaqueCaptureAddressCreateInfoBuilder<'a> {
    inner: BufferOpaqueCaptureAddressCreateInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl BufferOpaqueCaptureAddressCreateInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> BufferOpaqueCaptureAddressCreateInfoBuilder<'a> {
        BufferOpaqueCaptureAddressCreateInfoBuilder {
            inner: BufferOpaqueCaptureAddressCreateInfo {
                s_type: StructureType::from_raw(1000257002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> BufferOpaqueCaptureAddressCreateInfoBuilder<'a> {
    #[inline]
    pub fn opaque_capture_address(mut self, value: u64) -> Self {
        self.inner.opaque_capture_address = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`BufferOpaqueCaptureAddressCreateInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsBufferOpaqueCaptureAddressCreateInfo>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for BufferOpaqueCaptureAddressCreateInfoBuilder<'a> {
    type Target = BufferOpaqueCaptureAddressCreateInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for BufferOpaqueCaptureAddressCreateInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`BufferDeviceAddressCreateInfoEXT`] with lifetime-tied pNext safety.
pub struct BufferDeviceAddressCreateInfoEXTBuilder<'a> {
    inner: BufferDeviceAddressCreateInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl BufferDeviceAddressCreateInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> BufferDeviceAddressCreateInfoEXTBuilder<'a> {
        BufferDeviceAddressCreateInfoEXTBuilder {
            inner: BufferDeviceAddressCreateInfoEXT {
                s_type: StructureType::from_raw(1000244002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> BufferDeviceAddressCreateInfoEXTBuilder<'a> {
    #[inline]
    pub fn device_address(mut self, value: u64) -> Self {
        self.inner.device_address = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`BufferDeviceAddressCreateInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsBufferDeviceAddressCreateInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for BufferDeviceAddressCreateInfoEXTBuilder<'a> {
    type Target = BufferDeviceAddressCreateInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for BufferDeviceAddressCreateInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceImageViewImageFormatInfoEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceImageViewImageFormatInfoEXTBuilder<'a> {
    inner: PhysicalDeviceImageViewImageFormatInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceImageViewImageFormatInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceImageViewImageFormatInfoEXTBuilder<'a> {
        PhysicalDeviceImageViewImageFormatInfoEXTBuilder {
            inner: PhysicalDeviceImageViewImageFormatInfoEXT {
                s_type: StructureType::from_raw(1000170000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceImageViewImageFormatInfoEXTBuilder<'a> {
    #[inline]
    pub fn image_view_type(mut self, value: ImageViewType) -> Self {
        self.inner.image_view_type = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceImageViewImageFormatInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceImageViewImageFormatInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceImageViewImageFormatInfoEXTBuilder<'a> {
    type Target = PhysicalDeviceImageViewImageFormatInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceImageViewImageFormatInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`FilterCubicImageViewImageFormatPropertiesEXT`] with lifetime-tied pNext safety.
pub struct FilterCubicImageViewImageFormatPropertiesEXTBuilder<'a> {
    inner: FilterCubicImageViewImageFormatPropertiesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl FilterCubicImageViewImageFormatPropertiesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> FilterCubicImageViewImageFormatPropertiesEXTBuilder<'a> {
        FilterCubicImageViewImageFormatPropertiesEXTBuilder {
            inner: FilterCubicImageViewImageFormatPropertiesEXT {
                s_type: StructureType::from_raw(1000170001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> FilterCubicImageViewImageFormatPropertiesEXTBuilder<'a> {
    #[inline]
    pub fn filter_cubic(mut self, value: bool) -> Self {
        self.inner.filter_cubic = value as u32;
        self
    }
    #[inline]
    pub fn filter_cubic_minmax(mut self, value: bool) -> Self {
        self.inner.filter_cubic_minmax = value as u32;
        self
    }
}
impl<'a> core::ops::Deref for FilterCubicImageViewImageFormatPropertiesEXTBuilder<'a> {
    type Target = FilterCubicImageViewImageFormatPropertiesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for FilterCubicImageViewImageFormatPropertiesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceImagelessFramebufferFeatures`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceImagelessFramebufferFeaturesBuilder<'a> {
    inner: PhysicalDeviceImagelessFramebufferFeatures,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceImagelessFramebufferFeatures {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceImagelessFramebufferFeaturesBuilder<'a> {
        PhysicalDeviceImagelessFramebufferFeaturesBuilder {
            inner: PhysicalDeviceImagelessFramebufferFeatures {
                s_type: StructureType::from_raw(1000108000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceImagelessFramebufferFeaturesBuilder<'a> {
    #[inline]
    pub fn imageless_framebuffer(mut self, value: bool) -> Self {
        self.inner.imageless_framebuffer = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceImagelessFramebufferFeatures`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceImagelessFramebufferFeatures>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceImagelessFramebufferFeaturesBuilder<'a> {
    type Target = PhysicalDeviceImagelessFramebufferFeatures;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceImagelessFramebufferFeaturesBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`FramebufferAttachmentsCreateInfo`] with lifetime-tied pNext safety.
pub struct FramebufferAttachmentsCreateInfoBuilder<'a> {
    inner: FramebufferAttachmentsCreateInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl FramebufferAttachmentsCreateInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> FramebufferAttachmentsCreateInfoBuilder<'a> {
        FramebufferAttachmentsCreateInfoBuilder {
            inner: FramebufferAttachmentsCreateInfo {
                s_type: StructureType::from_raw(1000108001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> FramebufferAttachmentsCreateInfoBuilder<'a> {
    #[inline]
    pub fn attachment_image_infos(
        mut self,
        slice: &'a [FramebufferAttachmentImageInfo],
    ) -> Self {
        self.inner.attachment_image_info_count = slice.len() as u32;
        self.inner.p_attachment_image_infos = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`FramebufferAttachmentsCreateInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsFramebufferAttachmentsCreateInfo>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for FramebufferAttachmentsCreateInfoBuilder<'a> {
    type Target = FramebufferAttachmentsCreateInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for FramebufferAttachmentsCreateInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`FramebufferAttachmentImageInfo`] with lifetime-tied pNext safety.
pub struct FramebufferAttachmentImageInfoBuilder<'a> {
    inner: FramebufferAttachmentImageInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl FramebufferAttachmentImageInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> FramebufferAttachmentImageInfoBuilder<'a> {
        FramebufferAttachmentImageInfoBuilder {
            inner: FramebufferAttachmentImageInfo {
                s_type: StructureType::from_raw(1000108002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> FramebufferAttachmentImageInfoBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: ImageCreateFlags) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn usage(mut self, value: ImageUsageFlags) -> Self {
        self.inner.usage = value;
        self
    }
    #[inline]
    pub fn width(mut self, value: u32) -> Self {
        self.inner.width = value;
        self
    }
    #[inline]
    pub fn height(mut self, value: u32) -> Self {
        self.inner.height = value;
        self
    }
    #[inline]
    pub fn layer_count(mut self, value: u32) -> Self {
        self.inner.layer_count = value;
        self
    }
    #[inline]
    pub fn view_formats(mut self, slice: &'a [Format]) -> Self {
        self.inner.view_format_count = slice.len() as u32;
        self.inner.p_view_formats = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`FramebufferAttachmentImageInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsFramebufferAttachmentImageInfo>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for FramebufferAttachmentImageInfoBuilder<'a> {
    type Target = FramebufferAttachmentImageInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for FramebufferAttachmentImageInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`RenderPassAttachmentBeginInfo`] with lifetime-tied pNext safety.
pub struct RenderPassAttachmentBeginInfoBuilder<'a> {
    inner: RenderPassAttachmentBeginInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl RenderPassAttachmentBeginInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> RenderPassAttachmentBeginInfoBuilder<'a> {
        RenderPassAttachmentBeginInfoBuilder {
            inner: RenderPassAttachmentBeginInfo {
                s_type: StructureType::from_raw(1000108003i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> RenderPassAttachmentBeginInfoBuilder<'a> {
    #[inline]
    pub fn attachments(mut self, slice: &'a [ImageView]) -> Self {
        self.inner.attachment_count = slice.len() as u32;
        self.inner.p_attachments = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`RenderPassAttachmentBeginInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsRenderPassAttachmentBeginInfo>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for RenderPassAttachmentBeginInfoBuilder<'a> {
    type Target = RenderPassAttachmentBeginInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for RenderPassAttachmentBeginInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceTextureCompressionASTCHDRFeatures`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceTextureCompressionASTCHDRFeaturesBuilder<'a> {
    inner: PhysicalDeviceTextureCompressionASTCHDRFeatures,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceTextureCompressionASTCHDRFeatures {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceTextureCompressionASTCHDRFeaturesBuilder<'a> {
        PhysicalDeviceTextureCompressionASTCHDRFeaturesBuilder {
            inner: PhysicalDeviceTextureCompressionASTCHDRFeatures {
                s_type: StructureType::from_raw(1000066000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceTextureCompressionASTCHDRFeaturesBuilder<'a> {
    #[inline]
    pub fn texture_compression_astc_hdr(mut self, value: bool) -> Self {
        self.inner.texture_compression_astc_hdr = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceTextureCompressionASTCHDRFeatures`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceTextureCompressionASTCHDRFeatures>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDeviceTextureCompressionASTCHDRFeaturesBuilder<'a> {
    type Target = PhysicalDeviceTextureCompressionASTCHDRFeatures;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceTextureCompressionASTCHDRFeaturesBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceCooperativeMatrixFeaturesNV`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceCooperativeMatrixFeaturesNVBuilder<'a> {
    inner: PhysicalDeviceCooperativeMatrixFeaturesNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceCooperativeMatrixFeaturesNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceCooperativeMatrixFeaturesNVBuilder<'a> {
        PhysicalDeviceCooperativeMatrixFeaturesNVBuilder {
            inner: PhysicalDeviceCooperativeMatrixFeaturesNV {
                s_type: StructureType::from_raw(1000249000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceCooperativeMatrixFeaturesNVBuilder<'a> {
    #[inline]
    pub fn cooperative_matrix(mut self, value: bool) -> Self {
        self.inner.cooperative_matrix = value as u32;
        self
    }
    #[inline]
    pub fn cooperative_matrix_robust_buffer_access(mut self, value: bool) -> Self {
        self.inner.cooperative_matrix_robust_buffer_access = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceCooperativeMatrixFeaturesNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceCooperativeMatrixFeaturesNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceCooperativeMatrixFeaturesNVBuilder<'a> {
    type Target = PhysicalDeviceCooperativeMatrixFeaturesNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceCooperativeMatrixFeaturesNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceCooperativeMatrixPropertiesNV`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceCooperativeMatrixPropertiesNVBuilder<'a> {
    inner: PhysicalDeviceCooperativeMatrixPropertiesNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceCooperativeMatrixPropertiesNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceCooperativeMatrixPropertiesNVBuilder<'a> {
        PhysicalDeviceCooperativeMatrixPropertiesNVBuilder {
            inner: PhysicalDeviceCooperativeMatrixPropertiesNV {
                s_type: StructureType::from_raw(1000249002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceCooperativeMatrixPropertiesNVBuilder<'a> {
    #[inline]
    pub fn cooperative_matrix_supported_stages(
        mut self,
        value: ShaderStageFlags,
    ) -> Self {
        self.inner.cooperative_matrix_supported_stages = value;
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceCooperativeMatrixPropertiesNVBuilder<'a> {
    type Target = PhysicalDeviceCooperativeMatrixPropertiesNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceCooperativeMatrixPropertiesNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`CooperativeMatrixPropertiesNV`] with lifetime-tied pNext safety.
pub struct CooperativeMatrixPropertiesNVBuilder<'a> {
    inner: CooperativeMatrixPropertiesNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl CooperativeMatrixPropertiesNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> CooperativeMatrixPropertiesNVBuilder<'a> {
        CooperativeMatrixPropertiesNVBuilder {
            inner: CooperativeMatrixPropertiesNV {
                s_type: StructureType::from_raw(1000249001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> CooperativeMatrixPropertiesNVBuilder<'a> {
    #[inline]
    pub fn m_size(mut self, value: u32) -> Self {
        self.inner.m_size = value;
        self
    }
    #[inline]
    pub fn n_size(mut self, value: u32) -> Self {
        self.inner.n_size = value;
        self
    }
    #[inline]
    pub fn k_size(mut self, value: u32) -> Self {
        self.inner.k_size = value;
        self
    }
    #[inline]
    pub fn a_type(mut self, value: ComponentTypeNV) -> Self {
        self.inner.a_type = value;
        self
    }
    #[inline]
    pub fn b_type(mut self, value: ComponentTypeNV) -> Self {
        self.inner.b_type = value;
        self
    }
    #[inline]
    pub fn c_type(mut self, value: ComponentTypeNV) -> Self {
        self.inner.c_type = value;
        self
    }
    #[inline]
    pub fn d_type(mut self, value: ComponentTypeNV) -> Self {
        self.inner.d_type = value;
        self
    }
    #[inline]
    pub fn scope(mut self, value: ScopeNV) -> Self {
        self.inner.scope = value;
        self
    }
}
impl<'a> core::ops::Deref for CooperativeMatrixPropertiesNVBuilder<'a> {
    type Target = CooperativeMatrixPropertiesNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for CooperativeMatrixPropertiesNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceYcbcrImageArraysFeaturesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceYcbcrImageArraysFeaturesEXTBuilder<'a> {
    inner: PhysicalDeviceYcbcrImageArraysFeaturesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceYcbcrImageArraysFeaturesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceYcbcrImageArraysFeaturesEXTBuilder<'a> {
        PhysicalDeviceYcbcrImageArraysFeaturesEXTBuilder {
            inner: PhysicalDeviceYcbcrImageArraysFeaturesEXT {
                s_type: StructureType::from_raw(1000252000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceYcbcrImageArraysFeaturesEXTBuilder<'a> {
    #[inline]
    pub fn ycbcr_image_arrays(mut self, value: bool) -> Self {
        self.inner.ycbcr_image_arrays = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceYcbcrImageArraysFeaturesEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceYcbcrImageArraysFeaturesEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceYcbcrImageArraysFeaturesEXTBuilder<'a> {
    type Target = PhysicalDeviceYcbcrImageArraysFeaturesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceYcbcrImageArraysFeaturesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ImageViewHandleInfoNVX`] with lifetime-tied pNext safety.
pub struct ImageViewHandleInfoNVXBuilder<'a> {
    inner: ImageViewHandleInfoNVX,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ImageViewHandleInfoNVX {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ImageViewHandleInfoNVXBuilder<'a> {
        ImageViewHandleInfoNVXBuilder {
            inner: ImageViewHandleInfoNVX {
                s_type: StructureType::from_raw(1000030000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ImageViewHandleInfoNVXBuilder<'a> {
    #[inline]
    pub fn image_view(mut self, value: ImageView) -> Self {
        self.inner.image_view = value;
        self
    }
    #[inline]
    pub fn descriptor_type(mut self, value: DescriptorType) -> Self {
        self.inner.descriptor_type = value;
        self
    }
    #[inline]
    pub fn sampler(mut self, value: Sampler) -> Self {
        self.inner.sampler = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`ImageViewHandleInfoNVX`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsImageViewHandleInfoNVX>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for ImageViewHandleInfoNVXBuilder<'a> {
    type Target = ImageViewHandleInfoNVX;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ImageViewHandleInfoNVXBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ImageViewAddressPropertiesNVX`] with lifetime-tied pNext safety.
pub struct ImageViewAddressPropertiesNVXBuilder<'a> {
    inner: ImageViewAddressPropertiesNVX,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ImageViewAddressPropertiesNVX {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ImageViewAddressPropertiesNVXBuilder<'a> {
        ImageViewAddressPropertiesNVXBuilder {
            inner: ImageViewAddressPropertiesNVX {
                s_type: StructureType::from_raw(1000030001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ImageViewAddressPropertiesNVXBuilder<'a> {
    #[inline]
    pub fn device_address(mut self, value: u64) -> Self {
        self.inner.device_address = value;
        self
    }
    #[inline]
    pub fn size(mut self, value: u64) -> Self {
        self.inner.size = value;
        self
    }
}
impl<'a> core::ops::Deref for ImageViewAddressPropertiesNVXBuilder<'a> {
    type Target = ImageViewAddressPropertiesNVX;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ImageViewAddressPropertiesNVXBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PresentFrameTokenGGP`] with lifetime-tied pNext safety.
pub struct PresentFrameTokenGGPBuilder<'a> {
    inner: PresentFrameTokenGGP,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PresentFrameTokenGGP {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PresentFrameTokenGGPBuilder<'a> {
        PresentFrameTokenGGPBuilder {
            inner: PresentFrameTokenGGP {
                s_type: StructureType::from_raw(1000191000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PresentFrameTokenGGPBuilder<'a> {
    #[inline]
    pub fn frame_token(mut self, value: u32) -> Self {
        self.inner.frame_token = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PresentFrameTokenGGP`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPresentFrameTokenGGP>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for PresentFrameTokenGGPBuilder<'a> {
    type Target = PresentFrameTokenGGP;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PresentFrameTokenGGPBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PipelineCreationFeedback`].
pub struct PipelineCreationFeedbackBuilder {
    inner: PipelineCreationFeedback,
}
impl PipelineCreationFeedback {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> PipelineCreationFeedbackBuilder {
        PipelineCreationFeedbackBuilder {
            inner: PipelineCreationFeedback {
                ..Default::default()
            },
        }
    }
}
impl PipelineCreationFeedbackBuilder {
    #[inline]
    pub fn flags(mut self, value: PipelineCreationFeedbackFlags) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn duration(mut self, value: u64) -> Self {
        self.inner.duration = value;
        self
    }
}
impl core::ops::Deref for PipelineCreationFeedbackBuilder {
    type Target = PipelineCreationFeedback;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for PipelineCreationFeedbackBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PipelineCreationFeedbackCreateInfo`] with lifetime-tied pNext safety.
pub struct PipelineCreationFeedbackCreateInfoBuilder<'a> {
    inner: PipelineCreationFeedbackCreateInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PipelineCreationFeedbackCreateInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PipelineCreationFeedbackCreateInfoBuilder<'a> {
        PipelineCreationFeedbackCreateInfoBuilder {
            inner: PipelineCreationFeedbackCreateInfo {
                s_type: StructureType::from_raw(1000192000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PipelineCreationFeedbackCreateInfoBuilder<'a> {
    #[inline]
    pub fn pipeline_creation_feedback(
        mut self,
        value: *mut PipelineCreationFeedback,
    ) -> Self {
        self.inner.p_pipeline_creation_feedback = value;
        self
    }
    #[inline]
    pub fn pipeline_stage_creation_feedbacks(
        mut self,
        slice: &'a mut [PipelineCreationFeedback],
    ) -> Self {
        self.inner.pipeline_stage_creation_feedback_count = slice.len() as u32;
        self.inner.p_pipeline_stage_creation_feedbacks = slice.as_mut_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`PipelineCreationFeedbackCreateInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPipelineCreationFeedbackCreateInfo>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for PipelineCreationFeedbackCreateInfoBuilder<'a> {
    type Target = PipelineCreationFeedbackCreateInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PipelineCreationFeedbackCreateInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`SurfaceFullScreenExclusiveInfoEXT`] with lifetime-tied pNext safety.
pub struct SurfaceFullScreenExclusiveInfoEXTBuilder<'a> {
    inner: SurfaceFullScreenExclusiveInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl SurfaceFullScreenExclusiveInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> SurfaceFullScreenExclusiveInfoEXTBuilder<'a> {
        SurfaceFullScreenExclusiveInfoEXTBuilder {
            inner: SurfaceFullScreenExclusiveInfoEXT {
                s_type: StructureType::from_raw(1000255000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> SurfaceFullScreenExclusiveInfoEXTBuilder<'a> {
    #[inline]
    pub fn full_screen_exclusive(mut self, value: FullScreenExclusiveEXT) -> Self {
        self.inner.full_screen_exclusive = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`SurfaceFullScreenExclusiveInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsSurfaceFullScreenExclusiveInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for SurfaceFullScreenExclusiveInfoEXTBuilder<'a> {
    type Target = SurfaceFullScreenExclusiveInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for SurfaceFullScreenExclusiveInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`SurfaceFullScreenExclusiveWin32InfoEXT`] with lifetime-tied pNext safety.
pub struct SurfaceFullScreenExclusiveWin32InfoEXTBuilder<'a> {
    inner: SurfaceFullScreenExclusiveWin32InfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl SurfaceFullScreenExclusiveWin32InfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> SurfaceFullScreenExclusiveWin32InfoEXTBuilder<'a> {
        SurfaceFullScreenExclusiveWin32InfoEXTBuilder {
            inner: SurfaceFullScreenExclusiveWin32InfoEXT {
                s_type: StructureType::from_raw(1000255001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> SurfaceFullScreenExclusiveWin32InfoEXTBuilder<'a> {
    #[inline]
    pub fn hmonitor(mut self, value: isize) -> Self {
        self.inner.hmonitor = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`SurfaceFullScreenExclusiveWin32InfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsSurfaceFullScreenExclusiveWin32InfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for SurfaceFullScreenExclusiveWin32InfoEXTBuilder<'a> {
    type Target = SurfaceFullScreenExclusiveWin32InfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for SurfaceFullScreenExclusiveWin32InfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`SurfaceCapabilitiesFullScreenExclusiveEXT`] with lifetime-tied pNext safety.
pub struct SurfaceCapabilitiesFullScreenExclusiveEXTBuilder<'a> {
    inner: SurfaceCapabilitiesFullScreenExclusiveEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl SurfaceCapabilitiesFullScreenExclusiveEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> SurfaceCapabilitiesFullScreenExclusiveEXTBuilder<'a> {
        SurfaceCapabilitiesFullScreenExclusiveEXTBuilder {
            inner: SurfaceCapabilitiesFullScreenExclusiveEXT {
                s_type: StructureType::from_raw(1000255002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> SurfaceCapabilitiesFullScreenExclusiveEXTBuilder<'a> {
    #[inline]
    pub fn full_screen_exclusive_supported(mut self, value: bool) -> Self {
        self.inner.full_screen_exclusive_supported = value as u32;
        self
    }
}
impl<'a> core::ops::Deref for SurfaceCapabilitiesFullScreenExclusiveEXTBuilder<'a> {
    type Target = SurfaceCapabilitiesFullScreenExclusiveEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for SurfaceCapabilitiesFullScreenExclusiveEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDevicePresentBarrierFeaturesNV`] with lifetime-tied pNext safety.
pub struct PhysicalDevicePresentBarrierFeaturesNVBuilder<'a> {
    inner: PhysicalDevicePresentBarrierFeaturesNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDevicePresentBarrierFeaturesNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDevicePresentBarrierFeaturesNVBuilder<'a> {
        PhysicalDevicePresentBarrierFeaturesNVBuilder {
            inner: PhysicalDevicePresentBarrierFeaturesNV {
                s_type: StructureType::from_raw(1000292000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDevicePresentBarrierFeaturesNVBuilder<'a> {
    #[inline]
    pub fn present_barrier(mut self, value: bool) -> Self {
        self.inner.present_barrier = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDevicePresentBarrierFeaturesNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDevicePresentBarrierFeaturesNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDevicePresentBarrierFeaturesNVBuilder<'a> {
    type Target = PhysicalDevicePresentBarrierFeaturesNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDevicePresentBarrierFeaturesNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`SurfaceCapabilitiesPresentBarrierNV`] with lifetime-tied pNext safety.
pub struct SurfaceCapabilitiesPresentBarrierNVBuilder<'a> {
    inner: SurfaceCapabilitiesPresentBarrierNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl SurfaceCapabilitiesPresentBarrierNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> SurfaceCapabilitiesPresentBarrierNVBuilder<'a> {
        SurfaceCapabilitiesPresentBarrierNVBuilder {
            inner: SurfaceCapabilitiesPresentBarrierNV {
                s_type: StructureType::from_raw(1000292001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> SurfaceCapabilitiesPresentBarrierNVBuilder<'a> {
    #[inline]
    pub fn present_barrier_supported(mut self, value: bool) -> Self {
        self.inner.present_barrier_supported = value as u32;
        self
    }
}
impl<'a> core::ops::Deref for SurfaceCapabilitiesPresentBarrierNVBuilder<'a> {
    type Target = SurfaceCapabilitiesPresentBarrierNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for SurfaceCapabilitiesPresentBarrierNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`SwapchainPresentBarrierCreateInfoNV`] with lifetime-tied pNext safety.
pub struct SwapchainPresentBarrierCreateInfoNVBuilder<'a> {
    inner: SwapchainPresentBarrierCreateInfoNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl SwapchainPresentBarrierCreateInfoNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> SwapchainPresentBarrierCreateInfoNVBuilder<'a> {
        SwapchainPresentBarrierCreateInfoNVBuilder {
            inner: SwapchainPresentBarrierCreateInfoNV {
                s_type: StructureType::from_raw(1000292002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> SwapchainPresentBarrierCreateInfoNVBuilder<'a> {
    #[inline]
    pub fn present_barrier_enable(mut self, value: bool) -> Self {
        self.inner.present_barrier_enable = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`SwapchainPresentBarrierCreateInfoNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsSwapchainPresentBarrierCreateInfoNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for SwapchainPresentBarrierCreateInfoNVBuilder<'a> {
    type Target = SwapchainPresentBarrierCreateInfoNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for SwapchainPresentBarrierCreateInfoNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDevicePerformanceQueryFeaturesKHR`] with lifetime-tied pNext safety.
pub struct PhysicalDevicePerformanceQueryFeaturesKHRBuilder<'a> {
    inner: PhysicalDevicePerformanceQueryFeaturesKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDevicePerformanceQueryFeaturesKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDevicePerformanceQueryFeaturesKHRBuilder<'a> {
        PhysicalDevicePerformanceQueryFeaturesKHRBuilder {
            inner: PhysicalDevicePerformanceQueryFeaturesKHR {
                s_type: StructureType::from_raw(1000116000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDevicePerformanceQueryFeaturesKHRBuilder<'a> {
    #[inline]
    pub fn performance_counter_query_pools(mut self, value: bool) -> Self {
        self.inner.performance_counter_query_pools = value as u32;
        self
    }
    #[inline]
    pub fn performance_counter_multiple_query_pools(mut self, value: bool) -> Self {
        self.inner.performance_counter_multiple_query_pools = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDevicePerformanceQueryFeaturesKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDevicePerformanceQueryFeaturesKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDevicePerformanceQueryFeaturesKHRBuilder<'a> {
    type Target = PhysicalDevicePerformanceQueryFeaturesKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDevicePerformanceQueryFeaturesKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDevicePerformanceQueryPropertiesKHR`] with lifetime-tied pNext safety.
pub struct PhysicalDevicePerformanceQueryPropertiesKHRBuilder<'a> {
    inner: PhysicalDevicePerformanceQueryPropertiesKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDevicePerformanceQueryPropertiesKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDevicePerformanceQueryPropertiesKHRBuilder<'a> {
        PhysicalDevicePerformanceQueryPropertiesKHRBuilder {
            inner: PhysicalDevicePerformanceQueryPropertiesKHR {
                s_type: StructureType::from_raw(1000116001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDevicePerformanceQueryPropertiesKHRBuilder<'a> {
    #[inline]
    pub fn allow_command_buffer_query_copies(mut self, value: bool) -> Self {
        self.inner.allow_command_buffer_query_copies = value as u32;
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDevicePerformanceQueryPropertiesKHRBuilder<'a> {
    type Target = PhysicalDevicePerformanceQueryPropertiesKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDevicePerformanceQueryPropertiesKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PerformanceCounterKHR`] with lifetime-tied pNext safety.
pub struct PerformanceCounterKHRBuilder<'a> {
    inner: PerformanceCounterKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PerformanceCounterKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PerformanceCounterKHRBuilder<'a> {
        PerformanceCounterKHRBuilder {
            inner: PerformanceCounterKHR {
                s_type: StructureType::from_raw(1000116005i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PerformanceCounterKHRBuilder<'a> {
    #[inline]
    pub fn unit(mut self, value: PerformanceCounterUnitKHR) -> Self {
        self.inner.unit = value;
        self
    }
    #[inline]
    pub fn scope(mut self, value: PerformanceCounterScopeKHR) -> Self {
        self.inner.scope = value;
        self
    }
    #[inline]
    pub fn storage(mut self, value: PerformanceCounterStorageKHR) -> Self {
        self.inner.storage = value;
        self
    }
    #[inline]
    pub fn uuid(mut self, value: [u8; UUID_SIZE as usize]) -> Self {
        self.inner.uuid = value;
        self
    }
}
impl<'a> core::ops::Deref for PerformanceCounterKHRBuilder<'a> {
    type Target = PerformanceCounterKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PerformanceCounterKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PerformanceCounterDescriptionKHR`] with lifetime-tied pNext safety.
pub struct PerformanceCounterDescriptionKHRBuilder<'a> {
    inner: PerformanceCounterDescriptionKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PerformanceCounterDescriptionKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PerformanceCounterDescriptionKHRBuilder<'a> {
        PerformanceCounterDescriptionKHRBuilder {
            inner: PerformanceCounterDescriptionKHR {
                s_type: StructureType::from_raw(1000116006i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PerformanceCounterDescriptionKHRBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: PerformanceCounterDescriptionFlagsKHR) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn name(
        mut self,
        value: crate::StringArray<{ MAX_DESCRIPTION_SIZE as usize }>,
    ) -> Self {
        self.inner.name = value;
        self
    }
    #[inline]
    pub fn category(
        mut self,
        value: crate::StringArray<{ MAX_DESCRIPTION_SIZE as usize }>,
    ) -> Self {
        self.inner.category = value;
        self
    }
    #[inline]
    pub fn description(
        mut self,
        value: crate::StringArray<{ MAX_DESCRIPTION_SIZE as usize }>,
    ) -> Self {
        self.inner.description = value;
        self
    }
}
impl<'a> core::ops::Deref for PerformanceCounterDescriptionKHRBuilder<'a> {
    type Target = PerformanceCounterDescriptionKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PerformanceCounterDescriptionKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`QueryPoolPerformanceCreateInfoKHR`] with lifetime-tied pNext safety.
pub struct QueryPoolPerformanceCreateInfoKHRBuilder<'a> {
    inner: QueryPoolPerformanceCreateInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl QueryPoolPerformanceCreateInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> QueryPoolPerformanceCreateInfoKHRBuilder<'a> {
        QueryPoolPerformanceCreateInfoKHRBuilder {
            inner: QueryPoolPerformanceCreateInfoKHR {
                s_type: StructureType::from_raw(1000116002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> QueryPoolPerformanceCreateInfoKHRBuilder<'a> {
    #[inline]
    pub fn queue_family_index(mut self, value: u32) -> Self {
        self.inner.queue_family_index = value;
        self
    }
    #[inline]
    pub fn counter_indices(mut self, slice: &'a [u32]) -> Self {
        self.inner.counter_index_count = slice.len() as u32;
        self.inner.p_counter_indices = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`QueryPoolPerformanceCreateInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsQueryPoolPerformanceCreateInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for QueryPoolPerformanceCreateInfoKHRBuilder<'a> {
    type Target = QueryPoolPerformanceCreateInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for QueryPoolPerformanceCreateInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`AcquireProfilingLockInfoKHR`] with lifetime-tied pNext safety.
pub struct AcquireProfilingLockInfoKHRBuilder<'a> {
    inner: AcquireProfilingLockInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl AcquireProfilingLockInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> AcquireProfilingLockInfoKHRBuilder<'a> {
        AcquireProfilingLockInfoKHRBuilder {
            inner: AcquireProfilingLockInfoKHR {
                s_type: StructureType::from_raw(1000116004i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> AcquireProfilingLockInfoKHRBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: AcquireProfilingLockFlagsKHR) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn timeout(mut self, value: u64) -> Self {
        self.inner.timeout = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`AcquireProfilingLockInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsAcquireProfilingLockInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for AcquireProfilingLockInfoKHRBuilder<'a> {
    type Target = AcquireProfilingLockInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for AcquireProfilingLockInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PerformanceQuerySubmitInfoKHR`] with lifetime-tied pNext safety.
pub struct PerformanceQuerySubmitInfoKHRBuilder<'a> {
    inner: PerformanceQuerySubmitInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PerformanceQuerySubmitInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PerformanceQuerySubmitInfoKHRBuilder<'a> {
        PerformanceQuerySubmitInfoKHRBuilder {
            inner: PerformanceQuerySubmitInfoKHR {
                s_type: StructureType::from_raw(1000116003i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PerformanceQuerySubmitInfoKHRBuilder<'a> {
    #[inline]
    pub fn counter_pass_index(mut self, value: u32) -> Self {
        self.inner.counter_pass_index = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PerformanceQuerySubmitInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPerformanceQuerySubmitInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for PerformanceQuerySubmitInfoKHRBuilder<'a> {
    type Target = PerformanceQuerySubmitInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PerformanceQuerySubmitInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PerformanceQueryReservationInfoKHR`] with lifetime-tied pNext safety.
pub struct PerformanceQueryReservationInfoKHRBuilder<'a> {
    inner: PerformanceQueryReservationInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PerformanceQueryReservationInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PerformanceQueryReservationInfoKHRBuilder<'a> {
        PerformanceQueryReservationInfoKHRBuilder {
            inner: PerformanceQueryReservationInfoKHR {
                s_type: StructureType::from_raw(1000116007i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PerformanceQueryReservationInfoKHRBuilder<'a> {
    #[inline]
    pub fn max_performance_queries_per_pool(mut self, value: u32) -> Self {
        self.inner.max_performance_queries_per_pool = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PerformanceQueryReservationInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPerformanceQueryReservationInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for PerformanceQueryReservationInfoKHRBuilder<'a> {
    type Target = PerformanceQueryReservationInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PerformanceQueryReservationInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`HeadlessSurfaceCreateInfoEXT`] with lifetime-tied pNext safety.
pub struct HeadlessSurfaceCreateInfoEXTBuilder<'a> {
    inner: HeadlessSurfaceCreateInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl HeadlessSurfaceCreateInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> HeadlessSurfaceCreateInfoEXTBuilder<'a> {
        HeadlessSurfaceCreateInfoEXTBuilder {
            inner: HeadlessSurfaceCreateInfoEXT {
                s_type: StructureType::from_raw(1000256000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> HeadlessSurfaceCreateInfoEXTBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: HeadlessSurfaceCreateFlagsEXT) -> Self {
        self.inner.flags = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`HeadlessSurfaceCreateInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsHeadlessSurfaceCreateInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for HeadlessSurfaceCreateInfoEXTBuilder<'a> {
    type Target = HeadlessSurfaceCreateInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for HeadlessSurfaceCreateInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceCoverageReductionModeFeaturesNV`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceCoverageReductionModeFeaturesNVBuilder<'a> {
    inner: PhysicalDeviceCoverageReductionModeFeaturesNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceCoverageReductionModeFeaturesNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceCoverageReductionModeFeaturesNVBuilder<'a> {
        PhysicalDeviceCoverageReductionModeFeaturesNVBuilder {
            inner: PhysicalDeviceCoverageReductionModeFeaturesNV {
                s_type: StructureType::from_raw(1000250000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceCoverageReductionModeFeaturesNVBuilder<'a> {
    #[inline]
    pub fn coverage_reduction_mode(mut self, value: bool) -> Self {
        self.inner.coverage_reduction_mode = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceCoverageReductionModeFeaturesNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceCoverageReductionModeFeaturesNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceCoverageReductionModeFeaturesNVBuilder<'a> {
    type Target = PhysicalDeviceCoverageReductionModeFeaturesNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceCoverageReductionModeFeaturesNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PipelineCoverageReductionStateCreateInfoNV`] with lifetime-tied pNext safety.
pub struct PipelineCoverageReductionStateCreateInfoNVBuilder<'a> {
    inner: PipelineCoverageReductionStateCreateInfoNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PipelineCoverageReductionStateCreateInfoNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PipelineCoverageReductionStateCreateInfoNVBuilder<'a> {
        PipelineCoverageReductionStateCreateInfoNVBuilder {
            inner: PipelineCoverageReductionStateCreateInfoNV {
                s_type: StructureType::from_raw(1000250001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PipelineCoverageReductionStateCreateInfoNVBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: PipelineCoverageReductionStateCreateFlagsNV) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn coverage_reduction_mode(mut self, value: CoverageReductionModeNV) -> Self {
        self.inner.coverage_reduction_mode = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PipelineCoverageReductionStateCreateInfoNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPipelineCoverageReductionStateCreateInfoNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for PipelineCoverageReductionStateCreateInfoNVBuilder<'a> {
    type Target = PipelineCoverageReductionStateCreateInfoNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PipelineCoverageReductionStateCreateInfoNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`FramebufferMixedSamplesCombinationNV`] with lifetime-tied pNext safety.
pub struct FramebufferMixedSamplesCombinationNVBuilder<'a> {
    inner: FramebufferMixedSamplesCombinationNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl FramebufferMixedSamplesCombinationNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> FramebufferMixedSamplesCombinationNVBuilder<'a> {
        FramebufferMixedSamplesCombinationNVBuilder {
            inner: FramebufferMixedSamplesCombinationNV {
                s_type: StructureType::from_raw(1000250002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> FramebufferMixedSamplesCombinationNVBuilder<'a> {
    #[inline]
    pub fn coverage_reduction_mode(mut self, value: CoverageReductionModeNV) -> Self {
        self.inner.coverage_reduction_mode = value;
        self
    }
    #[inline]
    pub fn rasterization_samples(mut self, value: SampleCountFlagBits) -> Self {
        self.inner.rasterization_samples = value;
        self
    }
    #[inline]
    pub fn depth_stencil_samples(mut self, value: SampleCountFlags) -> Self {
        self.inner.depth_stencil_samples = value;
        self
    }
    #[inline]
    pub fn color_samples(mut self, value: SampleCountFlags) -> Self {
        self.inner.color_samples = value;
        self
    }
}
impl<'a> core::ops::Deref for FramebufferMixedSamplesCombinationNVBuilder<'a> {
    type Target = FramebufferMixedSamplesCombinationNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for FramebufferMixedSamplesCombinationNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceShaderIntegerFunctions2FeaturesINTELBuilder<'a> {
    inner: PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceShaderIntegerFunctions2FeaturesINTELBuilder<
        'a,
    > {
        PhysicalDeviceShaderIntegerFunctions2FeaturesINTELBuilder {
            inner: PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL {
                s_type: StructureType::from_raw(1000209000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceShaderIntegerFunctions2FeaturesINTELBuilder<'a> {
    #[inline]
    pub fn shader_integer_functions2(mut self, value: bool) -> Self {
        self.inner.shader_integer_functions2 = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDeviceShaderIntegerFunctions2FeaturesINTELBuilder<'a> {
    type Target = PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceShaderIntegerFunctions2FeaturesINTELBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PerformanceValueINTEL`].
pub struct PerformanceValueINTELBuilder {
    inner: PerformanceValueINTEL,
}
impl PerformanceValueINTEL {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> PerformanceValueINTELBuilder {
        PerformanceValueINTELBuilder {
            inner: PerformanceValueINTEL {
                ..Default::default()
            },
        }
    }
}
impl PerformanceValueINTELBuilder {
    #[inline]
    pub fn r#type(mut self, value: PerformanceValueTypeINTEL) -> Self {
        self.inner.r#type = value;
        self
    }
    #[inline]
    pub fn data(mut self, value: PerformanceValueDataINTEL) -> Self {
        self.inner.data = value;
        self
    }
}
impl core::ops::Deref for PerformanceValueINTELBuilder {
    type Target = PerformanceValueINTEL;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for PerformanceValueINTELBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`InitializePerformanceApiInfoINTEL`] with lifetime-tied pNext safety.
pub struct InitializePerformanceApiInfoINTELBuilder<'a> {
    inner: InitializePerformanceApiInfoINTEL,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl InitializePerformanceApiInfoINTEL {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> InitializePerformanceApiInfoINTELBuilder<'a> {
        InitializePerformanceApiInfoINTELBuilder {
            inner: InitializePerformanceApiInfoINTEL {
                s_type: StructureType::from_raw(1000210001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> InitializePerformanceApiInfoINTELBuilder<'a> {
    #[inline]
    pub fn user_data(mut self, value: *mut core::ffi::c_void) -> Self {
        self.inner.p_user_data = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`InitializePerformanceApiInfoINTEL`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsInitializePerformanceApiInfoINTEL>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for InitializePerformanceApiInfoINTELBuilder<'a> {
    type Target = InitializePerformanceApiInfoINTEL;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for InitializePerformanceApiInfoINTELBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`QueryPoolPerformanceQueryCreateInfoINTEL`] with lifetime-tied pNext safety.
pub struct QueryPoolPerformanceQueryCreateInfoINTELBuilder<'a> {
    inner: QueryPoolPerformanceQueryCreateInfoINTEL,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl QueryPoolPerformanceQueryCreateInfoINTEL {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> QueryPoolPerformanceQueryCreateInfoINTELBuilder<'a> {
        QueryPoolPerformanceQueryCreateInfoINTELBuilder {
            inner: QueryPoolPerformanceQueryCreateInfoINTEL {
                s_type: StructureType::from_raw(1000210000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> QueryPoolPerformanceQueryCreateInfoINTELBuilder<'a> {
    #[inline]
    pub fn performance_counters_sampling(
        mut self,
        value: QueryPoolSamplingModeINTEL,
    ) -> Self {
        self.inner.performance_counters_sampling = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`QueryPoolPerformanceQueryCreateInfoINTEL`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsQueryPoolPerformanceQueryCreateInfoINTEL>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for QueryPoolPerformanceQueryCreateInfoINTELBuilder<'a> {
    type Target = QueryPoolPerformanceQueryCreateInfoINTEL;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for QueryPoolPerformanceQueryCreateInfoINTELBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PerformanceMarkerInfoINTEL`] with lifetime-tied pNext safety.
pub struct PerformanceMarkerInfoINTELBuilder<'a> {
    inner: PerformanceMarkerInfoINTEL,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PerformanceMarkerInfoINTEL {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PerformanceMarkerInfoINTELBuilder<'a> {
        PerformanceMarkerInfoINTELBuilder {
            inner: PerformanceMarkerInfoINTEL {
                s_type: StructureType::from_raw(1000210002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PerformanceMarkerInfoINTELBuilder<'a> {
    #[inline]
    pub fn marker(mut self, value: u64) -> Self {
        self.inner.marker = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PerformanceMarkerInfoINTEL`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPerformanceMarkerInfoINTEL>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for PerformanceMarkerInfoINTELBuilder<'a> {
    type Target = PerformanceMarkerInfoINTEL;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PerformanceMarkerInfoINTELBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PerformanceStreamMarkerInfoINTEL`] with lifetime-tied pNext safety.
pub struct PerformanceStreamMarkerInfoINTELBuilder<'a> {
    inner: PerformanceStreamMarkerInfoINTEL,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PerformanceStreamMarkerInfoINTEL {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PerformanceStreamMarkerInfoINTELBuilder<'a> {
        PerformanceStreamMarkerInfoINTELBuilder {
            inner: PerformanceStreamMarkerInfoINTEL {
                s_type: StructureType::from_raw(1000210003i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PerformanceStreamMarkerInfoINTELBuilder<'a> {
    #[inline]
    pub fn marker(mut self, value: u32) -> Self {
        self.inner.marker = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PerformanceStreamMarkerInfoINTEL`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPerformanceStreamMarkerInfoINTEL>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for PerformanceStreamMarkerInfoINTELBuilder<'a> {
    type Target = PerformanceStreamMarkerInfoINTEL;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PerformanceStreamMarkerInfoINTELBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PerformanceOverrideInfoINTEL`] with lifetime-tied pNext safety.
pub struct PerformanceOverrideInfoINTELBuilder<'a> {
    inner: PerformanceOverrideInfoINTEL,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PerformanceOverrideInfoINTEL {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PerformanceOverrideInfoINTELBuilder<'a> {
        PerformanceOverrideInfoINTELBuilder {
            inner: PerformanceOverrideInfoINTEL {
                s_type: StructureType::from_raw(1000210004i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PerformanceOverrideInfoINTELBuilder<'a> {
    #[inline]
    pub fn r#type(mut self, value: PerformanceOverrideTypeINTEL) -> Self {
        self.inner.r#type = value;
        self
    }
    #[inline]
    pub fn enable(mut self, value: bool) -> Self {
        self.inner.enable = value as u32;
        self
    }
    #[inline]
    pub fn parameter(mut self, value: u64) -> Self {
        self.inner.parameter = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PerformanceOverrideInfoINTEL`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPerformanceOverrideInfoINTEL>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for PerformanceOverrideInfoINTELBuilder<'a> {
    type Target = PerformanceOverrideInfoINTEL;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PerformanceOverrideInfoINTELBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PerformanceConfigurationAcquireInfoINTEL`] with lifetime-tied pNext safety.
pub struct PerformanceConfigurationAcquireInfoINTELBuilder<'a> {
    inner: PerformanceConfigurationAcquireInfoINTEL,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PerformanceConfigurationAcquireInfoINTEL {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PerformanceConfigurationAcquireInfoINTELBuilder<'a> {
        PerformanceConfigurationAcquireInfoINTELBuilder {
            inner: PerformanceConfigurationAcquireInfoINTEL {
                s_type: StructureType::from_raw(1000210005i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PerformanceConfigurationAcquireInfoINTELBuilder<'a> {
    #[inline]
    pub fn r#type(mut self, value: PerformanceConfigurationTypeINTEL) -> Self {
        self.inner.r#type = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PerformanceConfigurationAcquireInfoINTEL`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPerformanceConfigurationAcquireInfoINTEL>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for PerformanceConfigurationAcquireInfoINTELBuilder<'a> {
    type Target = PerformanceConfigurationAcquireInfoINTEL;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PerformanceConfigurationAcquireInfoINTELBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceShaderClockFeaturesKHR`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceShaderClockFeaturesKHRBuilder<'a> {
    inner: PhysicalDeviceShaderClockFeaturesKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceShaderClockFeaturesKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceShaderClockFeaturesKHRBuilder<'a> {
        PhysicalDeviceShaderClockFeaturesKHRBuilder {
            inner: PhysicalDeviceShaderClockFeaturesKHR {
                s_type: StructureType::from_raw(1000181000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceShaderClockFeaturesKHRBuilder<'a> {
    #[inline]
    pub fn shader_subgroup_clock(mut self, value: bool) -> Self {
        self.inner.shader_subgroup_clock = value as u32;
        self
    }
    #[inline]
    pub fn shader_device_clock(mut self, value: bool) -> Self {
        self.inner.shader_device_clock = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceShaderClockFeaturesKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceShaderClockFeaturesKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceShaderClockFeaturesKHRBuilder<'a> {
    type Target = PhysicalDeviceShaderClockFeaturesKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceShaderClockFeaturesKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceIndexTypeUint8Features`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceIndexTypeUint8FeaturesBuilder<'a> {
    inner: PhysicalDeviceIndexTypeUint8Features,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceIndexTypeUint8Features {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceIndexTypeUint8FeaturesBuilder<'a> {
        PhysicalDeviceIndexTypeUint8FeaturesBuilder {
            inner: PhysicalDeviceIndexTypeUint8Features {
                s_type: StructureType::from_raw(1000265000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceIndexTypeUint8FeaturesBuilder<'a> {
    #[inline]
    pub fn index_type_uint8(mut self, value: bool) -> Self {
        self.inner.index_type_uint8 = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceIndexTypeUint8Features`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceIndexTypeUint8Features>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceIndexTypeUint8FeaturesBuilder<'a> {
    type Target = PhysicalDeviceIndexTypeUint8Features;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceIndexTypeUint8FeaturesBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceShaderSMBuiltinsPropertiesNV`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceShaderSMBuiltinsPropertiesNVBuilder<'a> {
    inner: PhysicalDeviceShaderSMBuiltinsPropertiesNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceShaderSMBuiltinsPropertiesNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceShaderSMBuiltinsPropertiesNVBuilder<'a> {
        PhysicalDeviceShaderSMBuiltinsPropertiesNVBuilder {
            inner: PhysicalDeviceShaderSMBuiltinsPropertiesNV {
                s_type: StructureType::from_raw(1000154001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceShaderSMBuiltinsPropertiesNVBuilder<'a> {
    #[inline]
    pub fn shader_sm_count(mut self, value: u32) -> Self {
        self.inner.shader_sm_count = value;
        self
    }
    #[inline]
    pub fn shader_warps_per_sm(mut self, value: u32) -> Self {
        self.inner.shader_warps_per_sm = value;
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceShaderSMBuiltinsPropertiesNVBuilder<'a> {
    type Target = PhysicalDeviceShaderSMBuiltinsPropertiesNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceShaderSMBuiltinsPropertiesNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceShaderSMBuiltinsFeaturesNV`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceShaderSMBuiltinsFeaturesNVBuilder<'a> {
    inner: PhysicalDeviceShaderSMBuiltinsFeaturesNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceShaderSMBuiltinsFeaturesNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceShaderSMBuiltinsFeaturesNVBuilder<'a> {
        PhysicalDeviceShaderSMBuiltinsFeaturesNVBuilder {
            inner: PhysicalDeviceShaderSMBuiltinsFeaturesNV {
                s_type: StructureType::from_raw(1000154000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceShaderSMBuiltinsFeaturesNVBuilder<'a> {
    #[inline]
    pub fn shader_sm_builtins(mut self, value: bool) -> Self {
        self.inner.shader_sm_builtins = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceShaderSMBuiltinsFeaturesNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceShaderSMBuiltinsFeaturesNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceShaderSMBuiltinsFeaturesNVBuilder<'a> {
    type Target = PhysicalDeviceShaderSMBuiltinsFeaturesNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceShaderSMBuiltinsFeaturesNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceFragmentShaderInterlockFeaturesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceFragmentShaderInterlockFeaturesEXTBuilder<'a> {
    inner: PhysicalDeviceFragmentShaderInterlockFeaturesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceFragmentShaderInterlockFeaturesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceFragmentShaderInterlockFeaturesEXTBuilder<'a> {
        PhysicalDeviceFragmentShaderInterlockFeaturesEXTBuilder {
            inner: PhysicalDeviceFragmentShaderInterlockFeaturesEXT {
                s_type: StructureType::from_raw(1000251000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceFragmentShaderInterlockFeaturesEXTBuilder<'a> {
    #[inline]
    pub fn fragment_shader_sample_interlock(mut self, value: bool) -> Self {
        self.inner.fragment_shader_sample_interlock = value as u32;
        self
    }
    #[inline]
    pub fn fragment_shader_pixel_interlock(mut self, value: bool) -> Self {
        self.inner.fragment_shader_pixel_interlock = value as u32;
        self
    }
    #[inline]
    pub fn fragment_shader_shading_rate_interlock(mut self, value: bool) -> Self {
        self.inner.fragment_shader_shading_rate_interlock = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceFragmentShaderInterlockFeaturesEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceFragmentShaderInterlockFeaturesEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDeviceFragmentShaderInterlockFeaturesEXTBuilder<'a> {
    type Target = PhysicalDeviceFragmentShaderInterlockFeaturesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceFragmentShaderInterlockFeaturesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceSeparateDepthStencilLayoutsFeatures`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceSeparateDepthStencilLayoutsFeaturesBuilder<'a> {
    inner: PhysicalDeviceSeparateDepthStencilLayoutsFeatures,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceSeparateDepthStencilLayoutsFeatures {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceSeparateDepthStencilLayoutsFeaturesBuilder<
        'a,
    > {
        PhysicalDeviceSeparateDepthStencilLayoutsFeaturesBuilder {
            inner: PhysicalDeviceSeparateDepthStencilLayoutsFeatures {
                s_type: StructureType::from_raw(1000241000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceSeparateDepthStencilLayoutsFeaturesBuilder<'a> {
    #[inline]
    pub fn separate_depth_stencil_layouts(mut self, value: bool) -> Self {
        self.inner.separate_depth_stencil_layouts = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceSeparateDepthStencilLayoutsFeatures`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceSeparateDepthStencilLayoutsFeatures>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDeviceSeparateDepthStencilLayoutsFeaturesBuilder<'a> {
    type Target = PhysicalDeviceSeparateDepthStencilLayoutsFeatures;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceSeparateDepthStencilLayoutsFeaturesBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`AttachmentReferenceStencilLayout`] with lifetime-tied pNext safety.
pub struct AttachmentReferenceStencilLayoutBuilder<'a> {
    inner: AttachmentReferenceStencilLayout,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl AttachmentReferenceStencilLayout {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> AttachmentReferenceStencilLayoutBuilder<'a> {
        AttachmentReferenceStencilLayoutBuilder {
            inner: AttachmentReferenceStencilLayout {
                s_type: StructureType::from_raw(1000241001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> AttachmentReferenceStencilLayoutBuilder<'a> {
    #[inline]
    pub fn stencil_layout(mut self, value: ImageLayout) -> Self {
        self.inner.stencil_layout = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`AttachmentReferenceStencilLayout`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsAttachmentReferenceStencilLayout>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for AttachmentReferenceStencilLayoutBuilder<'a> {
    type Target = AttachmentReferenceStencilLayout;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for AttachmentReferenceStencilLayoutBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDevicePrimitiveTopologyListRestartFeaturesEXTBuilder<'a> {
    inner: PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDevicePrimitiveTopologyListRestartFeaturesEXTBuilder<
        'a,
    > {
        PhysicalDevicePrimitiveTopologyListRestartFeaturesEXTBuilder {
            inner: PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT {
                s_type: StructureType::from_raw(1000356000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDevicePrimitiveTopologyListRestartFeaturesEXTBuilder<'a> {
    #[inline]
    pub fn primitive_topology_list_restart(mut self, value: bool) -> Self {
        self.inner.primitive_topology_list_restart = value as u32;
        self
    }
    #[inline]
    pub fn primitive_topology_patch_list_restart(mut self, value: bool) -> Self {
        self.inner.primitive_topology_patch_list_restart = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDevicePrimitiveTopologyListRestartFeaturesEXTBuilder<'a> {
    type Target = PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDevicePrimitiveTopologyListRestartFeaturesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`AttachmentDescriptionStencilLayout`] with lifetime-tied pNext safety.
pub struct AttachmentDescriptionStencilLayoutBuilder<'a> {
    inner: AttachmentDescriptionStencilLayout,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl AttachmentDescriptionStencilLayout {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> AttachmentDescriptionStencilLayoutBuilder<'a> {
        AttachmentDescriptionStencilLayoutBuilder {
            inner: AttachmentDescriptionStencilLayout {
                s_type: StructureType::from_raw(1000241002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> AttachmentDescriptionStencilLayoutBuilder<'a> {
    #[inline]
    pub fn stencil_initial_layout(mut self, value: ImageLayout) -> Self {
        self.inner.stencil_initial_layout = value;
        self
    }
    #[inline]
    pub fn stencil_final_layout(mut self, value: ImageLayout) -> Self {
        self.inner.stencil_final_layout = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`AttachmentDescriptionStencilLayout`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsAttachmentDescriptionStencilLayout>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for AttachmentDescriptionStencilLayoutBuilder<'a> {
    type Target = AttachmentDescriptionStencilLayout;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for AttachmentDescriptionStencilLayoutBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDevicePipelineExecutablePropertiesFeaturesKHR`] with lifetime-tied pNext safety.
pub struct PhysicalDevicePipelineExecutablePropertiesFeaturesKHRBuilder<'a> {
    inner: PhysicalDevicePipelineExecutablePropertiesFeaturesKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDevicePipelineExecutablePropertiesFeaturesKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDevicePipelineExecutablePropertiesFeaturesKHRBuilder<
        'a,
    > {
        PhysicalDevicePipelineExecutablePropertiesFeaturesKHRBuilder {
            inner: PhysicalDevicePipelineExecutablePropertiesFeaturesKHR {
                s_type: StructureType::from_raw(1000269000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDevicePipelineExecutablePropertiesFeaturesKHRBuilder<'a> {
    #[inline]
    pub fn pipeline_executable_info(mut self, value: bool) -> Self {
        self.inner.pipeline_executable_info = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDevicePipelineExecutablePropertiesFeaturesKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDevicePipelineExecutablePropertiesFeaturesKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDevicePipelineExecutablePropertiesFeaturesKHRBuilder<'a> {
    type Target = PhysicalDevicePipelineExecutablePropertiesFeaturesKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDevicePipelineExecutablePropertiesFeaturesKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PipelineInfoKHR`] with lifetime-tied pNext safety.
pub struct PipelineInfoKHRBuilder<'a> {
    inner: PipelineInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PipelineInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PipelineInfoKHRBuilder<'a> {
        PipelineInfoKHRBuilder {
            inner: PipelineInfoKHR {
                s_type: StructureType::from_raw(1000269001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PipelineInfoKHRBuilder<'a> {
    #[inline]
    pub fn pipeline(mut self, value: Pipeline) -> Self {
        self.inner.pipeline = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PipelineInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPipelineInfoKHR>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for PipelineInfoKHRBuilder<'a> {
    type Target = PipelineInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PipelineInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PipelineExecutablePropertiesKHR`] with lifetime-tied pNext safety.
pub struct PipelineExecutablePropertiesKHRBuilder<'a> {
    inner: PipelineExecutablePropertiesKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PipelineExecutablePropertiesKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PipelineExecutablePropertiesKHRBuilder<'a> {
        PipelineExecutablePropertiesKHRBuilder {
            inner: PipelineExecutablePropertiesKHR {
                s_type: StructureType::from_raw(1000269002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PipelineExecutablePropertiesKHRBuilder<'a> {
    #[inline]
    pub fn stages(mut self, value: ShaderStageFlags) -> Self {
        self.inner.stages = value;
        self
    }
    #[inline]
    pub fn name(
        mut self,
        value: crate::StringArray<{ MAX_DESCRIPTION_SIZE as usize }>,
    ) -> Self {
        self.inner.name = value;
        self
    }
    #[inline]
    pub fn description(
        mut self,
        value: crate::StringArray<{ MAX_DESCRIPTION_SIZE as usize }>,
    ) -> Self {
        self.inner.description = value;
        self
    }
    #[inline]
    pub fn subgroup_size(mut self, value: u32) -> Self {
        self.inner.subgroup_size = value;
        self
    }
}
impl<'a> core::ops::Deref for PipelineExecutablePropertiesKHRBuilder<'a> {
    type Target = PipelineExecutablePropertiesKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PipelineExecutablePropertiesKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PipelineExecutableInfoKHR`] with lifetime-tied pNext safety.
pub struct PipelineExecutableInfoKHRBuilder<'a> {
    inner: PipelineExecutableInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PipelineExecutableInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PipelineExecutableInfoKHRBuilder<'a> {
        PipelineExecutableInfoKHRBuilder {
            inner: PipelineExecutableInfoKHR {
                s_type: StructureType::from_raw(1000269003i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PipelineExecutableInfoKHRBuilder<'a> {
    #[inline]
    pub fn pipeline(mut self, value: Pipeline) -> Self {
        self.inner.pipeline = value;
        self
    }
    #[inline]
    pub fn executable_index(mut self, value: u32) -> Self {
        self.inner.executable_index = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PipelineExecutableInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPipelineExecutableInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for PipelineExecutableInfoKHRBuilder<'a> {
    type Target = PipelineExecutableInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PipelineExecutableInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PipelineExecutableStatisticKHR`] with lifetime-tied pNext safety.
pub struct PipelineExecutableStatisticKHRBuilder<'a> {
    inner: PipelineExecutableStatisticKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PipelineExecutableStatisticKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PipelineExecutableStatisticKHRBuilder<'a> {
        PipelineExecutableStatisticKHRBuilder {
            inner: PipelineExecutableStatisticKHR {
                s_type: StructureType::from_raw(1000269004i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PipelineExecutableStatisticKHRBuilder<'a> {
    #[inline]
    pub fn name(
        mut self,
        value: crate::StringArray<{ MAX_DESCRIPTION_SIZE as usize }>,
    ) -> Self {
        self.inner.name = value;
        self
    }
    #[inline]
    pub fn description(
        mut self,
        value: crate::StringArray<{ MAX_DESCRIPTION_SIZE as usize }>,
    ) -> Self {
        self.inner.description = value;
        self
    }
    #[inline]
    pub fn format(mut self, value: PipelineExecutableStatisticFormatKHR) -> Self {
        self.inner.format = value;
        self
    }
    #[inline]
    pub fn value(mut self, value: PipelineExecutableStatisticValueKHR) -> Self {
        self.inner.value = value;
        self
    }
}
impl<'a> core::ops::Deref for PipelineExecutableStatisticKHRBuilder<'a> {
    type Target = PipelineExecutableStatisticKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PipelineExecutableStatisticKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PipelineExecutableInternalRepresentationKHR`] with lifetime-tied pNext safety.
pub struct PipelineExecutableInternalRepresentationKHRBuilder<'a> {
    inner: PipelineExecutableInternalRepresentationKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PipelineExecutableInternalRepresentationKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PipelineExecutableInternalRepresentationKHRBuilder<'a> {
        PipelineExecutableInternalRepresentationKHRBuilder {
            inner: PipelineExecutableInternalRepresentationKHR {
                s_type: StructureType::from_raw(1000269005i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PipelineExecutableInternalRepresentationKHRBuilder<'a> {
    #[inline]
    pub fn name(
        mut self,
        value: crate::StringArray<{ MAX_DESCRIPTION_SIZE as usize }>,
    ) -> Self {
        self.inner.name = value;
        self
    }
    #[inline]
    pub fn description(
        mut self,
        value: crate::StringArray<{ MAX_DESCRIPTION_SIZE as usize }>,
    ) -> Self {
        self.inner.description = value;
        self
    }
    #[inline]
    pub fn is_text(mut self, value: bool) -> Self {
        self.inner.is_text = value as u32;
        self
    }
    #[inline]
    pub fn data_size(mut self, value: usize) -> Self {
        self.inner.data_size = value;
        self
    }
    #[inline]
    pub fn data(mut self, slice: &'a mut [core::ffi::c_void]) -> Self {
        self.inner.data_size = slice.len();
        self.inner.p_data = slice.as_mut_ptr();
        self
    }
}
impl<'a> core::ops::Deref for PipelineExecutableInternalRepresentationKHRBuilder<'a> {
    type Target = PipelineExecutableInternalRepresentationKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PipelineExecutableInternalRepresentationKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceShaderDemoteToHelperInvocationFeatures`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceShaderDemoteToHelperInvocationFeaturesBuilder<'a> {
    inner: PhysicalDeviceShaderDemoteToHelperInvocationFeatures,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceShaderDemoteToHelperInvocationFeatures {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceShaderDemoteToHelperInvocationFeaturesBuilder<
        'a,
    > {
        PhysicalDeviceShaderDemoteToHelperInvocationFeaturesBuilder {
            inner: PhysicalDeviceShaderDemoteToHelperInvocationFeatures {
                s_type: StructureType::from_raw(1000276000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceShaderDemoteToHelperInvocationFeaturesBuilder<'a> {
    #[inline]
    pub fn shader_demote_to_helper_invocation(mut self, value: bool) -> Self {
        self.inner.shader_demote_to_helper_invocation = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceShaderDemoteToHelperInvocationFeatures`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceShaderDemoteToHelperInvocationFeatures>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDeviceShaderDemoteToHelperInvocationFeaturesBuilder<'a> {
    type Target = PhysicalDeviceShaderDemoteToHelperInvocationFeatures;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceShaderDemoteToHelperInvocationFeaturesBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceTexelBufferAlignmentFeaturesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceTexelBufferAlignmentFeaturesEXTBuilder<'a> {
    inner: PhysicalDeviceTexelBufferAlignmentFeaturesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceTexelBufferAlignmentFeaturesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceTexelBufferAlignmentFeaturesEXTBuilder<'a> {
        PhysicalDeviceTexelBufferAlignmentFeaturesEXTBuilder {
            inner: PhysicalDeviceTexelBufferAlignmentFeaturesEXT {
                s_type: StructureType::from_raw(1000281000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceTexelBufferAlignmentFeaturesEXTBuilder<'a> {
    #[inline]
    pub fn texel_buffer_alignment(mut self, value: bool) -> Self {
        self.inner.texel_buffer_alignment = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceTexelBufferAlignmentFeaturesEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceTexelBufferAlignmentFeaturesEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceTexelBufferAlignmentFeaturesEXTBuilder<'a> {
    type Target = PhysicalDeviceTexelBufferAlignmentFeaturesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceTexelBufferAlignmentFeaturesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceTexelBufferAlignmentProperties`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceTexelBufferAlignmentPropertiesBuilder<'a> {
    inner: PhysicalDeviceTexelBufferAlignmentProperties,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceTexelBufferAlignmentProperties {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceTexelBufferAlignmentPropertiesBuilder<'a> {
        PhysicalDeviceTexelBufferAlignmentPropertiesBuilder {
            inner: PhysicalDeviceTexelBufferAlignmentProperties {
                s_type: StructureType::from_raw(1000281001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceTexelBufferAlignmentPropertiesBuilder<'a> {
    #[inline]
    pub fn storage_texel_buffer_offset_alignment_bytes(mut self, value: u64) -> Self {
        self.inner.storage_texel_buffer_offset_alignment_bytes = value;
        self
    }
    #[inline]
    pub fn storage_texel_buffer_offset_single_texel_alignment(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.storage_texel_buffer_offset_single_texel_alignment = value as u32;
        self
    }
    #[inline]
    pub fn uniform_texel_buffer_offset_alignment_bytes(mut self, value: u64) -> Self {
        self.inner.uniform_texel_buffer_offset_alignment_bytes = value;
        self
    }
    #[inline]
    pub fn uniform_texel_buffer_offset_single_texel_alignment(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.uniform_texel_buffer_offset_single_texel_alignment = value as u32;
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceTexelBufferAlignmentPropertiesBuilder<'a> {
    type Target = PhysicalDeviceTexelBufferAlignmentProperties;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceTexelBufferAlignmentPropertiesBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceSubgroupSizeControlFeatures`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceSubgroupSizeControlFeaturesBuilder<'a> {
    inner: PhysicalDeviceSubgroupSizeControlFeatures,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceSubgroupSizeControlFeatures {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceSubgroupSizeControlFeaturesBuilder<'a> {
        PhysicalDeviceSubgroupSizeControlFeaturesBuilder {
            inner: PhysicalDeviceSubgroupSizeControlFeatures {
                s_type: StructureType::from_raw(1000225002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceSubgroupSizeControlFeaturesBuilder<'a> {
    #[inline]
    pub fn subgroup_size_control(mut self, value: bool) -> Self {
        self.inner.subgroup_size_control = value as u32;
        self
    }
    #[inline]
    pub fn compute_full_subgroups(mut self, value: bool) -> Self {
        self.inner.compute_full_subgroups = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceSubgroupSizeControlFeatures`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceSubgroupSizeControlFeatures>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceSubgroupSizeControlFeaturesBuilder<'a> {
    type Target = PhysicalDeviceSubgroupSizeControlFeatures;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceSubgroupSizeControlFeaturesBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceSubgroupSizeControlProperties`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceSubgroupSizeControlPropertiesBuilder<'a> {
    inner: PhysicalDeviceSubgroupSizeControlProperties,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceSubgroupSizeControlProperties {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceSubgroupSizeControlPropertiesBuilder<'a> {
        PhysicalDeviceSubgroupSizeControlPropertiesBuilder {
            inner: PhysicalDeviceSubgroupSizeControlProperties {
                s_type: StructureType::from_raw(1000225000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceSubgroupSizeControlPropertiesBuilder<'a> {
    #[inline]
    pub fn min_subgroup_size(mut self, value: u32) -> Self {
        self.inner.min_subgroup_size = value;
        self
    }
    #[inline]
    pub fn max_subgroup_size(mut self, value: u32) -> Self {
        self.inner.max_subgroup_size = value;
        self
    }
    #[inline]
    pub fn max_compute_workgroup_subgroups(mut self, value: u32) -> Self {
        self.inner.max_compute_workgroup_subgroups = value;
        self
    }
    #[inline]
    pub fn required_subgroup_size_stages(mut self, value: ShaderStageFlags) -> Self {
        self.inner.required_subgroup_size_stages = value;
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceSubgroupSizeControlPropertiesBuilder<'a> {
    type Target = PhysicalDeviceSubgroupSizeControlProperties;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceSubgroupSizeControlPropertiesBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PipelineShaderStageRequiredSubgroupSizeCreateInfo`] with lifetime-tied pNext safety.
pub struct PipelineShaderStageRequiredSubgroupSizeCreateInfoBuilder<'a> {
    inner: PipelineShaderStageRequiredSubgroupSizeCreateInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PipelineShaderStageRequiredSubgroupSizeCreateInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PipelineShaderStageRequiredSubgroupSizeCreateInfoBuilder<
        'a,
    > {
        PipelineShaderStageRequiredSubgroupSizeCreateInfoBuilder {
            inner: PipelineShaderStageRequiredSubgroupSizeCreateInfo {
                s_type: StructureType::from_raw(1000225001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PipelineShaderStageRequiredSubgroupSizeCreateInfoBuilder<'a> {
    #[inline]
    pub fn required_subgroup_size(mut self, value: u32) -> Self {
        self.inner.required_subgroup_size = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PipelineShaderStageRequiredSubgroupSizeCreateInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPipelineShaderStageRequiredSubgroupSizeCreateInfo>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref
for PipelineShaderStageRequiredSubgroupSizeCreateInfoBuilder<'a> {
    type Target = PipelineShaderStageRequiredSubgroupSizeCreateInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PipelineShaderStageRequiredSubgroupSizeCreateInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`SubpassShadingPipelineCreateInfoHUAWEI`] with lifetime-tied pNext safety.
pub struct SubpassShadingPipelineCreateInfoHUAWEIBuilder<'a> {
    inner: SubpassShadingPipelineCreateInfoHUAWEI,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl SubpassShadingPipelineCreateInfoHUAWEI {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> SubpassShadingPipelineCreateInfoHUAWEIBuilder<'a> {
        SubpassShadingPipelineCreateInfoHUAWEIBuilder {
            inner: SubpassShadingPipelineCreateInfoHUAWEI {
                s_type: StructureType::from_raw(1000369000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> SubpassShadingPipelineCreateInfoHUAWEIBuilder<'a> {
    #[inline]
    pub fn render_pass(mut self, value: RenderPass) -> Self {
        self.inner.render_pass = value;
        self
    }
    #[inline]
    pub fn subpass(mut self, value: u32) -> Self {
        self.inner.subpass = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`SubpassShadingPipelineCreateInfoHUAWEI`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsSubpassShadingPipelineCreateInfoHUAWEI>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for SubpassShadingPipelineCreateInfoHUAWEIBuilder<'a> {
    type Target = SubpassShadingPipelineCreateInfoHUAWEI;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for SubpassShadingPipelineCreateInfoHUAWEIBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceSubpassShadingPropertiesHUAWEI`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceSubpassShadingPropertiesHUAWEIBuilder<'a> {
    inner: PhysicalDeviceSubpassShadingPropertiesHUAWEI,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceSubpassShadingPropertiesHUAWEI {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceSubpassShadingPropertiesHUAWEIBuilder<'a> {
        PhysicalDeviceSubpassShadingPropertiesHUAWEIBuilder {
            inner: PhysicalDeviceSubpassShadingPropertiesHUAWEI {
                s_type: StructureType::from_raw(1000369002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceSubpassShadingPropertiesHUAWEIBuilder<'a> {
    #[inline]
    pub fn max_subpass_shading_workgroup_size_aspect_ratio(
        mut self,
        value: u32,
    ) -> Self {
        self.inner.max_subpass_shading_workgroup_size_aspect_ratio = value;
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceSubpassShadingPropertiesHUAWEIBuilder<'a> {
    type Target = PhysicalDeviceSubpassShadingPropertiesHUAWEI;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceSubpassShadingPropertiesHUAWEIBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceClusterCullingShaderPropertiesHUAWEI`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceClusterCullingShaderPropertiesHUAWEIBuilder<'a> {
    inner: PhysicalDeviceClusterCullingShaderPropertiesHUAWEI,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceClusterCullingShaderPropertiesHUAWEI {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceClusterCullingShaderPropertiesHUAWEIBuilder<
        'a,
    > {
        PhysicalDeviceClusterCullingShaderPropertiesHUAWEIBuilder {
            inner: PhysicalDeviceClusterCullingShaderPropertiesHUAWEI {
                s_type: StructureType::from_raw(1000404001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceClusterCullingShaderPropertiesHUAWEIBuilder<'a> {
    #[inline]
    pub fn max_work_group_count(mut self, value: [u32; 3usize]) -> Self {
        self.inner.max_work_group_count = value;
        self
    }
    #[inline]
    pub fn max_work_group_size(mut self, value: [u32; 3usize]) -> Self {
        self.inner.max_work_group_size = value;
        self
    }
    #[inline]
    pub fn max_output_cluster_count(mut self, value: u32) -> Self {
        self.inner.max_output_cluster_count = value;
        self
    }
    #[inline]
    pub fn indirect_buffer_offset_alignment(mut self, value: u64) -> Self {
        self.inner.indirect_buffer_offset_alignment = value;
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDeviceClusterCullingShaderPropertiesHUAWEIBuilder<'a> {
    type Target = PhysicalDeviceClusterCullingShaderPropertiesHUAWEI;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceClusterCullingShaderPropertiesHUAWEIBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`MemoryOpaqueCaptureAddressAllocateInfo`] with lifetime-tied pNext safety.
pub struct MemoryOpaqueCaptureAddressAllocateInfoBuilder<'a> {
    inner: MemoryOpaqueCaptureAddressAllocateInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl MemoryOpaqueCaptureAddressAllocateInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> MemoryOpaqueCaptureAddressAllocateInfoBuilder<'a> {
        MemoryOpaqueCaptureAddressAllocateInfoBuilder {
            inner: MemoryOpaqueCaptureAddressAllocateInfo {
                s_type: StructureType::from_raw(1000257003i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> MemoryOpaqueCaptureAddressAllocateInfoBuilder<'a> {
    #[inline]
    pub fn opaque_capture_address(mut self, value: u64) -> Self {
        self.inner.opaque_capture_address = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`MemoryOpaqueCaptureAddressAllocateInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsMemoryOpaqueCaptureAddressAllocateInfo>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for MemoryOpaqueCaptureAddressAllocateInfoBuilder<'a> {
    type Target = MemoryOpaqueCaptureAddressAllocateInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for MemoryOpaqueCaptureAddressAllocateInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DeviceMemoryOpaqueCaptureAddressInfo`] with lifetime-tied pNext safety.
pub struct DeviceMemoryOpaqueCaptureAddressInfoBuilder<'a> {
    inner: DeviceMemoryOpaqueCaptureAddressInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DeviceMemoryOpaqueCaptureAddressInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> DeviceMemoryOpaqueCaptureAddressInfoBuilder<'a> {
        DeviceMemoryOpaqueCaptureAddressInfoBuilder {
            inner: DeviceMemoryOpaqueCaptureAddressInfo {
                s_type: StructureType::from_raw(1000257004i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DeviceMemoryOpaqueCaptureAddressInfoBuilder<'a> {
    #[inline]
    pub fn memory(mut self, value: DeviceMemory) -> Self {
        self.inner.memory = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`DeviceMemoryOpaqueCaptureAddressInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsDeviceMemoryOpaqueCaptureAddressInfo>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for DeviceMemoryOpaqueCaptureAddressInfoBuilder<'a> {
    type Target = DeviceMemoryOpaqueCaptureAddressInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for DeviceMemoryOpaqueCaptureAddressInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceLineRasterizationFeatures`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceLineRasterizationFeaturesBuilder<'a> {
    inner: PhysicalDeviceLineRasterizationFeatures,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceLineRasterizationFeatures {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceLineRasterizationFeaturesBuilder<'a> {
        PhysicalDeviceLineRasterizationFeaturesBuilder {
            inner: PhysicalDeviceLineRasterizationFeatures {
                s_type: StructureType::from_raw(1000259000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceLineRasterizationFeaturesBuilder<'a> {
    #[inline]
    pub fn rectangular_lines(mut self, value: bool) -> Self {
        self.inner.rectangular_lines = value as u32;
        self
    }
    #[inline]
    pub fn bresenham_lines(mut self, value: bool) -> Self {
        self.inner.bresenham_lines = value as u32;
        self
    }
    #[inline]
    pub fn smooth_lines(mut self, value: bool) -> Self {
        self.inner.smooth_lines = value as u32;
        self
    }
    #[inline]
    pub fn stippled_rectangular_lines(mut self, value: bool) -> Self {
        self.inner.stippled_rectangular_lines = value as u32;
        self
    }
    #[inline]
    pub fn stippled_bresenham_lines(mut self, value: bool) -> Self {
        self.inner.stippled_bresenham_lines = value as u32;
        self
    }
    #[inline]
    pub fn stippled_smooth_lines(mut self, value: bool) -> Self {
        self.inner.stippled_smooth_lines = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceLineRasterizationFeatures`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceLineRasterizationFeatures>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceLineRasterizationFeaturesBuilder<'a> {
    type Target = PhysicalDeviceLineRasterizationFeatures;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceLineRasterizationFeaturesBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceLineRasterizationProperties`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceLineRasterizationPropertiesBuilder<'a> {
    inner: PhysicalDeviceLineRasterizationProperties,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceLineRasterizationProperties {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceLineRasterizationPropertiesBuilder<'a> {
        PhysicalDeviceLineRasterizationPropertiesBuilder {
            inner: PhysicalDeviceLineRasterizationProperties {
                s_type: StructureType::from_raw(1000259002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceLineRasterizationPropertiesBuilder<'a> {
    #[inline]
    pub fn line_sub_pixel_precision_bits(mut self, value: u32) -> Self {
        self.inner.line_sub_pixel_precision_bits = value;
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceLineRasterizationPropertiesBuilder<'a> {
    type Target = PhysicalDeviceLineRasterizationProperties;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceLineRasterizationPropertiesBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PipelineRasterizationLineStateCreateInfo`] with lifetime-tied pNext safety.
pub struct PipelineRasterizationLineStateCreateInfoBuilder<'a> {
    inner: PipelineRasterizationLineStateCreateInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PipelineRasterizationLineStateCreateInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PipelineRasterizationLineStateCreateInfoBuilder<'a> {
        PipelineRasterizationLineStateCreateInfoBuilder {
            inner: PipelineRasterizationLineStateCreateInfo {
                s_type: StructureType::from_raw(1000259001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PipelineRasterizationLineStateCreateInfoBuilder<'a> {
    #[inline]
    pub fn line_rasterization_mode(mut self, value: LineRasterizationMode) -> Self {
        self.inner.line_rasterization_mode = value;
        self
    }
    #[inline]
    pub fn stippled_line_enable(mut self, value: bool) -> Self {
        self.inner.stippled_line_enable = value as u32;
        self
    }
    #[inline]
    pub fn line_stipple_factor(mut self, value: u32) -> Self {
        self.inner.line_stipple_factor = value;
        self
    }
    #[inline]
    pub fn line_stipple_pattern(mut self, value: u16) -> Self {
        self.inner.line_stipple_pattern = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PipelineRasterizationLineStateCreateInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPipelineRasterizationLineStateCreateInfo>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for PipelineRasterizationLineStateCreateInfoBuilder<'a> {
    type Target = PipelineRasterizationLineStateCreateInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PipelineRasterizationLineStateCreateInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDevicePipelineCreationCacheControlFeatures`] with lifetime-tied pNext safety.
pub struct PhysicalDevicePipelineCreationCacheControlFeaturesBuilder<'a> {
    inner: PhysicalDevicePipelineCreationCacheControlFeatures,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDevicePipelineCreationCacheControlFeatures {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDevicePipelineCreationCacheControlFeaturesBuilder<
        'a,
    > {
        PhysicalDevicePipelineCreationCacheControlFeaturesBuilder {
            inner: PhysicalDevicePipelineCreationCacheControlFeatures {
                s_type: StructureType::from_raw(1000297000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDevicePipelineCreationCacheControlFeaturesBuilder<'a> {
    #[inline]
    pub fn pipeline_creation_cache_control(mut self, value: bool) -> Self {
        self.inner.pipeline_creation_cache_control = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDevicePipelineCreationCacheControlFeatures`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDevicePipelineCreationCacheControlFeatures>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDevicePipelineCreationCacheControlFeaturesBuilder<'a> {
    type Target = PhysicalDevicePipelineCreationCacheControlFeatures;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDevicePipelineCreationCacheControlFeaturesBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceVulkan11Features`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceVulkan11FeaturesBuilder<'a> {
    inner: PhysicalDeviceVulkan11Features,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceVulkan11Features {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceVulkan11FeaturesBuilder<'a> {
        PhysicalDeviceVulkan11FeaturesBuilder {
            inner: PhysicalDeviceVulkan11Features {
                s_type: StructureType::from_raw(49i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceVulkan11FeaturesBuilder<'a> {
    #[inline]
    pub fn storage_buffer16_bit_access(mut self, value: bool) -> Self {
        self.inner.storage_buffer16_bit_access = value as u32;
        self
    }
    #[inline]
    pub fn uniform_and_storage_buffer16_bit_access(mut self, value: bool) -> Self {
        self.inner.uniform_and_storage_buffer16_bit_access = value as u32;
        self
    }
    #[inline]
    pub fn storage_push_constant16(mut self, value: bool) -> Self {
        self.inner.storage_push_constant16 = value as u32;
        self
    }
    #[inline]
    pub fn storage_input_output16(mut self, value: bool) -> Self {
        self.inner.storage_input_output16 = value as u32;
        self
    }
    #[inline]
    pub fn multiview(mut self, value: bool) -> Self {
        self.inner.multiview = value as u32;
        self
    }
    #[inline]
    pub fn multiview_geometry_shader(mut self, value: bool) -> Self {
        self.inner.multiview_geometry_shader = value as u32;
        self
    }
    #[inline]
    pub fn multiview_tessellation_shader(mut self, value: bool) -> Self {
        self.inner.multiview_tessellation_shader = value as u32;
        self
    }
    #[inline]
    pub fn variable_pointers_storage_buffer(mut self, value: bool) -> Self {
        self.inner.variable_pointers_storage_buffer = value as u32;
        self
    }
    #[inline]
    pub fn variable_pointers(mut self, value: bool) -> Self {
        self.inner.variable_pointers = value as u32;
        self
    }
    #[inline]
    pub fn protected_memory(mut self, value: bool) -> Self {
        self.inner.protected_memory = value as u32;
        self
    }
    #[inline]
    pub fn sampler_ycbcr_conversion(mut self, value: bool) -> Self {
        self.inner.sampler_ycbcr_conversion = value as u32;
        self
    }
    #[inline]
    pub fn shader_draw_parameters(mut self, value: bool) -> Self {
        self.inner.shader_draw_parameters = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceVulkan11Features`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceVulkan11Features>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceVulkan11FeaturesBuilder<'a> {
    type Target = PhysicalDeviceVulkan11Features;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceVulkan11FeaturesBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceVulkan11Properties`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceVulkan11PropertiesBuilder<'a> {
    inner: PhysicalDeviceVulkan11Properties,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceVulkan11Properties {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceVulkan11PropertiesBuilder<'a> {
        PhysicalDeviceVulkan11PropertiesBuilder {
            inner: PhysicalDeviceVulkan11Properties {
                s_type: StructureType::from_raw(50i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceVulkan11PropertiesBuilder<'a> {
    #[inline]
    pub fn device_uuid(mut self, value: [u8; UUID_SIZE as usize]) -> Self {
        self.inner.device_uuid = value;
        self
    }
    #[inline]
    pub fn driver_uuid(mut self, value: [u8; UUID_SIZE as usize]) -> Self {
        self.inner.driver_uuid = value;
        self
    }
    #[inline]
    pub fn device_luid(mut self, value: [u8; LUID_SIZE as usize]) -> Self {
        self.inner.device_luid = value;
        self
    }
    #[inline]
    pub fn device_node_mask(mut self, value: u32) -> Self {
        self.inner.device_node_mask = value;
        self
    }
    #[inline]
    pub fn device_luid_valid(mut self, value: bool) -> Self {
        self.inner.device_luid_valid = value as u32;
        self
    }
    #[inline]
    pub fn subgroup_size(mut self, value: u32) -> Self {
        self.inner.subgroup_size = value;
        self
    }
    #[inline]
    pub fn subgroup_supported_stages(mut self, value: ShaderStageFlags) -> Self {
        self.inner.subgroup_supported_stages = value;
        self
    }
    #[inline]
    pub fn subgroup_supported_operations(mut self, value: SubgroupFeatureFlags) -> Self {
        self.inner.subgroup_supported_operations = value;
        self
    }
    #[inline]
    pub fn subgroup_quad_operations_in_all_stages(mut self, value: bool) -> Self {
        self.inner.subgroup_quad_operations_in_all_stages = value as u32;
        self
    }
    #[inline]
    pub fn point_clipping_behavior(mut self, value: PointClippingBehavior) -> Self {
        self.inner.point_clipping_behavior = value;
        self
    }
    #[inline]
    pub fn max_multiview_view_count(mut self, value: u32) -> Self {
        self.inner.max_multiview_view_count = value;
        self
    }
    #[inline]
    pub fn max_multiview_instance_index(mut self, value: u32) -> Self {
        self.inner.max_multiview_instance_index = value;
        self
    }
    #[inline]
    pub fn protected_no_fault(mut self, value: bool) -> Self {
        self.inner.protected_no_fault = value as u32;
        self
    }
    #[inline]
    pub fn max_per_set_descriptors(mut self, value: u32) -> Self {
        self.inner.max_per_set_descriptors = value;
        self
    }
    #[inline]
    pub fn max_memory_allocation_size(mut self, value: u64) -> Self {
        self.inner.max_memory_allocation_size = value;
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceVulkan11PropertiesBuilder<'a> {
    type Target = PhysicalDeviceVulkan11Properties;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceVulkan11PropertiesBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceVulkan12Features`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceVulkan12FeaturesBuilder<'a> {
    inner: PhysicalDeviceVulkan12Features,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceVulkan12Features {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
        PhysicalDeviceVulkan12FeaturesBuilder {
            inner: PhysicalDeviceVulkan12Features {
                s_type: StructureType::from_raw(51i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
    #[inline]
    pub fn sampler_mirror_clamp_to_edge(mut self, value: bool) -> Self {
        self.inner.sampler_mirror_clamp_to_edge = value as u32;
        self
    }
    #[inline]
    pub fn draw_indirect_count(mut self, value: bool) -> Self {
        self.inner.draw_indirect_count = value as u32;
        self
    }
    #[inline]
    pub fn storage_buffer8_bit_access(mut self, value: bool) -> Self {
        self.inner.storage_buffer8_bit_access = value as u32;
        self
    }
    #[inline]
    pub fn uniform_and_storage_buffer8_bit_access(mut self, value: bool) -> Self {
        self.inner.uniform_and_storage_buffer8_bit_access = value as u32;
        self
    }
    #[inline]
    pub fn storage_push_constant8(mut self, value: bool) -> Self {
        self.inner.storage_push_constant8 = value as u32;
        self
    }
    #[inline]
    pub fn shader_buffer_int64_atomics(mut self, value: bool) -> Self {
        self.inner.shader_buffer_int64_atomics = value as u32;
        self
    }
    #[inline]
    pub fn shader_shared_int64_atomics(mut self, value: bool) -> Self {
        self.inner.shader_shared_int64_atomics = value as u32;
        self
    }
    #[inline]
    pub fn shader_float16(mut self, value: bool) -> Self {
        self.inner.shader_float16 = value as u32;
        self
    }
    #[inline]
    pub fn shader_int8(mut self, value: bool) -> Self {
        self.inner.shader_int8 = value as u32;
        self
    }
    #[inline]
    pub fn descriptor_indexing(mut self, value: bool) -> Self {
        self.inner.descriptor_indexing = value as u32;
        self
    }
    #[inline]
    pub fn shader_input_attachment_array_dynamic_indexing(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.shader_input_attachment_array_dynamic_indexing = value as u32;
        self
    }
    #[inline]
    pub fn shader_uniform_texel_buffer_array_dynamic_indexing(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.shader_uniform_texel_buffer_array_dynamic_indexing = value as u32;
        self
    }
    #[inline]
    pub fn shader_storage_texel_buffer_array_dynamic_indexing(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.shader_storage_texel_buffer_array_dynamic_indexing = value as u32;
        self
    }
    #[inline]
    pub fn shader_uniform_buffer_array_non_uniform_indexing(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.shader_uniform_buffer_array_non_uniform_indexing = value as u32;
        self
    }
    #[inline]
    pub fn shader_sampled_image_array_non_uniform_indexing(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.shader_sampled_image_array_non_uniform_indexing = value as u32;
        self
    }
    #[inline]
    pub fn shader_storage_buffer_array_non_uniform_indexing(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.shader_storage_buffer_array_non_uniform_indexing = value as u32;
        self
    }
    #[inline]
    pub fn shader_storage_image_array_non_uniform_indexing(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.shader_storage_image_array_non_uniform_indexing = value as u32;
        self
    }
    #[inline]
    pub fn shader_input_attachment_array_non_uniform_indexing(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.shader_input_attachment_array_non_uniform_indexing = value as u32;
        self
    }
    #[inline]
    pub fn shader_uniform_texel_buffer_array_non_uniform_indexing(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.shader_uniform_texel_buffer_array_non_uniform_indexing = value as u32;
        self
    }
    #[inline]
    pub fn shader_storage_texel_buffer_array_non_uniform_indexing(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.shader_storage_texel_buffer_array_non_uniform_indexing = value as u32;
        self
    }
    #[inline]
    pub fn descriptor_binding_uniform_buffer_update_after_bind(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.descriptor_binding_uniform_buffer_update_after_bind = value as u32;
        self
    }
    #[inline]
    pub fn descriptor_binding_sampled_image_update_after_bind(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.descriptor_binding_sampled_image_update_after_bind = value as u32;
        self
    }
    #[inline]
    pub fn descriptor_binding_storage_image_update_after_bind(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.descriptor_binding_storage_image_update_after_bind = value as u32;
        self
    }
    #[inline]
    pub fn descriptor_binding_storage_buffer_update_after_bind(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.descriptor_binding_storage_buffer_update_after_bind = value as u32;
        self
    }
    #[inline]
    pub fn descriptor_binding_uniform_texel_buffer_update_after_bind(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.descriptor_binding_uniform_texel_buffer_update_after_bind = value
            as u32;
        self
    }
    #[inline]
    pub fn descriptor_binding_storage_texel_buffer_update_after_bind(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.descriptor_binding_storage_texel_buffer_update_after_bind = value
            as u32;
        self
    }
    #[inline]
    pub fn descriptor_binding_update_unused_while_pending(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.descriptor_binding_update_unused_while_pending = value as u32;
        self
    }
    #[inline]
    pub fn descriptor_binding_partially_bound(mut self, value: bool) -> Self {
        self.inner.descriptor_binding_partially_bound = value as u32;
        self
    }
    #[inline]
    pub fn descriptor_binding_variable_descriptor_count(mut self, value: bool) -> Self {
        self.inner.descriptor_binding_variable_descriptor_count = value as u32;
        self
    }
    #[inline]
    pub fn runtime_descriptor_array(mut self, value: bool) -> Self {
        self.inner.runtime_descriptor_array = value as u32;
        self
    }
    #[inline]
    pub fn sampler_filter_minmax(mut self, value: bool) -> Self {
        self.inner.sampler_filter_minmax = value as u32;
        self
    }
    #[inline]
    pub fn scalar_block_layout(mut self, value: bool) -> Self {
        self.inner.scalar_block_layout = value as u32;
        self
    }
    #[inline]
    pub fn imageless_framebuffer(mut self, value: bool) -> Self {
        self.inner.imageless_framebuffer = value as u32;
        self
    }
    #[inline]
    pub fn uniform_buffer_standard_layout(mut self, value: bool) -> Self {
        self.inner.uniform_buffer_standard_layout = value as u32;
        self
    }
    #[inline]
    pub fn shader_subgroup_extended_types(mut self, value: bool) -> Self {
        self.inner.shader_subgroup_extended_types = value as u32;
        self
    }
    #[inline]
    pub fn separate_depth_stencil_layouts(mut self, value: bool) -> Self {
        self.inner.separate_depth_stencil_layouts = value as u32;
        self
    }
    #[inline]
    pub fn host_query_reset(mut self, value: bool) -> Self {
        self.inner.host_query_reset = value as u32;
        self
    }
    #[inline]
    pub fn timeline_semaphore(mut self, value: bool) -> Self {
        self.inner.timeline_semaphore = value as u32;
        self
    }
    #[inline]
    pub fn buffer_device_address(mut self, value: bool) -> Self {
        self.inner.buffer_device_address = value as u32;
        self
    }
    #[inline]
    pub fn buffer_device_address_capture_replay(mut self, value: bool) -> Self {
        self.inner.buffer_device_address_capture_replay = value as u32;
        self
    }
    #[inline]
    pub fn buffer_device_address_multi_device(mut self, value: bool) -> Self {
        self.inner.buffer_device_address_multi_device = value as u32;
        self
    }
    #[inline]
    pub fn vulkan_memory_model(mut self, value: bool) -> Self {
        self.inner.vulkan_memory_model = value as u32;
        self
    }
    #[inline]
    pub fn vulkan_memory_model_device_scope(mut self, value: bool) -> Self {
        self.inner.vulkan_memory_model_device_scope = value as u32;
        self
    }
    #[inline]
    pub fn vulkan_memory_model_availability_visibility_chains(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.vulkan_memory_model_availability_visibility_chains = value as u32;
        self
    }
    #[inline]
    pub fn shader_output_viewport_index(mut self, value: bool) -> Self {
        self.inner.shader_output_viewport_index = value as u32;
        self
    }
    #[inline]
    pub fn shader_output_layer(mut self, value: bool) -> Self {
        self.inner.shader_output_layer = value as u32;
        self
    }
    #[inline]
    pub fn subgroup_broadcast_dynamic_id(mut self, value: bool) -> Self {
        self.inner.subgroup_broadcast_dynamic_id = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceVulkan12Features`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceVulkan12Features>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceVulkan12FeaturesBuilder<'a> {
    type Target = PhysicalDeviceVulkan12Features;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceVulkan12FeaturesBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceVulkan12Properties`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceVulkan12PropertiesBuilder<'a> {
    inner: PhysicalDeviceVulkan12Properties,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceVulkan12Properties {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
        PhysicalDeviceVulkan12PropertiesBuilder {
            inner: PhysicalDeviceVulkan12Properties {
                s_type: StructureType::from_raw(52i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
    #[inline]
    pub fn driver_id(mut self, value: DriverId) -> Self {
        self.inner.driver_id = value;
        self
    }
    #[inline]
    pub fn driver_name(
        mut self,
        value: crate::StringArray<{ MAX_DRIVER_NAME_SIZE as usize }>,
    ) -> Self {
        self.inner.driver_name = value;
        self
    }
    #[inline]
    pub fn driver_info(
        mut self,
        value: crate::StringArray<{ MAX_DRIVER_INFO_SIZE as usize }>,
    ) -> Self {
        self.inner.driver_info = value;
        self
    }
    #[inline]
    pub fn conformance_version(mut self, value: ConformanceVersion) -> Self {
        self.inner.conformance_version = value;
        self
    }
    #[inline]
    pub fn denorm_behavior_independence(
        mut self,
        value: ShaderFloatControlsIndependence,
    ) -> Self {
        self.inner.denorm_behavior_independence = value;
        self
    }
    #[inline]
    pub fn rounding_mode_independence(
        mut self,
        value: ShaderFloatControlsIndependence,
    ) -> Self {
        self.inner.rounding_mode_independence = value;
        self
    }
    #[inline]
    pub fn shader_signed_zero_inf_nan_preserve_float16(mut self, value: bool) -> Self {
        self.inner.shader_signed_zero_inf_nan_preserve_float16 = value as u32;
        self
    }
    #[inline]
    pub fn shader_signed_zero_inf_nan_preserve_float32(mut self, value: bool) -> Self {
        self.inner.shader_signed_zero_inf_nan_preserve_float32 = value as u32;
        self
    }
    #[inline]
    pub fn shader_signed_zero_inf_nan_preserve_float64(mut self, value: bool) -> Self {
        self.inner.shader_signed_zero_inf_nan_preserve_float64 = value as u32;
        self
    }
    #[inline]
    pub fn shader_denorm_preserve_float16(mut self, value: bool) -> Self {
        self.inner.shader_denorm_preserve_float16 = value as u32;
        self
    }
    #[inline]
    pub fn shader_denorm_preserve_float32(mut self, value: bool) -> Self {
        self.inner.shader_denorm_preserve_float32 = value as u32;
        self
    }
    #[inline]
    pub fn shader_denorm_preserve_float64(mut self, value: bool) -> Self {
        self.inner.shader_denorm_preserve_float64 = value as u32;
        self
    }
    #[inline]
    pub fn shader_denorm_flush_to_zero_float16(mut self, value: bool) -> Self {
        self.inner.shader_denorm_flush_to_zero_float16 = value as u32;
        self
    }
    #[inline]
    pub fn shader_denorm_flush_to_zero_float32(mut self, value: bool) -> Self {
        self.inner.shader_denorm_flush_to_zero_float32 = value as u32;
        self
    }
    #[inline]
    pub fn shader_denorm_flush_to_zero_float64(mut self, value: bool) -> Self {
        self.inner.shader_denorm_flush_to_zero_float64 = value as u32;
        self
    }
    #[inline]
    pub fn shader_rounding_mode_rte_float16(mut self, value: bool) -> Self {
        self.inner.shader_rounding_mode_rte_float16 = value as u32;
        self
    }
    #[inline]
    pub fn shader_rounding_mode_rte_float32(mut self, value: bool) -> Self {
        self.inner.shader_rounding_mode_rte_float32 = value as u32;
        self
    }
    #[inline]
    pub fn shader_rounding_mode_rte_float64(mut self, value: bool) -> Self {
        self.inner.shader_rounding_mode_rte_float64 = value as u32;
        self
    }
    #[inline]
    pub fn shader_rounding_mode_rtz_float16(mut self, value: bool) -> Self {
        self.inner.shader_rounding_mode_rtz_float16 = value as u32;
        self
    }
    #[inline]
    pub fn shader_rounding_mode_rtz_float32(mut self, value: bool) -> Self {
        self.inner.shader_rounding_mode_rtz_float32 = value as u32;
        self
    }
    #[inline]
    pub fn shader_rounding_mode_rtz_float64(mut self, value: bool) -> Self {
        self.inner.shader_rounding_mode_rtz_float64 = value as u32;
        self
    }
    #[inline]
    pub fn max_update_after_bind_descriptors_in_all_pools(mut self, value: u32) -> Self {
        self.inner.max_update_after_bind_descriptors_in_all_pools = value;
        self
    }
    #[inline]
    pub fn shader_uniform_buffer_array_non_uniform_indexing_native(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.shader_uniform_buffer_array_non_uniform_indexing_native = value
            as u32;
        self
    }
    #[inline]
    pub fn shader_sampled_image_array_non_uniform_indexing_native(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.shader_sampled_image_array_non_uniform_indexing_native = value as u32;
        self
    }
    #[inline]
    pub fn shader_storage_buffer_array_non_uniform_indexing_native(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.shader_storage_buffer_array_non_uniform_indexing_native = value
            as u32;
        self
    }
    #[inline]
    pub fn shader_storage_image_array_non_uniform_indexing_native(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.shader_storage_image_array_non_uniform_indexing_native = value as u32;
        self
    }
    #[inline]
    pub fn shader_input_attachment_array_non_uniform_indexing_native(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.shader_input_attachment_array_non_uniform_indexing_native = value
            as u32;
        self
    }
    #[inline]
    pub fn robust_buffer_access_update_after_bind(mut self, value: bool) -> Self {
        self.inner.robust_buffer_access_update_after_bind = value as u32;
        self
    }
    #[inline]
    pub fn quad_divergent_implicit_lod(mut self, value: bool) -> Self {
        self.inner.quad_divergent_implicit_lod = value as u32;
        self
    }
    #[inline]
    pub fn max_per_stage_descriptor_update_after_bind_samplers(
        mut self,
        value: u32,
    ) -> Self {
        self.inner.max_per_stage_descriptor_update_after_bind_samplers = value;
        self
    }
    #[inline]
    pub fn max_per_stage_descriptor_update_after_bind_uniform_buffers(
        mut self,
        value: u32,
    ) -> Self {
        self.inner.max_per_stage_descriptor_update_after_bind_uniform_buffers = value;
        self
    }
    #[inline]
    pub fn max_per_stage_descriptor_update_after_bind_storage_buffers(
        mut self,
        value: u32,
    ) -> Self {
        self.inner.max_per_stage_descriptor_update_after_bind_storage_buffers = value;
        self
    }
    #[inline]
    pub fn max_per_stage_descriptor_update_after_bind_sampled_images(
        mut self,
        value: u32,
    ) -> Self {
        self.inner.max_per_stage_descriptor_update_after_bind_sampled_images = value;
        self
    }
    #[inline]
    pub fn max_per_stage_descriptor_update_after_bind_storage_images(
        mut self,
        value: u32,
    ) -> Self {
        self.inner.max_per_stage_descriptor_update_after_bind_storage_images = value;
        self
    }
    #[inline]
    pub fn max_per_stage_descriptor_update_after_bind_input_attachments(
        mut self,
        value: u32,
    ) -> Self {
        self.inner.max_per_stage_descriptor_update_after_bind_input_attachments = value;
        self
    }
    #[inline]
    pub fn max_per_stage_update_after_bind_resources(mut self, value: u32) -> Self {
        self.inner.max_per_stage_update_after_bind_resources = value;
        self
    }
    #[inline]
    pub fn max_descriptor_set_update_after_bind_samplers(mut self, value: u32) -> Self {
        self.inner.max_descriptor_set_update_after_bind_samplers = value;
        self
    }
    #[inline]
    pub fn max_descriptor_set_update_after_bind_uniform_buffers(
        mut self,
        value: u32,
    ) -> Self {
        self.inner.max_descriptor_set_update_after_bind_uniform_buffers = value;
        self
    }
    #[inline]
    pub fn max_descriptor_set_update_after_bind_uniform_buffers_dynamic(
        mut self,
        value: u32,
    ) -> Self {
        self.inner.max_descriptor_set_update_after_bind_uniform_buffers_dynamic = value;
        self
    }
    #[inline]
    pub fn max_descriptor_set_update_after_bind_storage_buffers(
        mut self,
        value: u32,
    ) -> Self {
        self.inner.max_descriptor_set_update_after_bind_storage_buffers = value;
        self
    }
    #[inline]
    pub fn max_descriptor_set_update_after_bind_storage_buffers_dynamic(
        mut self,
        value: u32,
    ) -> Self {
        self.inner.max_descriptor_set_update_after_bind_storage_buffers_dynamic = value;
        self
    }
    #[inline]
    pub fn max_descriptor_set_update_after_bind_sampled_images(
        mut self,
        value: u32,
    ) -> Self {
        self.inner.max_descriptor_set_update_after_bind_sampled_images = value;
        self
    }
    #[inline]
    pub fn max_descriptor_set_update_after_bind_storage_images(
        mut self,
        value: u32,
    ) -> Self {
        self.inner.max_descriptor_set_update_after_bind_storage_images = value;
        self
    }
    #[inline]
    pub fn max_descriptor_set_update_after_bind_input_attachments(
        mut self,
        value: u32,
    ) -> Self {
        self.inner.max_descriptor_set_update_after_bind_input_attachments = value;
        self
    }
    #[inline]
    pub fn supported_depth_resolve_modes(mut self, value: ResolveModeFlags) -> Self {
        self.inner.supported_depth_resolve_modes = value;
        self
    }
    #[inline]
    pub fn supported_stencil_resolve_modes(mut self, value: ResolveModeFlags) -> Self {
        self.inner.supported_stencil_resolve_modes = value;
        self
    }
    #[inline]
    pub fn independent_resolve_none(mut self, value: bool) -> Self {
        self.inner.independent_resolve_none = value as u32;
        self
    }
    #[inline]
    pub fn independent_resolve(mut self, value: bool) -> Self {
        self.inner.independent_resolve = value as u32;
        self
    }
    #[inline]
    pub fn filter_minmax_single_component_formats(mut self, value: bool) -> Self {
        self.inner.filter_minmax_single_component_formats = value as u32;
        self
    }
    #[inline]
    pub fn filter_minmax_image_component_mapping(mut self, value: bool) -> Self {
        self.inner.filter_minmax_image_component_mapping = value as u32;
        self
    }
    #[inline]
    pub fn max_timeline_semaphore_value_difference(mut self, value: u64) -> Self {
        self.inner.max_timeline_semaphore_value_difference = value;
        self
    }
    #[inline]
    pub fn framebuffer_integer_color_sample_counts(
        mut self,
        value: SampleCountFlags,
    ) -> Self {
        self.inner.framebuffer_integer_color_sample_counts = value;
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceVulkan12PropertiesBuilder<'a> {
    type Target = PhysicalDeviceVulkan12Properties;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceVulkan12PropertiesBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceVulkan13Features`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceVulkan13FeaturesBuilder<'a> {
    inner: PhysicalDeviceVulkan13Features,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceVulkan13Features {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceVulkan13FeaturesBuilder<'a> {
        PhysicalDeviceVulkan13FeaturesBuilder {
            inner: PhysicalDeviceVulkan13Features {
                s_type: StructureType::from_raw(53i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceVulkan13FeaturesBuilder<'a> {
    #[inline]
    pub fn robust_image_access(mut self, value: bool) -> Self {
        self.inner.robust_image_access = value as u32;
        self
    }
    #[inline]
    pub fn inline_uniform_block(mut self, value: bool) -> Self {
        self.inner.inline_uniform_block = value as u32;
        self
    }
    #[inline]
    pub fn descriptor_binding_inline_uniform_block_update_after_bind(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.descriptor_binding_inline_uniform_block_update_after_bind = value
            as u32;
        self
    }
    #[inline]
    pub fn pipeline_creation_cache_control(mut self, value: bool) -> Self {
        self.inner.pipeline_creation_cache_control = value as u32;
        self
    }
    #[inline]
    pub fn private_data(mut self, value: bool) -> Self {
        self.inner.private_data = value as u32;
        self
    }
    #[inline]
    pub fn shader_demote_to_helper_invocation(mut self, value: bool) -> Self {
        self.inner.shader_demote_to_helper_invocation = value as u32;
        self
    }
    #[inline]
    pub fn shader_terminate_invocation(mut self, value: bool) -> Self {
        self.inner.shader_terminate_invocation = value as u32;
        self
    }
    #[inline]
    pub fn subgroup_size_control(mut self, value: bool) -> Self {
        self.inner.subgroup_size_control = value as u32;
        self
    }
    #[inline]
    pub fn compute_full_subgroups(mut self, value: bool) -> Self {
        self.inner.compute_full_subgroups = value as u32;
        self
    }
    #[inline]
    pub fn synchronization2(mut self, value: bool) -> Self {
        self.inner.synchronization2 = value as u32;
        self
    }
    #[inline]
    pub fn texture_compression_astc_hdr(mut self, value: bool) -> Self {
        self.inner.texture_compression_astc_hdr = value as u32;
        self
    }
    #[inline]
    pub fn shader_zero_initialize_workgroup_memory(mut self, value: bool) -> Self {
        self.inner.shader_zero_initialize_workgroup_memory = value as u32;
        self
    }
    #[inline]
    pub fn dynamic_rendering(mut self, value: bool) -> Self {
        self.inner.dynamic_rendering = value as u32;
        self
    }
    #[inline]
    pub fn shader_integer_dot_product(mut self, value: bool) -> Self {
        self.inner.shader_integer_dot_product = value as u32;
        self
    }
    #[inline]
    pub fn maintenance4(mut self, value: bool) -> Self {
        self.inner.maintenance4 = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceVulkan13Features`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceVulkan13Features>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceVulkan13FeaturesBuilder<'a> {
    type Target = PhysicalDeviceVulkan13Features;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceVulkan13FeaturesBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceVulkan13Properties`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceVulkan13PropertiesBuilder<'a> {
    inner: PhysicalDeviceVulkan13Properties,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceVulkan13Properties {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceVulkan13PropertiesBuilder<'a> {
        PhysicalDeviceVulkan13PropertiesBuilder {
            inner: PhysicalDeviceVulkan13Properties {
                s_type: StructureType::from_raw(54i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceVulkan13PropertiesBuilder<'a> {
    #[inline]
    pub fn min_subgroup_size(mut self, value: u32) -> Self {
        self.inner.min_subgroup_size = value;
        self
    }
    #[inline]
    pub fn max_subgroup_size(mut self, value: u32) -> Self {
        self.inner.max_subgroup_size = value;
        self
    }
    #[inline]
    pub fn max_compute_workgroup_subgroups(mut self, value: u32) -> Self {
        self.inner.max_compute_workgroup_subgroups = value;
        self
    }
    #[inline]
    pub fn required_subgroup_size_stages(mut self, value: ShaderStageFlags) -> Self {
        self.inner.required_subgroup_size_stages = value;
        self
    }
    #[inline]
    pub fn max_inline_uniform_block_size(mut self, value: u32) -> Self {
        self.inner.max_inline_uniform_block_size = value;
        self
    }
    #[inline]
    pub fn max_per_stage_descriptor_inline_uniform_blocks(mut self, value: u32) -> Self {
        self.inner.max_per_stage_descriptor_inline_uniform_blocks = value;
        self
    }
    #[inline]
    pub fn max_per_stage_descriptor_update_after_bind_inline_uniform_blocks(
        mut self,
        value: u32,
    ) -> Self {
        self.inner.max_per_stage_descriptor_update_after_bind_inline_uniform_blocks = value;
        self
    }
    #[inline]
    pub fn max_descriptor_set_inline_uniform_blocks(mut self, value: u32) -> Self {
        self.inner.max_descriptor_set_inline_uniform_blocks = value;
        self
    }
    #[inline]
    pub fn max_descriptor_set_update_after_bind_inline_uniform_blocks(
        mut self,
        value: u32,
    ) -> Self {
        self.inner.max_descriptor_set_update_after_bind_inline_uniform_blocks = value;
        self
    }
    #[inline]
    pub fn max_inline_uniform_total_size(mut self, value: u32) -> Self {
        self.inner.max_inline_uniform_total_size = value;
        self
    }
    #[inline]
    pub fn integer_dot_product8_bit_unsigned_accelerated(mut self, value: bool) -> Self {
        self.inner.integer_dot_product8_bit_unsigned_accelerated = value as u32;
        self
    }
    #[inline]
    pub fn integer_dot_product8_bit_signed_accelerated(mut self, value: bool) -> Self {
        self.inner.integer_dot_product8_bit_signed_accelerated = value as u32;
        self
    }
    #[inline]
    pub fn integer_dot_product8_bit_mixed_signedness_accelerated(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.integer_dot_product8_bit_mixed_signedness_accelerated = value as u32;
        self
    }
    #[inline]
    pub fn integer_dot_product4x8_bit_packed_unsigned_accelerated(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.integer_dot_product4x8_bit_packed_unsigned_accelerated = value as u32;
        self
    }
    #[inline]
    pub fn integer_dot_product4x8_bit_packed_signed_accelerated(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.integer_dot_product4x8_bit_packed_signed_accelerated = value as u32;
        self
    }
    #[inline]
    pub fn integer_dot_product4x8_bit_packed_mixed_signedness_accelerated(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.integer_dot_product4x8_bit_packed_mixed_signedness_accelerated = value
            as u32;
        self
    }
    #[inline]
    pub fn integer_dot_product16_bit_unsigned_accelerated(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.integer_dot_product16_bit_unsigned_accelerated = value as u32;
        self
    }
    #[inline]
    pub fn integer_dot_product16_bit_signed_accelerated(mut self, value: bool) -> Self {
        self.inner.integer_dot_product16_bit_signed_accelerated = value as u32;
        self
    }
    #[inline]
    pub fn integer_dot_product16_bit_mixed_signedness_accelerated(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.integer_dot_product16_bit_mixed_signedness_accelerated = value as u32;
        self
    }
    #[inline]
    pub fn integer_dot_product32_bit_unsigned_accelerated(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.integer_dot_product32_bit_unsigned_accelerated = value as u32;
        self
    }
    #[inline]
    pub fn integer_dot_product32_bit_signed_accelerated(mut self, value: bool) -> Self {
        self.inner.integer_dot_product32_bit_signed_accelerated = value as u32;
        self
    }
    #[inline]
    pub fn integer_dot_product32_bit_mixed_signedness_accelerated(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.integer_dot_product32_bit_mixed_signedness_accelerated = value as u32;
        self
    }
    #[inline]
    pub fn integer_dot_product64_bit_unsigned_accelerated(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.integer_dot_product64_bit_unsigned_accelerated = value as u32;
        self
    }
    #[inline]
    pub fn integer_dot_product64_bit_signed_accelerated(mut self, value: bool) -> Self {
        self.inner.integer_dot_product64_bit_signed_accelerated = value as u32;
        self
    }
    #[inline]
    pub fn integer_dot_product64_bit_mixed_signedness_accelerated(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.integer_dot_product64_bit_mixed_signedness_accelerated = value as u32;
        self
    }
    #[inline]
    pub fn integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated(
        mut self,
        value: bool,
    ) -> Self {
        self
            .inner
            .integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated = value
            as u32;
        self
    }
    #[inline]
    pub fn integer_dot_product_accumulating_saturating8_bit_signed_accelerated(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.integer_dot_product_accumulating_saturating8_bit_signed_accelerated = value
            as u32;
        self
    }
    #[inline]
    pub fn integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated(
        mut self,
        value: bool,
    ) -> Self {
        self
            .inner
            .integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated = value
            as u32;
        self
    }
    #[inline]
    pub fn integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated(
        mut self,
        value: bool,
    ) -> Self {
        self
            .inner
            .integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated = value
            as u32;
        self
    }
    #[inline]
    pub fn integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated(
        mut self,
        value: bool,
    ) -> Self {
        self
            .inner
            .integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated = value
            as u32;
        self
    }
    #[inline]
    pub fn integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated(
        mut self,
        value: bool,
    ) -> Self {
        self
            .inner
            .integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated = value
            as u32;
        self
    }
    #[inline]
    pub fn integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated(
        mut self,
        value: bool,
    ) -> Self {
        self
            .inner
            .integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated = value
            as u32;
        self
    }
    #[inline]
    pub fn integer_dot_product_accumulating_saturating16_bit_signed_accelerated(
        mut self,
        value: bool,
    ) -> Self {
        self
            .inner
            .integer_dot_product_accumulating_saturating16_bit_signed_accelerated = value
            as u32;
        self
    }
    #[inline]
    pub fn integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated(
        mut self,
        value: bool,
    ) -> Self {
        self
            .inner
            .integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated = value
            as u32;
        self
    }
    #[inline]
    pub fn integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated(
        mut self,
        value: bool,
    ) -> Self {
        self
            .inner
            .integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated = value
            as u32;
        self
    }
    #[inline]
    pub fn integer_dot_product_accumulating_saturating32_bit_signed_accelerated(
        mut self,
        value: bool,
    ) -> Self {
        self
            .inner
            .integer_dot_product_accumulating_saturating32_bit_signed_accelerated = value
            as u32;
        self
    }
    #[inline]
    pub fn integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated(
        mut self,
        value: bool,
    ) -> Self {
        self
            .inner
            .integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated = value
            as u32;
        self
    }
    #[inline]
    pub fn integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated(
        mut self,
        value: bool,
    ) -> Self {
        self
            .inner
            .integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated = value
            as u32;
        self
    }
    #[inline]
    pub fn integer_dot_product_accumulating_saturating64_bit_signed_accelerated(
        mut self,
        value: bool,
    ) -> Self {
        self
            .inner
            .integer_dot_product_accumulating_saturating64_bit_signed_accelerated = value
            as u32;
        self
    }
    #[inline]
    pub fn integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated(
        mut self,
        value: bool,
    ) -> Self {
        self
            .inner
            .integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated = value
            as u32;
        self
    }
    #[inline]
    pub fn storage_texel_buffer_offset_alignment_bytes(mut self, value: u64) -> Self {
        self.inner.storage_texel_buffer_offset_alignment_bytes = value;
        self
    }
    #[inline]
    pub fn storage_texel_buffer_offset_single_texel_alignment(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.storage_texel_buffer_offset_single_texel_alignment = value as u32;
        self
    }
    #[inline]
    pub fn uniform_texel_buffer_offset_alignment_bytes(mut self, value: u64) -> Self {
        self.inner.uniform_texel_buffer_offset_alignment_bytes = value;
        self
    }
    #[inline]
    pub fn uniform_texel_buffer_offset_single_texel_alignment(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.uniform_texel_buffer_offset_single_texel_alignment = value as u32;
        self
    }
    #[inline]
    pub fn max_buffer_size(mut self, value: u64) -> Self {
        self.inner.max_buffer_size = value;
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceVulkan13PropertiesBuilder<'a> {
    type Target = PhysicalDeviceVulkan13Properties;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceVulkan13PropertiesBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceVulkan14Features`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceVulkan14FeaturesBuilder<'a> {
    inner: PhysicalDeviceVulkan14Features,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceVulkan14Features {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceVulkan14FeaturesBuilder<'a> {
        PhysicalDeviceVulkan14FeaturesBuilder {
            inner: PhysicalDeviceVulkan14Features {
                s_type: StructureType::from_raw(55i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceVulkan14FeaturesBuilder<'a> {
    #[inline]
    pub fn global_priority_query(mut self, value: bool) -> Self {
        self.inner.global_priority_query = value as u32;
        self
    }
    #[inline]
    pub fn shader_subgroup_rotate(mut self, value: bool) -> Self {
        self.inner.shader_subgroup_rotate = value as u32;
        self
    }
    #[inline]
    pub fn shader_subgroup_rotate_clustered(mut self, value: bool) -> Self {
        self.inner.shader_subgroup_rotate_clustered = value as u32;
        self
    }
    #[inline]
    pub fn shader_float_controls2(mut self, value: bool) -> Self {
        self.inner.shader_float_controls2 = value as u32;
        self
    }
    #[inline]
    pub fn shader_expect_assume(mut self, value: bool) -> Self {
        self.inner.shader_expect_assume = value as u32;
        self
    }
    #[inline]
    pub fn rectangular_lines(mut self, value: bool) -> Self {
        self.inner.rectangular_lines = value as u32;
        self
    }
    #[inline]
    pub fn bresenham_lines(mut self, value: bool) -> Self {
        self.inner.bresenham_lines = value as u32;
        self
    }
    #[inline]
    pub fn smooth_lines(mut self, value: bool) -> Self {
        self.inner.smooth_lines = value as u32;
        self
    }
    #[inline]
    pub fn stippled_rectangular_lines(mut self, value: bool) -> Self {
        self.inner.stippled_rectangular_lines = value as u32;
        self
    }
    #[inline]
    pub fn stippled_bresenham_lines(mut self, value: bool) -> Self {
        self.inner.stippled_bresenham_lines = value as u32;
        self
    }
    #[inline]
    pub fn stippled_smooth_lines(mut self, value: bool) -> Self {
        self.inner.stippled_smooth_lines = value as u32;
        self
    }
    #[inline]
    pub fn vertex_attribute_instance_rate_divisor(mut self, value: bool) -> Self {
        self.inner.vertex_attribute_instance_rate_divisor = value as u32;
        self
    }
    #[inline]
    pub fn vertex_attribute_instance_rate_zero_divisor(mut self, value: bool) -> Self {
        self.inner.vertex_attribute_instance_rate_zero_divisor = value as u32;
        self
    }
    #[inline]
    pub fn index_type_uint8(mut self, value: bool) -> Self {
        self.inner.index_type_uint8 = value as u32;
        self
    }
    #[inline]
    pub fn dynamic_rendering_local_read(mut self, value: bool) -> Self {
        self.inner.dynamic_rendering_local_read = value as u32;
        self
    }
    #[inline]
    pub fn maintenance5(mut self, value: bool) -> Self {
        self.inner.maintenance5 = value as u32;
        self
    }
    #[inline]
    pub fn maintenance6(mut self, value: bool) -> Self {
        self.inner.maintenance6 = value as u32;
        self
    }
    #[inline]
    pub fn pipeline_protected_access(mut self, value: bool) -> Self {
        self.inner.pipeline_protected_access = value as u32;
        self
    }
    #[inline]
    pub fn pipeline_robustness(mut self, value: bool) -> Self {
        self.inner.pipeline_robustness = value as u32;
        self
    }
    #[inline]
    pub fn host_image_copy(mut self, value: bool) -> Self {
        self.inner.host_image_copy = value as u32;
        self
    }
    #[inline]
    pub fn push_descriptor(mut self, value: bool) -> Self {
        self.inner.push_descriptor = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceVulkan14Features`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceVulkan14Features>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceVulkan14FeaturesBuilder<'a> {
    type Target = PhysicalDeviceVulkan14Features;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceVulkan14FeaturesBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceVulkan14Properties`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceVulkan14PropertiesBuilder<'a> {
    inner: PhysicalDeviceVulkan14Properties,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceVulkan14Properties {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceVulkan14PropertiesBuilder<'a> {
        PhysicalDeviceVulkan14PropertiesBuilder {
            inner: PhysicalDeviceVulkan14Properties {
                s_type: StructureType::from_raw(56i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceVulkan14PropertiesBuilder<'a> {
    #[inline]
    pub fn line_sub_pixel_precision_bits(mut self, value: u32) -> Self {
        self.inner.line_sub_pixel_precision_bits = value;
        self
    }
    #[inline]
    pub fn max_vertex_attrib_divisor(mut self, value: u32) -> Self {
        self.inner.max_vertex_attrib_divisor = value;
        self
    }
    #[inline]
    pub fn supports_non_zero_first_instance(mut self, value: bool) -> Self {
        self.inner.supports_non_zero_first_instance = value as u32;
        self
    }
    #[inline]
    pub fn max_push_descriptors(mut self, value: u32) -> Self {
        self.inner.max_push_descriptors = value;
        self
    }
    #[inline]
    pub fn dynamic_rendering_local_read_depth_stencil_attachments(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.dynamic_rendering_local_read_depth_stencil_attachments = value as u32;
        self
    }
    #[inline]
    pub fn dynamic_rendering_local_read_multisampled_attachments(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.dynamic_rendering_local_read_multisampled_attachments = value as u32;
        self
    }
    #[inline]
    pub fn early_fragment_multisample_coverage_after_sample_counting(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.early_fragment_multisample_coverage_after_sample_counting = value
            as u32;
        self
    }
    #[inline]
    pub fn early_fragment_sample_mask_test_before_sample_counting(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.early_fragment_sample_mask_test_before_sample_counting = value as u32;
        self
    }
    #[inline]
    pub fn depth_stencil_swizzle_one_support(mut self, value: bool) -> Self {
        self.inner.depth_stencil_swizzle_one_support = value as u32;
        self
    }
    #[inline]
    pub fn polygon_mode_point_size(mut self, value: bool) -> Self {
        self.inner.polygon_mode_point_size = value as u32;
        self
    }
    #[inline]
    pub fn non_strict_single_pixel_wide_lines_use_parallelogram(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.non_strict_single_pixel_wide_lines_use_parallelogram = value as u32;
        self
    }
    #[inline]
    pub fn non_strict_wide_lines_use_parallelogram(mut self, value: bool) -> Self {
        self.inner.non_strict_wide_lines_use_parallelogram = value as u32;
        self
    }
    #[inline]
    pub fn block_texel_view_compatible_multiple_layers(mut self, value: bool) -> Self {
        self.inner.block_texel_view_compatible_multiple_layers = value as u32;
        self
    }
    #[inline]
    pub fn max_combined_image_sampler_descriptor_count(mut self, value: u32) -> Self {
        self.inner.max_combined_image_sampler_descriptor_count = value;
        self
    }
    #[inline]
    pub fn fragment_shading_rate_clamp_combiner_inputs(mut self, value: bool) -> Self {
        self.inner.fragment_shading_rate_clamp_combiner_inputs = value as u32;
        self
    }
    #[inline]
    pub fn default_robustness_storage_buffers(
        mut self,
        value: PipelineRobustnessBufferBehavior,
    ) -> Self {
        self.inner.default_robustness_storage_buffers = value;
        self
    }
    #[inline]
    pub fn default_robustness_uniform_buffers(
        mut self,
        value: PipelineRobustnessBufferBehavior,
    ) -> Self {
        self.inner.default_robustness_uniform_buffers = value;
        self
    }
    #[inline]
    pub fn default_robustness_vertex_inputs(
        mut self,
        value: PipelineRobustnessBufferBehavior,
    ) -> Self {
        self.inner.default_robustness_vertex_inputs = value;
        self
    }
    #[inline]
    pub fn default_robustness_images(
        mut self,
        value: PipelineRobustnessImageBehavior,
    ) -> Self {
        self.inner.default_robustness_images = value;
        self
    }
    #[inline]
    pub fn copy_src_layout_count(mut self, value: u32) -> Self {
        self.inner.copy_src_layout_count = value;
        self
    }
    #[inline]
    pub fn copy_src_layouts(mut self, slice: &'a mut [ImageLayout]) -> Self {
        self.inner.copy_src_layout_count = slice.len() as u32;
        self.inner.p_copy_src_layouts = slice.as_mut_ptr();
        self
    }
    #[inline]
    pub fn copy_dst_layout_count(mut self, value: u32) -> Self {
        self.inner.copy_dst_layout_count = value;
        self
    }
    #[inline]
    pub fn copy_dst_layouts(mut self, slice: &'a mut [ImageLayout]) -> Self {
        self.inner.copy_dst_layout_count = slice.len() as u32;
        self.inner.p_copy_dst_layouts = slice.as_mut_ptr();
        self
    }
    #[inline]
    pub fn optimal_tiling_layout_uuid(
        mut self,
        value: [u8; UUID_SIZE as usize],
    ) -> Self {
        self.inner.optimal_tiling_layout_uuid = value;
        self
    }
    #[inline]
    pub fn identical_memory_type_requirements(mut self, value: bool) -> Self {
        self.inner.identical_memory_type_requirements = value as u32;
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceVulkan14PropertiesBuilder<'a> {
    type Target = PhysicalDeviceVulkan14Properties;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceVulkan14PropertiesBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PipelineCompilerControlCreateInfoAMD`] with lifetime-tied pNext safety.
pub struct PipelineCompilerControlCreateInfoAMDBuilder<'a> {
    inner: PipelineCompilerControlCreateInfoAMD,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PipelineCompilerControlCreateInfoAMD {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PipelineCompilerControlCreateInfoAMDBuilder<'a> {
        PipelineCompilerControlCreateInfoAMDBuilder {
            inner: PipelineCompilerControlCreateInfoAMD {
                s_type: StructureType::from_raw(1000183000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PipelineCompilerControlCreateInfoAMDBuilder<'a> {
    #[inline]
    pub fn compiler_control_flags(
        mut self,
        value: PipelineCompilerControlFlagsAMD,
    ) -> Self {
        self.inner.compiler_control_flags = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PipelineCompilerControlCreateInfoAMD`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPipelineCompilerControlCreateInfoAMD>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for PipelineCompilerControlCreateInfoAMDBuilder<'a> {
    type Target = PipelineCompilerControlCreateInfoAMD;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PipelineCompilerControlCreateInfoAMDBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceCoherentMemoryFeaturesAMD`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceCoherentMemoryFeaturesAMDBuilder<'a> {
    inner: PhysicalDeviceCoherentMemoryFeaturesAMD,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceCoherentMemoryFeaturesAMD {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceCoherentMemoryFeaturesAMDBuilder<'a> {
        PhysicalDeviceCoherentMemoryFeaturesAMDBuilder {
            inner: PhysicalDeviceCoherentMemoryFeaturesAMD {
                s_type: StructureType::from_raw(1000229000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceCoherentMemoryFeaturesAMDBuilder<'a> {
    #[inline]
    pub fn device_coherent_memory(mut self, value: bool) -> Self {
        self.inner.device_coherent_memory = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceCoherentMemoryFeaturesAMD`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceCoherentMemoryFeaturesAMD>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceCoherentMemoryFeaturesAMDBuilder<'a> {
    type Target = PhysicalDeviceCoherentMemoryFeaturesAMD;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceCoherentMemoryFeaturesAMDBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`FaultData`] with lifetime-tied pNext safety.
pub struct FaultDataBuilder<'a> {
    inner: FaultData,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl FaultData {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> FaultDataBuilder<'a> {
        FaultDataBuilder {
            inner: FaultData {
                s_type: StructureType::from_raw(1000298007i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> FaultDataBuilder<'a> {
    #[inline]
    pub fn fault_level(mut self, value: FaultLevel) -> Self {
        self.inner.fault_level = value;
        self
    }
    #[inline]
    pub fn fault_type(mut self, value: FaultType) -> Self {
        self.inner.fault_type = value;
        self
    }
}
impl<'a> core::ops::Deref for FaultDataBuilder<'a> {
    type Target = FaultData;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for FaultDataBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`FaultCallbackInfo`] with lifetime-tied pNext safety.
pub struct FaultCallbackInfoBuilder<'a> {
    inner: FaultCallbackInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl FaultCallbackInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> FaultCallbackInfoBuilder<'a> {
        FaultCallbackInfoBuilder {
            inner: FaultCallbackInfo {
                s_type: StructureType::from_raw(1000298008i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> FaultCallbackInfoBuilder<'a> {
    #[inline]
    pub fn fault_count(mut self, value: u32) -> Self {
        self.inner.fault_count = value;
        self
    }
    #[inline]
    pub fn faults(mut self, slice: &'a mut [FaultData]) -> Self {
        self.inner.fault_count = slice.len() as u32;
        self.inner.p_faults = slice.as_mut_ptr();
        self
    }
    #[inline]
    pub fn pfn_fault_callback(mut self, value: PFN_vkFaultCallbackFunction) -> Self {
        self.inner.pfn_fault_callback = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`FaultCallbackInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsFaultCallbackInfo>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for FaultCallbackInfoBuilder<'a> {
    type Target = FaultCallbackInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for FaultCallbackInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceToolProperties`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceToolPropertiesBuilder<'a> {
    inner: PhysicalDeviceToolProperties,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceToolProperties {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceToolPropertiesBuilder<'a> {
        PhysicalDeviceToolPropertiesBuilder {
            inner: PhysicalDeviceToolProperties {
                s_type: StructureType::from_raw(1000245000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceToolPropertiesBuilder<'a> {
    #[inline]
    pub fn name(
        mut self,
        value: crate::StringArray<{ MAX_EXTENSION_NAME_SIZE as usize }>,
    ) -> Self {
        self.inner.name = value;
        self
    }
    #[inline]
    pub fn version(
        mut self,
        value: crate::StringArray<{ MAX_EXTENSION_NAME_SIZE as usize }>,
    ) -> Self {
        self.inner.version = value;
        self
    }
    #[inline]
    pub fn purposes(mut self, value: ToolPurposeFlags) -> Self {
        self.inner.purposes = value;
        self
    }
    #[inline]
    pub fn description(
        mut self,
        value: crate::StringArray<{ MAX_DESCRIPTION_SIZE as usize }>,
    ) -> Self {
        self.inner.description = value;
        self
    }
    #[inline]
    pub fn layer(
        mut self,
        value: crate::StringArray<{ MAX_EXTENSION_NAME_SIZE as usize }>,
    ) -> Self {
        self.inner.layer = value;
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceToolPropertiesBuilder<'a> {
    type Target = PhysicalDeviceToolProperties;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceToolPropertiesBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`SamplerCustomBorderColorCreateInfoEXT`] with lifetime-tied pNext safety.
pub struct SamplerCustomBorderColorCreateInfoEXTBuilder<'a> {
    inner: SamplerCustomBorderColorCreateInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl SamplerCustomBorderColorCreateInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> SamplerCustomBorderColorCreateInfoEXTBuilder<'a> {
        SamplerCustomBorderColorCreateInfoEXTBuilder {
            inner: SamplerCustomBorderColorCreateInfoEXT {
                s_type: StructureType::from_raw(1000287000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> SamplerCustomBorderColorCreateInfoEXTBuilder<'a> {
    #[inline]
    pub fn custom_border_color(mut self, value: ClearColorValue) -> Self {
        self.inner.custom_border_color = value;
        self
    }
    #[inline]
    pub fn format(mut self, value: Format) -> Self {
        self.inner.format = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`SamplerCustomBorderColorCreateInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsSamplerCustomBorderColorCreateInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for SamplerCustomBorderColorCreateInfoEXTBuilder<'a> {
    type Target = SamplerCustomBorderColorCreateInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for SamplerCustomBorderColorCreateInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceCustomBorderColorPropertiesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceCustomBorderColorPropertiesEXTBuilder<'a> {
    inner: PhysicalDeviceCustomBorderColorPropertiesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceCustomBorderColorPropertiesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceCustomBorderColorPropertiesEXTBuilder<'a> {
        PhysicalDeviceCustomBorderColorPropertiesEXTBuilder {
            inner: PhysicalDeviceCustomBorderColorPropertiesEXT {
                s_type: StructureType::from_raw(1000287001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceCustomBorderColorPropertiesEXTBuilder<'a> {
    #[inline]
    pub fn max_custom_border_color_samplers(mut self, value: u32) -> Self {
        self.inner.max_custom_border_color_samplers = value;
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceCustomBorderColorPropertiesEXTBuilder<'a> {
    type Target = PhysicalDeviceCustomBorderColorPropertiesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceCustomBorderColorPropertiesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceCustomBorderColorFeaturesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceCustomBorderColorFeaturesEXTBuilder<'a> {
    inner: PhysicalDeviceCustomBorderColorFeaturesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceCustomBorderColorFeaturesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceCustomBorderColorFeaturesEXTBuilder<'a> {
        PhysicalDeviceCustomBorderColorFeaturesEXTBuilder {
            inner: PhysicalDeviceCustomBorderColorFeaturesEXT {
                s_type: StructureType::from_raw(1000287002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceCustomBorderColorFeaturesEXTBuilder<'a> {
    #[inline]
    pub fn custom_border_colors(mut self, value: bool) -> Self {
        self.inner.custom_border_colors = value as u32;
        self
    }
    #[inline]
    pub fn custom_border_color_without_format(mut self, value: bool) -> Self {
        self.inner.custom_border_color_without_format = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceCustomBorderColorFeaturesEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceCustomBorderColorFeaturesEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceCustomBorderColorFeaturesEXTBuilder<'a> {
    type Target = PhysicalDeviceCustomBorderColorFeaturesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceCustomBorderColorFeaturesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`SamplerBorderColorComponentMappingCreateInfoEXT`] with lifetime-tied pNext safety.
pub struct SamplerBorderColorComponentMappingCreateInfoEXTBuilder<'a> {
    inner: SamplerBorderColorComponentMappingCreateInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl SamplerBorderColorComponentMappingCreateInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> SamplerBorderColorComponentMappingCreateInfoEXTBuilder<'a> {
        SamplerBorderColorComponentMappingCreateInfoEXTBuilder {
            inner: SamplerBorderColorComponentMappingCreateInfoEXT {
                s_type: StructureType::from_raw(1000411001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> SamplerBorderColorComponentMappingCreateInfoEXTBuilder<'a> {
    #[inline]
    pub fn components(mut self, value: ComponentMapping) -> Self {
        self.inner.components = value;
        self
    }
    #[inline]
    pub fn srgb(mut self, value: bool) -> Self {
        self.inner.srgb = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`SamplerBorderColorComponentMappingCreateInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsSamplerBorderColorComponentMappingCreateInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref
for SamplerBorderColorComponentMappingCreateInfoEXTBuilder<'a> {
    type Target = SamplerBorderColorComponentMappingCreateInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for SamplerBorderColorComponentMappingCreateInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceBorderColorSwizzleFeaturesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceBorderColorSwizzleFeaturesEXTBuilder<'a> {
    inner: PhysicalDeviceBorderColorSwizzleFeaturesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceBorderColorSwizzleFeaturesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceBorderColorSwizzleFeaturesEXTBuilder<'a> {
        PhysicalDeviceBorderColorSwizzleFeaturesEXTBuilder {
            inner: PhysicalDeviceBorderColorSwizzleFeaturesEXT {
                s_type: StructureType::from_raw(1000411000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceBorderColorSwizzleFeaturesEXTBuilder<'a> {
    #[inline]
    pub fn border_color_swizzle(mut self, value: bool) -> Self {
        self.inner.border_color_swizzle = value as u32;
        self
    }
    #[inline]
    pub fn border_color_swizzle_from_image(mut self, value: bool) -> Self {
        self.inner.border_color_swizzle_from_image = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceBorderColorSwizzleFeaturesEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceBorderColorSwizzleFeaturesEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceBorderColorSwizzleFeaturesEXTBuilder<'a> {
    type Target = PhysicalDeviceBorderColorSwizzleFeaturesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceBorderColorSwizzleFeaturesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`AccelerationStructureGeometryTrianglesDataKHR`] with lifetime-tied pNext safety.
pub struct AccelerationStructureGeometryTrianglesDataKHRBuilder<'a> {
    inner: AccelerationStructureGeometryTrianglesDataKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl AccelerationStructureGeometryTrianglesDataKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> AccelerationStructureGeometryTrianglesDataKHRBuilder<'a> {
        AccelerationStructureGeometryTrianglesDataKHRBuilder {
            inner: AccelerationStructureGeometryTrianglesDataKHR {
                s_type: StructureType::from_raw(1000150005i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> AccelerationStructureGeometryTrianglesDataKHRBuilder<'a> {
    #[inline]
    pub fn vertex_format(mut self, value: Format) -> Self {
        self.inner.vertex_format = value;
        self
    }
    #[inline]
    pub fn vertex_data(mut self, value: DeviceOrHostAddressConstKHR) -> Self {
        self.inner.vertex_data = value;
        self
    }
    #[inline]
    pub fn vertex_stride(mut self, value: u64) -> Self {
        self.inner.vertex_stride = value;
        self
    }
    #[inline]
    pub fn max_vertex(mut self, value: u32) -> Self {
        self.inner.max_vertex = value;
        self
    }
    #[inline]
    pub fn index_type(mut self, value: IndexType) -> Self {
        self.inner.index_type = value;
        self
    }
    #[inline]
    pub fn index_data(mut self, value: DeviceOrHostAddressConstKHR) -> Self {
        self.inner.index_data = value;
        self
    }
    #[inline]
    pub fn transform_data(mut self, value: DeviceOrHostAddressConstKHR) -> Self {
        self.inner.transform_data = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`AccelerationStructureGeometryTrianglesDataKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsAccelerationStructureGeometryTrianglesDataKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for AccelerationStructureGeometryTrianglesDataKHRBuilder<'a> {
    type Target = AccelerationStructureGeometryTrianglesDataKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for AccelerationStructureGeometryTrianglesDataKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`AccelerationStructureGeometryAabbsDataKHR`] with lifetime-tied pNext safety.
pub struct AccelerationStructureGeometryAabbsDataKHRBuilder<'a> {
    inner: AccelerationStructureGeometryAabbsDataKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl AccelerationStructureGeometryAabbsDataKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> AccelerationStructureGeometryAabbsDataKHRBuilder<'a> {
        AccelerationStructureGeometryAabbsDataKHRBuilder {
            inner: AccelerationStructureGeometryAabbsDataKHR {
                s_type: StructureType::from_raw(1000150003i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> AccelerationStructureGeometryAabbsDataKHRBuilder<'a> {
    #[inline]
    pub fn data(mut self, value: DeviceOrHostAddressConstKHR) -> Self {
        self.inner.data = value;
        self
    }
    #[inline]
    pub fn stride(mut self, value: u64) -> Self {
        self.inner.stride = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`AccelerationStructureGeometryAabbsDataKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsAccelerationStructureGeometryAabbsDataKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for AccelerationStructureGeometryAabbsDataKHRBuilder<'a> {
    type Target = AccelerationStructureGeometryAabbsDataKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for AccelerationStructureGeometryAabbsDataKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`AccelerationStructureGeometryInstancesDataKHR`] with lifetime-tied pNext safety.
pub struct AccelerationStructureGeometryInstancesDataKHRBuilder<'a> {
    inner: AccelerationStructureGeometryInstancesDataKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl AccelerationStructureGeometryInstancesDataKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> AccelerationStructureGeometryInstancesDataKHRBuilder<'a> {
        AccelerationStructureGeometryInstancesDataKHRBuilder {
            inner: AccelerationStructureGeometryInstancesDataKHR {
                s_type: StructureType::from_raw(1000150004i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> AccelerationStructureGeometryInstancesDataKHRBuilder<'a> {
    #[inline]
    pub fn array_of_pointers(mut self, value: bool) -> Self {
        self.inner.array_of_pointers = value as u32;
        self
    }
    #[inline]
    pub fn data(mut self, value: DeviceOrHostAddressConstKHR) -> Self {
        self.inner.data = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`AccelerationStructureGeometryInstancesDataKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsAccelerationStructureGeometryInstancesDataKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for AccelerationStructureGeometryInstancesDataKHRBuilder<'a> {
    type Target = AccelerationStructureGeometryInstancesDataKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for AccelerationStructureGeometryInstancesDataKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`AccelerationStructureGeometryLinearSweptSpheresDataNV`] with lifetime-tied pNext safety.
pub struct AccelerationStructureGeometryLinearSweptSpheresDataNVBuilder<'a> {
    inner: AccelerationStructureGeometryLinearSweptSpheresDataNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl AccelerationStructureGeometryLinearSweptSpheresDataNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> AccelerationStructureGeometryLinearSweptSpheresDataNVBuilder<
        'a,
    > {
        AccelerationStructureGeometryLinearSweptSpheresDataNVBuilder {
            inner: AccelerationStructureGeometryLinearSweptSpheresDataNV {
                s_type: StructureType::from_raw(1000429009i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> AccelerationStructureGeometryLinearSweptSpheresDataNVBuilder<'a> {
    #[inline]
    pub fn vertex_format(mut self, value: Format) -> Self {
        self.inner.vertex_format = value;
        self
    }
    #[inline]
    pub fn vertex_data(mut self, value: DeviceOrHostAddressConstKHR) -> Self {
        self.inner.vertex_data = value;
        self
    }
    #[inline]
    pub fn vertex_stride(mut self, value: u64) -> Self {
        self.inner.vertex_stride = value;
        self
    }
    #[inline]
    pub fn radius_format(mut self, value: Format) -> Self {
        self.inner.radius_format = value;
        self
    }
    #[inline]
    pub fn radius_data(mut self, value: DeviceOrHostAddressConstKHR) -> Self {
        self.inner.radius_data = value;
        self
    }
    #[inline]
    pub fn radius_stride(mut self, value: u64) -> Self {
        self.inner.radius_stride = value;
        self
    }
    #[inline]
    pub fn index_type(mut self, value: IndexType) -> Self {
        self.inner.index_type = value;
        self
    }
    #[inline]
    pub fn index_data(mut self, value: DeviceOrHostAddressConstKHR) -> Self {
        self.inner.index_data = value;
        self
    }
    #[inline]
    pub fn index_stride(mut self, value: u64) -> Self {
        self.inner.index_stride = value;
        self
    }
    #[inline]
    pub fn indexing_mode(mut self, value: RayTracingLssIndexingModeNV) -> Self {
        self.inner.indexing_mode = value;
        self
    }
    #[inline]
    pub fn end_caps_mode(mut self, value: RayTracingLssPrimitiveEndCapsModeNV) -> Self {
        self.inner.end_caps_mode = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`AccelerationStructureGeometryLinearSweptSpheresDataNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsAccelerationStructureGeometryLinearSweptSpheresDataNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref
for AccelerationStructureGeometryLinearSweptSpheresDataNVBuilder<'a> {
    type Target = AccelerationStructureGeometryLinearSweptSpheresDataNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for AccelerationStructureGeometryLinearSweptSpheresDataNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`AccelerationStructureGeometrySpheresDataNV`] with lifetime-tied pNext safety.
pub struct AccelerationStructureGeometrySpheresDataNVBuilder<'a> {
    inner: AccelerationStructureGeometrySpheresDataNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl AccelerationStructureGeometrySpheresDataNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> AccelerationStructureGeometrySpheresDataNVBuilder<'a> {
        AccelerationStructureGeometrySpheresDataNVBuilder {
            inner: AccelerationStructureGeometrySpheresDataNV {
                s_type: StructureType::from_raw(1000429010i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> AccelerationStructureGeometrySpheresDataNVBuilder<'a> {
    #[inline]
    pub fn vertex_format(mut self, value: Format) -> Self {
        self.inner.vertex_format = value;
        self
    }
    #[inline]
    pub fn vertex_data(mut self, value: DeviceOrHostAddressConstKHR) -> Self {
        self.inner.vertex_data = value;
        self
    }
    #[inline]
    pub fn vertex_stride(mut self, value: u64) -> Self {
        self.inner.vertex_stride = value;
        self
    }
    #[inline]
    pub fn radius_format(mut self, value: Format) -> Self {
        self.inner.radius_format = value;
        self
    }
    #[inline]
    pub fn radius_data(mut self, value: DeviceOrHostAddressConstKHR) -> Self {
        self.inner.radius_data = value;
        self
    }
    #[inline]
    pub fn radius_stride(mut self, value: u64) -> Self {
        self.inner.radius_stride = value;
        self
    }
    #[inline]
    pub fn index_type(mut self, value: IndexType) -> Self {
        self.inner.index_type = value;
        self
    }
    #[inline]
    pub fn index_data(mut self, value: DeviceOrHostAddressConstKHR) -> Self {
        self.inner.index_data = value;
        self
    }
    #[inline]
    pub fn index_stride(mut self, value: u64) -> Self {
        self.inner.index_stride = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`AccelerationStructureGeometrySpheresDataNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsAccelerationStructureGeometrySpheresDataNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for AccelerationStructureGeometrySpheresDataNVBuilder<'a> {
    type Target = AccelerationStructureGeometrySpheresDataNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for AccelerationStructureGeometrySpheresDataNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`AccelerationStructureGeometryKHR`] with lifetime-tied pNext safety.
pub struct AccelerationStructureGeometryKHRBuilder<'a> {
    inner: AccelerationStructureGeometryKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl AccelerationStructureGeometryKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> AccelerationStructureGeometryKHRBuilder<'a> {
        AccelerationStructureGeometryKHRBuilder {
            inner: AccelerationStructureGeometryKHR {
                s_type: StructureType::from_raw(1000150006i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> AccelerationStructureGeometryKHRBuilder<'a> {
    #[inline]
    pub fn geometry_type(mut self, value: GeometryTypeKHR) -> Self {
        self.inner.geometry_type = value;
        self
    }
    #[inline]
    pub fn geometry(mut self, value: AccelerationStructureGeometryDataKHR) -> Self {
        self.inner.geometry = value;
        self
    }
    #[inline]
    pub fn flags(mut self, value: GeometryFlagsKHR) -> Self {
        self.inner.flags = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`AccelerationStructureGeometryKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsAccelerationStructureGeometryKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for AccelerationStructureGeometryKHRBuilder<'a> {
    type Target = AccelerationStructureGeometryKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for AccelerationStructureGeometryKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`AccelerationStructureBuildGeometryInfoKHR`] with lifetime-tied pNext safety.
pub struct AccelerationStructureBuildGeometryInfoKHRBuilder<'a> {
    inner: AccelerationStructureBuildGeometryInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl AccelerationStructureBuildGeometryInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> AccelerationStructureBuildGeometryInfoKHRBuilder<'a> {
        AccelerationStructureBuildGeometryInfoKHRBuilder {
            inner: AccelerationStructureBuildGeometryInfoKHR {
                s_type: StructureType::from_raw(1000150000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> AccelerationStructureBuildGeometryInfoKHRBuilder<'a> {
    #[inline]
    pub fn r#type(mut self, value: AccelerationStructureTypeKHR) -> Self {
        self.inner.r#type = value;
        self
    }
    #[inline]
    pub fn flags(mut self, value: BuildAccelerationStructureFlagsKHR) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn mode(mut self, value: BuildAccelerationStructureModeKHR) -> Self {
        self.inner.mode = value;
        self
    }
    #[inline]
    pub fn src_acceleration_structure(
        mut self,
        value: AccelerationStructureKHR,
    ) -> Self {
        self.inner.src_acceleration_structure = value;
        self
    }
    #[inline]
    pub fn dst_acceleration_structure(
        mut self,
        value: AccelerationStructureKHR,
    ) -> Self {
        self.inner.dst_acceleration_structure = value;
        self
    }
    #[inline]
    pub fn geometry_count(mut self, value: u32) -> Self {
        self.inner.geometry_count = value;
        self
    }
    #[inline]
    pub fn geometries(mut self, slice: &'a [AccelerationStructureGeometryKHR]) -> Self {
        self.inner.geometry_count = slice.len() as u32;
        self.inner.p_geometries = slice.as_ptr();
        self
    }
    #[inline]
    pub fn pp_geometries(
        mut self,
        value: *const *const AccelerationStructureGeometryKHR,
    ) -> Self {
        self.inner.pp_geometries = value;
        self
    }
    #[inline]
    pub fn scratch_data(mut self, value: DeviceOrHostAddressKHR) -> Self {
        self.inner.scratch_data = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`AccelerationStructureBuildGeometryInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsAccelerationStructureBuildGeometryInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for AccelerationStructureBuildGeometryInfoKHRBuilder<'a> {
    type Target = AccelerationStructureBuildGeometryInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for AccelerationStructureBuildGeometryInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`AccelerationStructureBuildRangeInfoKHR`].
pub struct AccelerationStructureBuildRangeInfoKHRBuilder {
    inner: AccelerationStructureBuildRangeInfoKHR,
}
impl AccelerationStructureBuildRangeInfoKHR {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> AccelerationStructureBuildRangeInfoKHRBuilder {
        AccelerationStructureBuildRangeInfoKHRBuilder {
            inner: AccelerationStructureBuildRangeInfoKHR {
                ..Default::default()
            },
        }
    }
}
impl AccelerationStructureBuildRangeInfoKHRBuilder {
    #[inline]
    pub fn primitive_count(mut self, value: u32) -> Self {
        self.inner.primitive_count = value;
        self
    }
    #[inline]
    pub fn primitive_offset(mut self, value: u32) -> Self {
        self.inner.primitive_offset = value;
        self
    }
    #[inline]
    pub fn first_vertex(mut self, value: u32) -> Self {
        self.inner.first_vertex = value;
        self
    }
    #[inline]
    pub fn transform_offset(mut self, value: u32) -> Self {
        self.inner.transform_offset = value;
        self
    }
}
impl core::ops::Deref for AccelerationStructureBuildRangeInfoKHRBuilder {
    type Target = AccelerationStructureBuildRangeInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for AccelerationStructureBuildRangeInfoKHRBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`AccelerationStructureCreateInfoKHR`] with lifetime-tied pNext safety.
pub struct AccelerationStructureCreateInfoKHRBuilder<'a> {
    inner: AccelerationStructureCreateInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl AccelerationStructureCreateInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> AccelerationStructureCreateInfoKHRBuilder<'a> {
        AccelerationStructureCreateInfoKHRBuilder {
            inner: AccelerationStructureCreateInfoKHR {
                s_type: StructureType::from_raw(1000150017i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> AccelerationStructureCreateInfoKHRBuilder<'a> {
    #[inline]
    pub fn create_flags(mut self, value: AccelerationStructureCreateFlagsKHR) -> Self {
        self.inner.create_flags = value;
        self
    }
    #[inline]
    pub fn buffer(mut self, value: Buffer) -> Self {
        self.inner.buffer = value;
        self
    }
    #[inline]
    pub fn offset(mut self, value: u64) -> Self {
        self.inner.offset = value;
        self
    }
    #[inline]
    pub fn size(mut self, value: u64) -> Self {
        self.inner.size = value;
        self
    }
    #[inline]
    pub fn r#type(mut self, value: AccelerationStructureTypeKHR) -> Self {
        self.inner.r#type = value;
        self
    }
    #[inline]
    pub fn device_address(mut self, value: u64) -> Self {
        self.inner.device_address = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`AccelerationStructureCreateInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsAccelerationStructureCreateInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for AccelerationStructureCreateInfoKHRBuilder<'a> {
    type Target = AccelerationStructureCreateInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for AccelerationStructureCreateInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`AabbPositionsKHR`].
pub struct AabbPositionsKHRBuilder {
    inner: AabbPositionsKHR,
}
impl AabbPositionsKHR {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> AabbPositionsKHRBuilder {
        AabbPositionsKHRBuilder {
            inner: AabbPositionsKHR {
                ..Default::default()
            },
        }
    }
}
impl AabbPositionsKHRBuilder {
    #[inline]
    pub fn min_x(mut self, value: f32) -> Self {
        self.inner.min_x = value;
        self
    }
    #[inline]
    pub fn min_y(mut self, value: f32) -> Self {
        self.inner.min_y = value;
        self
    }
    #[inline]
    pub fn min_z(mut self, value: f32) -> Self {
        self.inner.min_z = value;
        self
    }
    #[inline]
    pub fn max_x(mut self, value: f32) -> Self {
        self.inner.max_x = value;
        self
    }
    #[inline]
    pub fn max_y(mut self, value: f32) -> Self {
        self.inner.max_y = value;
        self
    }
    #[inline]
    pub fn max_z(mut self, value: f32) -> Self {
        self.inner.max_z = value;
        self
    }
}
impl core::ops::Deref for AabbPositionsKHRBuilder {
    type Target = AabbPositionsKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for AabbPositionsKHRBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`TransformMatrixKHR`].
pub struct TransformMatrixKHRBuilder {
    inner: TransformMatrixKHR,
}
impl TransformMatrixKHR {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> TransformMatrixKHRBuilder {
        TransformMatrixKHRBuilder {
            inner: TransformMatrixKHR {
                ..Default::default()
            },
        }
    }
}
impl TransformMatrixKHRBuilder {
    #[inline]
    pub fn matrix(mut self, value: [[f32; 4usize]; 3usize]) -> Self {
        self.inner.matrix = value;
        self
    }
}
impl core::ops::Deref for TransformMatrixKHRBuilder {
    type Target = TransformMatrixKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for TransformMatrixKHRBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`AccelerationStructureDeviceAddressInfoKHR`] with lifetime-tied pNext safety.
pub struct AccelerationStructureDeviceAddressInfoKHRBuilder<'a> {
    inner: AccelerationStructureDeviceAddressInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl AccelerationStructureDeviceAddressInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> AccelerationStructureDeviceAddressInfoKHRBuilder<'a> {
        AccelerationStructureDeviceAddressInfoKHRBuilder {
            inner: AccelerationStructureDeviceAddressInfoKHR {
                s_type: StructureType::from_raw(1000150002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> AccelerationStructureDeviceAddressInfoKHRBuilder<'a> {
    #[inline]
    pub fn acceleration_structure(mut self, value: AccelerationStructureKHR) -> Self {
        self.inner.acceleration_structure = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`AccelerationStructureDeviceAddressInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsAccelerationStructureDeviceAddressInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for AccelerationStructureDeviceAddressInfoKHRBuilder<'a> {
    type Target = AccelerationStructureDeviceAddressInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for AccelerationStructureDeviceAddressInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`AccelerationStructureVersionInfoKHR`] with lifetime-tied pNext safety.
pub struct AccelerationStructureVersionInfoKHRBuilder<'a> {
    inner: AccelerationStructureVersionInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl AccelerationStructureVersionInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> AccelerationStructureVersionInfoKHRBuilder<'a> {
        AccelerationStructureVersionInfoKHRBuilder {
            inner: AccelerationStructureVersionInfoKHR {
                s_type: StructureType::from_raw(1000150009i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> AccelerationStructureVersionInfoKHRBuilder<'a> {
    #[inline]
    pub fn version_data(mut self, value: *const u8) -> Self {
        self.inner.p_version_data = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`AccelerationStructureVersionInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsAccelerationStructureVersionInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for AccelerationStructureVersionInfoKHRBuilder<'a> {
    type Target = AccelerationStructureVersionInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for AccelerationStructureVersionInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`CopyAccelerationStructureInfoKHR`] with lifetime-tied pNext safety.
pub struct CopyAccelerationStructureInfoKHRBuilder<'a> {
    inner: CopyAccelerationStructureInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl CopyAccelerationStructureInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> CopyAccelerationStructureInfoKHRBuilder<'a> {
        CopyAccelerationStructureInfoKHRBuilder {
            inner: CopyAccelerationStructureInfoKHR {
                s_type: StructureType::from_raw(1000150010i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> CopyAccelerationStructureInfoKHRBuilder<'a> {
    #[inline]
    pub fn src(mut self, value: AccelerationStructureKHR) -> Self {
        self.inner.src = value;
        self
    }
    #[inline]
    pub fn dst(mut self, value: AccelerationStructureKHR) -> Self {
        self.inner.dst = value;
        self
    }
    #[inline]
    pub fn mode(mut self, value: CopyAccelerationStructureModeKHR) -> Self {
        self.inner.mode = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`CopyAccelerationStructureInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsCopyAccelerationStructureInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for CopyAccelerationStructureInfoKHRBuilder<'a> {
    type Target = CopyAccelerationStructureInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for CopyAccelerationStructureInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`CopyAccelerationStructureToMemoryInfoKHR`] with lifetime-tied pNext safety.
pub struct CopyAccelerationStructureToMemoryInfoKHRBuilder<'a> {
    inner: CopyAccelerationStructureToMemoryInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl CopyAccelerationStructureToMemoryInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> CopyAccelerationStructureToMemoryInfoKHRBuilder<'a> {
        CopyAccelerationStructureToMemoryInfoKHRBuilder {
            inner: CopyAccelerationStructureToMemoryInfoKHR {
                s_type: StructureType::from_raw(1000150011i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> CopyAccelerationStructureToMemoryInfoKHRBuilder<'a> {
    #[inline]
    pub fn src(mut self, value: AccelerationStructureKHR) -> Self {
        self.inner.src = value;
        self
    }
    #[inline]
    pub fn dst(mut self, value: DeviceOrHostAddressKHR) -> Self {
        self.inner.dst = value;
        self
    }
    #[inline]
    pub fn mode(mut self, value: CopyAccelerationStructureModeKHR) -> Self {
        self.inner.mode = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`CopyAccelerationStructureToMemoryInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsCopyAccelerationStructureToMemoryInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for CopyAccelerationStructureToMemoryInfoKHRBuilder<'a> {
    type Target = CopyAccelerationStructureToMemoryInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for CopyAccelerationStructureToMemoryInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`CopyMemoryToAccelerationStructureInfoKHR`] with lifetime-tied pNext safety.
pub struct CopyMemoryToAccelerationStructureInfoKHRBuilder<'a> {
    inner: CopyMemoryToAccelerationStructureInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl CopyMemoryToAccelerationStructureInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> CopyMemoryToAccelerationStructureInfoKHRBuilder<'a> {
        CopyMemoryToAccelerationStructureInfoKHRBuilder {
            inner: CopyMemoryToAccelerationStructureInfoKHR {
                s_type: StructureType::from_raw(1000150012i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> CopyMemoryToAccelerationStructureInfoKHRBuilder<'a> {
    #[inline]
    pub fn src(mut self, value: DeviceOrHostAddressConstKHR) -> Self {
        self.inner.src = value;
        self
    }
    #[inline]
    pub fn dst(mut self, value: AccelerationStructureKHR) -> Self {
        self.inner.dst = value;
        self
    }
    #[inline]
    pub fn mode(mut self, value: CopyAccelerationStructureModeKHR) -> Self {
        self.inner.mode = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`CopyMemoryToAccelerationStructureInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsCopyMemoryToAccelerationStructureInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for CopyMemoryToAccelerationStructureInfoKHRBuilder<'a> {
    type Target = CopyMemoryToAccelerationStructureInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for CopyMemoryToAccelerationStructureInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`RayTracingPipelineInterfaceCreateInfoKHR`] with lifetime-tied pNext safety.
pub struct RayTracingPipelineInterfaceCreateInfoKHRBuilder<'a> {
    inner: RayTracingPipelineInterfaceCreateInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl RayTracingPipelineInterfaceCreateInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> RayTracingPipelineInterfaceCreateInfoKHRBuilder<'a> {
        RayTracingPipelineInterfaceCreateInfoKHRBuilder {
            inner: RayTracingPipelineInterfaceCreateInfoKHR {
                s_type: StructureType::from_raw(1000150018i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> RayTracingPipelineInterfaceCreateInfoKHRBuilder<'a> {
    #[inline]
    pub fn max_pipeline_ray_payload_size(mut self, value: u32) -> Self {
        self.inner.max_pipeline_ray_payload_size = value;
        self
    }
    #[inline]
    pub fn max_pipeline_ray_hit_attribute_size(mut self, value: u32) -> Self {
        self.inner.max_pipeline_ray_hit_attribute_size = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`RayTracingPipelineInterfaceCreateInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsRayTracingPipelineInterfaceCreateInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for RayTracingPipelineInterfaceCreateInfoKHRBuilder<'a> {
    type Target = RayTracingPipelineInterfaceCreateInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for RayTracingPipelineInterfaceCreateInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PipelineLibraryCreateInfoKHR`] with lifetime-tied pNext safety.
pub struct PipelineLibraryCreateInfoKHRBuilder<'a> {
    inner: PipelineLibraryCreateInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PipelineLibraryCreateInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PipelineLibraryCreateInfoKHRBuilder<'a> {
        PipelineLibraryCreateInfoKHRBuilder {
            inner: PipelineLibraryCreateInfoKHR {
                s_type: StructureType::from_raw(1000290000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PipelineLibraryCreateInfoKHRBuilder<'a> {
    #[inline]
    pub fn libraries(mut self, slice: &'a [Pipeline]) -> Self {
        self.inner.library_count = slice.len() as u32;
        self.inner.p_libraries = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`PipelineLibraryCreateInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPipelineLibraryCreateInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for PipelineLibraryCreateInfoKHRBuilder<'a> {
    type Target = PipelineLibraryCreateInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PipelineLibraryCreateInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`RefreshObjectKHR`].
pub struct RefreshObjectKHRBuilder {
    inner: RefreshObjectKHR,
}
impl RefreshObjectKHR {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> RefreshObjectKHRBuilder {
        RefreshObjectKHRBuilder {
            inner: RefreshObjectKHR {
                ..Default::default()
            },
        }
    }
}
impl RefreshObjectKHRBuilder {
    #[inline]
    pub fn object_type(mut self, value: ObjectType) -> Self {
        self.inner.object_type = value;
        self
    }
    #[inline]
    pub fn object_handle(mut self, value: u64) -> Self {
        self.inner.object_handle = value;
        self
    }
    #[inline]
    pub fn flags(mut self, value: RefreshObjectFlagsKHR) -> Self {
        self.inner.flags = value;
        self
    }
}
impl core::ops::Deref for RefreshObjectKHRBuilder {
    type Target = RefreshObjectKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for RefreshObjectKHRBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`RefreshObjectListKHR`] with lifetime-tied pNext safety.
pub struct RefreshObjectListKHRBuilder<'a> {
    inner: RefreshObjectListKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl RefreshObjectListKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> RefreshObjectListKHRBuilder<'a> {
        RefreshObjectListKHRBuilder {
            inner: RefreshObjectListKHR {
                s_type: Default::default(),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> RefreshObjectListKHRBuilder<'a> {
    #[inline]
    pub fn objects(mut self, slice: &'a [RefreshObjectKHR]) -> Self {
        self.inner.object_count = slice.len() as u32;
        self.inner.p_objects = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`RefreshObjectListKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsRefreshObjectListKHR>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for RefreshObjectListKHRBuilder<'a> {
    type Target = RefreshObjectListKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for RefreshObjectListKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceExtendedDynamicStateFeaturesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceExtendedDynamicStateFeaturesEXTBuilder<'a> {
    inner: PhysicalDeviceExtendedDynamicStateFeaturesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceExtendedDynamicStateFeaturesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceExtendedDynamicStateFeaturesEXTBuilder<'a> {
        PhysicalDeviceExtendedDynamicStateFeaturesEXTBuilder {
            inner: PhysicalDeviceExtendedDynamicStateFeaturesEXT {
                s_type: StructureType::from_raw(1000267000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceExtendedDynamicStateFeaturesEXTBuilder<'a> {
    #[inline]
    pub fn extended_dynamic_state(mut self, value: bool) -> Self {
        self.inner.extended_dynamic_state = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceExtendedDynamicStateFeaturesEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceExtendedDynamicStateFeaturesEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceExtendedDynamicStateFeaturesEXTBuilder<'a> {
    type Target = PhysicalDeviceExtendedDynamicStateFeaturesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceExtendedDynamicStateFeaturesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceExtendedDynamicState2FeaturesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceExtendedDynamicState2FeaturesEXTBuilder<'a> {
    inner: PhysicalDeviceExtendedDynamicState2FeaturesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceExtendedDynamicState2FeaturesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceExtendedDynamicState2FeaturesEXTBuilder<'a> {
        PhysicalDeviceExtendedDynamicState2FeaturesEXTBuilder {
            inner: PhysicalDeviceExtendedDynamicState2FeaturesEXT {
                s_type: StructureType::from_raw(1000377000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceExtendedDynamicState2FeaturesEXTBuilder<'a> {
    #[inline]
    pub fn extended_dynamic_state2(mut self, value: bool) -> Self {
        self.inner.extended_dynamic_state2 = value as u32;
        self
    }
    #[inline]
    pub fn extended_dynamic_state2_logic_op(mut self, value: bool) -> Self {
        self.inner.extended_dynamic_state2_logic_op = value as u32;
        self
    }
    #[inline]
    pub fn extended_dynamic_state2_patch_control_points(mut self, value: bool) -> Self {
        self.inner.extended_dynamic_state2_patch_control_points = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceExtendedDynamicState2FeaturesEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceExtendedDynamicState2FeaturesEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceExtendedDynamicState2FeaturesEXTBuilder<'a> {
    type Target = PhysicalDeviceExtendedDynamicState2FeaturesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceExtendedDynamicState2FeaturesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceExtendedDynamicState3FeaturesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceExtendedDynamicState3FeaturesEXTBuilder<'a> {
    inner: PhysicalDeviceExtendedDynamicState3FeaturesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceExtendedDynamicState3FeaturesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceExtendedDynamicState3FeaturesEXTBuilder<'a> {
        PhysicalDeviceExtendedDynamicState3FeaturesEXTBuilder {
            inner: PhysicalDeviceExtendedDynamicState3FeaturesEXT {
                s_type: StructureType::from_raw(1000455000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceExtendedDynamicState3FeaturesEXTBuilder<'a> {
    #[inline]
    pub fn extended_dynamic_state3_tessellation_domain_origin(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.extended_dynamic_state3_tessellation_domain_origin = value as u32;
        self
    }
    #[inline]
    pub fn extended_dynamic_state3_depth_clamp_enable(mut self, value: bool) -> Self {
        self.inner.extended_dynamic_state3_depth_clamp_enable = value as u32;
        self
    }
    #[inline]
    pub fn extended_dynamic_state3_polygon_mode(mut self, value: bool) -> Self {
        self.inner.extended_dynamic_state3_polygon_mode = value as u32;
        self
    }
    #[inline]
    pub fn extended_dynamic_state3_rasterization_samples(mut self, value: bool) -> Self {
        self.inner.extended_dynamic_state3_rasterization_samples = value as u32;
        self
    }
    #[inline]
    pub fn extended_dynamic_state3_sample_mask(mut self, value: bool) -> Self {
        self.inner.extended_dynamic_state3_sample_mask = value as u32;
        self
    }
    #[inline]
    pub fn extended_dynamic_state3_alpha_to_coverage_enable(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.extended_dynamic_state3_alpha_to_coverage_enable = value as u32;
        self
    }
    #[inline]
    pub fn extended_dynamic_state3_alpha_to_one_enable(mut self, value: bool) -> Self {
        self.inner.extended_dynamic_state3_alpha_to_one_enable = value as u32;
        self
    }
    #[inline]
    pub fn extended_dynamic_state3_logic_op_enable(mut self, value: bool) -> Self {
        self.inner.extended_dynamic_state3_logic_op_enable = value as u32;
        self
    }
    #[inline]
    pub fn extended_dynamic_state3_color_blend_enable(mut self, value: bool) -> Self {
        self.inner.extended_dynamic_state3_color_blend_enable = value as u32;
        self
    }
    #[inline]
    pub fn extended_dynamic_state3_color_blend_equation(mut self, value: bool) -> Self {
        self.inner.extended_dynamic_state3_color_blend_equation = value as u32;
        self
    }
    #[inline]
    pub fn extended_dynamic_state3_color_write_mask(mut self, value: bool) -> Self {
        self.inner.extended_dynamic_state3_color_write_mask = value as u32;
        self
    }
    #[inline]
    pub fn extended_dynamic_state3_rasterization_stream(mut self, value: bool) -> Self {
        self.inner.extended_dynamic_state3_rasterization_stream = value as u32;
        self
    }
    #[inline]
    pub fn extended_dynamic_state3_conservative_rasterization_mode(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.extended_dynamic_state3_conservative_rasterization_mode = value
            as u32;
        self
    }
    #[inline]
    pub fn extended_dynamic_state3_extra_primitive_overestimation_size(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.extended_dynamic_state3_extra_primitive_overestimation_size = value
            as u32;
        self
    }
    #[inline]
    pub fn extended_dynamic_state3_depth_clip_enable(mut self, value: bool) -> Self {
        self.inner.extended_dynamic_state3_depth_clip_enable = value as u32;
        self
    }
    #[inline]
    pub fn extended_dynamic_state3_sample_locations_enable(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.extended_dynamic_state3_sample_locations_enable = value as u32;
        self
    }
    #[inline]
    pub fn extended_dynamic_state3_color_blend_advanced(mut self, value: bool) -> Self {
        self.inner.extended_dynamic_state3_color_blend_advanced = value as u32;
        self
    }
    #[inline]
    pub fn extended_dynamic_state3_provoking_vertex_mode(mut self, value: bool) -> Self {
        self.inner.extended_dynamic_state3_provoking_vertex_mode = value as u32;
        self
    }
    #[inline]
    pub fn extended_dynamic_state3_line_rasterization_mode(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.extended_dynamic_state3_line_rasterization_mode = value as u32;
        self
    }
    #[inline]
    pub fn extended_dynamic_state3_line_stipple_enable(mut self, value: bool) -> Self {
        self.inner.extended_dynamic_state3_line_stipple_enable = value as u32;
        self
    }
    #[inline]
    pub fn extended_dynamic_state3_depth_clip_negative_one_to_one(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.extended_dynamic_state3_depth_clip_negative_one_to_one = value as u32;
        self
    }
    #[inline]
    pub fn extended_dynamic_state3_viewport_w_scaling_enable(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.extended_dynamic_state3_viewport_w_scaling_enable = value as u32;
        self
    }
    #[inline]
    pub fn extended_dynamic_state3_viewport_swizzle(mut self, value: bool) -> Self {
        self.inner.extended_dynamic_state3_viewport_swizzle = value as u32;
        self
    }
    #[inline]
    pub fn extended_dynamic_state3_coverage_to_color_enable(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.extended_dynamic_state3_coverage_to_color_enable = value as u32;
        self
    }
    #[inline]
    pub fn extended_dynamic_state3_coverage_to_color_location(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.extended_dynamic_state3_coverage_to_color_location = value as u32;
        self
    }
    #[inline]
    pub fn extended_dynamic_state3_coverage_modulation_mode(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.extended_dynamic_state3_coverage_modulation_mode = value as u32;
        self
    }
    #[inline]
    pub fn extended_dynamic_state3_coverage_modulation_table_enable(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.extended_dynamic_state3_coverage_modulation_table_enable = value
            as u32;
        self
    }
    #[inline]
    pub fn extended_dynamic_state3_coverage_modulation_table(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.extended_dynamic_state3_coverage_modulation_table = value as u32;
        self
    }
    #[inline]
    pub fn extended_dynamic_state3_coverage_reduction_mode(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.extended_dynamic_state3_coverage_reduction_mode = value as u32;
        self
    }
    #[inline]
    pub fn extended_dynamic_state3_representative_fragment_test_enable(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.extended_dynamic_state3_representative_fragment_test_enable = value
            as u32;
        self
    }
    #[inline]
    pub fn extended_dynamic_state3_shading_rate_image_enable(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.extended_dynamic_state3_shading_rate_image_enable = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceExtendedDynamicState3FeaturesEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceExtendedDynamicState3FeaturesEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceExtendedDynamicState3FeaturesEXTBuilder<'a> {
    type Target = PhysicalDeviceExtendedDynamicState3FeaturesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceExtendedDynamicState3FeaturesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceExtendedDynamicState3PropertiesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceExtendedDynamicState3PropertiesEXTBuilder<'a> {
    inner: PhysicalDeviceExtendedDynamicState3PropertiesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceExtendedDynamicState3PropertiesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceExtendedDynamicState3PropertiesEXTBuilder<'a> {
        PhysicalDeviceExtendedDynamicState3PropertiesEXTBuilder {
            inner: PhysicalDeviceExtendedDynamicState3PropertiesEXT {
                s_type: StructureType::from_raw(1000455001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceExtendedDynamicState3PropertiesEXTBuilder<'a> {
    #[inline]
    pub fn dynamic_primitive_topology_unrestricted(mut self, value: bool) -> Self {
        self.inner.dynamic_primitive_topology_unrestricted = value as u32;
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDeviceExtendedDynamicState3PropertiesEXTBuilder<'a> {
    type Target = PhysicalDeviceExtendedDynamicState3PropertiesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceExtendedDynamicState3PropertiesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ColorBlendEquationEXT`].
pub struct ColorBlendEquationEXTBuilder {
    inner: ColorBlendEquationEXT,
}
impl ColorBlendEquationEXT {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> ColorBlendEquationEXTBuilder {
        ColorBlendEquationEXTBuilder {
            inner: ColorBlendEquationEXT {
                ..Default::default()
            },
        }
    }
}
impl ColorBlendEquationEXTBuilder {
    #[inline]
    pub fn src_color_blend_factor(mut self, value: BlendFactor) -> Self {
        self.inner.src_color_blend_factor = value;
        self
    }
    #[inline]
    pub fn dst_color_blend_factor(mut self, value: BlendFactor) -> Self {
        self.inner.dst_color_blend_factor = value;
        self
    }
    #[inline]
    pub fn color_blend_op(mut self, value: BlendOp) -> Self {
        self.inner.color_blend_op = value;
        self
    }
    #[inline]
    pub fn src_alpha_blend_factor(mut self, value: BlendFactor) -> Self {
        self.inner.src_alpha_blend_factor = value;
        self
    }
    #[inline]
    pub fn dst_alpha_blend_factor(mut self, value: BlendFactor) -> Self {
        self.inner.dst_alpha_blend_factor = value;
        self
    }
    #[inline]
    pub fn alpha_blend_op(mut self, value: BlendOp) -> Self {
        self.inner.alpha_blend_op = value;
        self
    }
}
impl core::ops::Deref for ColorBlendEquationEXTBuilder {
    type Target = ColorBlendEquationEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for ColorBlendEquationEXTBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ColorBlendAdvancedEXT`].
pub struct ColorBlendAdvancedEXTBuilder {
    inner: ColorBlendAdvancedEXT,
}
impl ColorBlendAdvancedEXT {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> ColorBlendAdvancedEXTBuilder {
        ColorBlendAdvancedEXTBuilder {
            inner: ColorBlendAdvancedEXT {
                ..Default::default()
            },
        }
    }
}
impl ColorBlendAdvancedEXTBuilder {
    #[inline]
    pub fn advanced_blend_op(mut self, value: BlendOp) -> Self {
        self.inner.advanced_blend_op = value;
        self
    }
    #[inline]
    pub fn src_premultiplied(mut self, value: bool) -> Self {
        self.inner.src_premultiplied = value as u32;
        self
    }
    #[inline]
    pub fn dst_premultiplied(mut self, value: bool) -> Self {
        self.inner.dst_premultiplied = value as u32;
        self
    }
    #[inline]
    pub fn blend_overlap(mut self, value: BlendOverlapEXT) -> Self {
        self.inner.blend_overlap = value;
        self
    }
    #[inline]
    pub fn clamp_results(mut self, value: bool) -> Self {
        self.inner.clamp_results = value as u32;
        self
    }
}
impl core::ops::Deref for ColorBlendAdvancedEXTBuilder {
    type Target = ColorBlendAdvancedEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for ColorBlendAdvancedEXTBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`RenderPassTransformBeginInfoQCOM`] with lifetime-tied pNext safety.
pub struct RenderPassTransformBeginInfoQCOMBuilder<'a> {
    inner: RenderPassTransformBeginInfoQCOM,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl RenderPassTransformBeginInfoQCOM {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> RenderPassTransformBeginInfoQCOMBuilder<'a> {
        RenderPassTransformBeginInfoQCOMBuilder {
            inner: RenderPassTransformBeginInfoQCOM {
                s_type: StructureType::from_raw(1000282001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> RenderPassTransformBeginInfoQCOMBuilder<'a> {
    #[inline]
    pub fn transform(mut self, value: SurfaceTransformFlagBitsKHR) -> Self {
        self.inner.transform = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`RenderPassTransformBeginInfoQCOM`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsRenderPassTransformBeginInfoQCOM>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for RenderPassTransformBeginInfoQCOMBuilder<'a> {
    type Target = RenderPassTransformBeginInfoQCOM;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for RenderPassTransformBeginInfoQCOMBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`CopyCommandTransformInfoQCOM`] with lifetime-tied pNext safety.
pub struct CopyCommandTransformInfoQCOMBuilder<'a> {
    inner: CopyCommandTransformInfoQCOM,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl CopyCommandTransformInfoQCOM {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> CopyCommandTransformInfoQCOMBuilder<'a> {
        CopyCommandTransformInfoQCOMBuilder {
            inner: CopyCommandTransformInfoQCOM {
                s_type: StructureType::from_raw(1000333000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> CopyCommandTransformInfoQCOMBuilder<'a> {
    #[inline]
    pub fn transform(mut self, value: SurfaceTransformFlagBitsKHR) -> Self {
        self.inner.transform = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`CopyCommandTransformInfoQCOM`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsCopyCommandTransformInfoQCOM>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for CopyCommandTransformInfoQCOMBuilder<'a> {
    type Target = CopyCommandTransformInfoQCOM;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for CopyCommandTransformInfoQCOMBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`CommandBufferInheritanceRenderPassTransformInfoQCOM`] with lifetime-tied pNext safety.
pub struct CommandBufferInheritanceRenderPassTransformInfoQCOMBuilder<'a> {
    inner: CommandBufferInheritanceRenderPassTransformInfoQCOM,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl CommandBufferInheritanceRenderPassTransformInfoQCOM {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> CommandBufferInheritanceRenderPassTransformInfoQCOMBuilder<
        'a,
    > {
        CommandBufferInheritanceRenderPassTransformInfoQCOMBuilder {
            inner: CommandBufferInheritanceRenderPassTransformInfoQCOM {
                s_type: StructureType::from_raw(1000282000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> CommandBufferInheritanceRenderPassTransformInfoQCOMBuilder<'a> {
    #[inline]
    pub fn transform(mut self, value: SurfaceTransformFlagBitsKHR) -> Self {
        self.inner.transform = value;
        self
    }
    #[inline]
    pub fn render_area(mut self, value: Rect2D) -> Self {
        self.inner.render_area = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`CommandBufferInheritanceRenderPassTransformInfoQCOM`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsCommandBufferInheritanceRenderPassTransformInfoQCOM>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref
for CommandBufferInheritanceRenderPassTransformInfoQCOMBuilder<'a> {
    type Target = CommandBufferInheritanceRenderPassTransformInfoQCOM;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for CommandBufferInheritanceRenderPassTransformInfoQCOMBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDevicePartitionedAccelerationStructureFeaturesNV`] with lifetime-tied pNext safety.
pub struct PhysicalDevicePartitionedAccelerationStructureFeaturesNVBuilder<'a> {
    inner: PhysicalDevicePartitionedAccelerationStructureFeaturesNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDevicePartitionedAccelerationStructureFeaturesNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDevicePartitionedAccelerationStructureFeaturesNVBuilder<
        'a,
    > {
        PhysicalDevicePartitionedAccelerationStructureFeaturesNVBuilder {
            inner: PhysicalDevicePartitionedAccelerationStructureFeaturesNV {
                s_type: StructureType::from_raw(1000570000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDevicePartitionedAccelerationStructureFeaturesNVBuilder<'a> {
    #[inline]
    pub fn partitioned_acceleration_structure(mut self, value: bool) -> Self {
        self.inner.partitioned_acceleration_structure = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDevicePartitionedAccelerationStructureFeaturesNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDevicePartitionedAccelerationStructureFeaturesNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDevicePartitionedAccelerationStructureFeaturesNVBuilder<'a> {
    type Target = PhysicalDevicePartitionedAccelerationStructureFeaturesNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDevicePartitionedAccelerationStructureFeaturesNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDevicePartitionedAccelerationStructurePropertiesNV`] with lifetime-tied pNext safety.
pub struct PhysicalDevicePartitionedAccelerationStructurePropertiesNVBuilder<'a> {
    inner: PhysicalDevicePartitionedAccelerationStructurePropertiesNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDevicePartitionedAccelerationStructurePropertiesNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDevicePartitionedAccelerationStructurePropertiesNVBuilder<
        'a,
    > {
        PhysicalDevicePartitionedAccelerationStructurePropertiesNVBuilder {
            inner: PhysicalDevicePartitionedAccelerationStructurePropertiesNV {
                s_type: StructureType::from_raw(1000570001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDevicePartitionedAccelerationStructurePropertiesNVBuilder<'a> {
    #[inline]
    pub fn max_partition_count(mut self, value: u32) -> Self {
        self.inner.max_partition_count = value;
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDevicePartitionedAccelerationStructurePropertiesNVBuilder<'a> {
    type Target = PhysicalDevicePartitionedAccelerationStructurePropertiesNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDevicePartitionedAccelerationStructurePropertiesNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`BuildPartitionedAccelerationStructureIndirectCommandNV`].
pub struct BuildPartitionedAccelerationStructureIndirectCommandNVBuilder {
    inner: BuildPartitionedAccelerationStructureIndirectCommandNV,
}
impl BuildPartitionedAccelerationStructureIndirectCommandNV {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> BuildPartitionedAccelerationStructureIndirectCommandNVBuilder {
        BuildPartitionedAccelerationStructureIndirectCommandNVBuilder {
            inner: BuildPartitionedAccelerationStructureIndirectCommandNV {
                ..Default::default()
            },
        }
    }
}
impl BuildPartitionedAccelerationStructureIndirectCommandNVBuilder {
    #[inline]
    pub fn op_type(mut self, value: PartitionedAccelerationStructureOpTypeNV) -> Self {
        self.inner.op_type = value;
        self
    }
    #[inline]
    pub fn arg_count(mut self, value: u32) -> Self {
        self.inner.arg_count = value;
        self
    }
    #[inline]
    pub fn arg_data(mut self, value: StridedDeviceAddressNV) -> Self {
        self.inner.arg_data = value;
        self
    }
}
impl core::ops::Deref for BuildPartitionedAccelerationStructureIndirectCommandNVBuilder {
    type Target = BuildPartitionedAccelerationStructureIndirectCommandNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut
for BuildPartitionedAccelerationStructureIndirectCommandNVBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PartitionedAccelerationStructureFlagsNV`] with lifetime-tied pNext safety.
pub struct PartitionedAccelerationStructureFlagsNVBuilder<'a> {
    inner: PartitionedAccelerationStructureFlagsNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PartitionedAccelerationStructureFlagsNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PartitionedAccelerationStructureFlagsNVBuilder<'a> {
        PartitionedAccelerationStructureFlagsNVBuilder {
            inner: PartitionedAccelerationStructureFlagsNV {
                s_type: StructureType::from_raw(1000570005i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PartitionedAccelerationStructureFlagsNVBuilder<'a> {
    #[inline]
    pub fn enable_partition_translation(mut self, value: bool) -> Self {
        self.inner.enable_partition_translation = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PartitionedAccelerationStructureFlagsNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPartitionedAccelerationStructureFlagsNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PartitionedAccelerationStructureFlagsNVBuilder<'a> {
    type Target = PartitionedAccelerationStructureFlagsNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PartitionedAccelerationStructureFlagsNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PartitionedAccelerationStructureWriteInstanceDataNV`].
pub struct PartitionedAccelerationStructureWriteInstanceDataNVBuilder {
    inner: PartitionedAccelerationStructureWriteInstanceDataNV,
}
impl PartitionedAccelerationStructureWriteInstanceDataNV {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> PartitionedAccelerationStructureWriteInstanceDataNVBuilder {
        PartitionedAccelerationStructureWriteInstanceDataNVBuilder {
            inner: PartitionedAccelerationStructureWriteInstanceDataNV {
                ..Default::default()
            },
        }
    }
}
impl PartitionedAccelerationStructureWriteInstanceDataNVBuilder {
    #[inline]
    pub fn transform(mut self, value: TransformMatrixKHR) -> Self {
        self.inner.transform = value;
        self
    }
    #[inline]
    pub fn explicit_aabb(mut self, value: [f32; 6usize]) -> Self {
        self.inner.explicit_aabb = value;
        self
    }
    #[inline]
    pub fn instance_id(mut self, value: u32) -> Self {
        self.inner.instance_id = value;
        self
    }
    #[inline]
    pub fn instance_mask(mut self, value: u32) -> Self {
        self.inner.instance_mask = value;
        self
    }
    #[inline]
    pub fn instance_contribution_to_hit_group_index(mut self, value: u32) -> Self {
        self.inner.instance_contribution_to_hit_group_index = value;
        self
    }
    #[inline]
    pub fn instance_flags(
        mut self,
        value: PartitionedAccelerationStructureInstanceFlagsNV,
    ) -> Self {
        self.inner.instance_flags = value;
        self
    }
    #[inline]
    pub fn instance_index(mut self, value: u32) -> Self {
        self.inner.instance_index = value;
        self
    }
    #[inline]
    pub fn partition_index(mut self, value: u32) -> Self {
        self.inner.partition_index = value;
        self
    }
    #[inline]
    pub fn acceleration_structure(mut self, value: u64) -> Self {
        self.inner.acceleration_structure = value;
        self
    }
}
impl core::ops::Deref for PartitionedAccelerationStructureWriteInstanceDataNVBuilder {
    type Target = PartitionedAccelerationStructureWriteInstanceDataNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for PartitionedAccelerationStructureWriteInstanceDataNVBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PartitionedAccelerationStructureUpdateInstanceDataNV`].
pub struct PartitionedAccelerationStructureUpdateInstanceDataNVBuilder {
    inner: PartitionedAccelerationStructureUpdateInstanceDataNV,
}
impl PartitionedAccelerationStructureUpdateInstanceDataNV {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> PartitionedAccelerationStructureUpdateInstanceDataNVBuilder {
        PartitionedAccelerationStructureUpdateInstanceDataNVBuilder {
            inner: PartitionedAccelerationStructureUpdateInstanceDataNV {
                ..Default::default()
            },
        }
    }
}
impl PartitionedAccelerationStructureUpdateInstanceDataNVBuilder {
    #[inline]
    pub fn instance_index(mut self, value: u32) -> Self {
        self.inner.instance_index = value;
        self
    }
    #[inline]
    pub fn instance_contribution_to_hit_group_index(mut self, value: u32) -> Self {
        self.inner.instance_contribution_to_hit_group_index = value;
        self
    }
    #[inline]
    pub fn acceleration_structure(mut self, value: u64) -> Self {
        self.inner.acceleration_structure = value;
        self
    }
}
impl core::ops::Deref for PartitionedAccelerationStructureUpdateInstanceDataNVBuilder {
    type Target = PartitionedAccelerationStructureUpdateInstanceDataNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut
for PartitionedAccelerationStructureUpdateInstanceDataNVBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PartitionedAccelerationStructureWritePartitionTranslationDataNV`].
pub struct PartitionedAccelerationStructureWritePartitionTranslationDataNVBuilder {
    inner: PartitionedAccelerationStructureWritePartitionTranslationDataNV,
}
impl PartitionedAccelerationStructureWritePartitionTranslationDataNV {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> PartitionedAccelerationStructureWritePartitionTranslationDataNVBuilder {
        PartitionedAccelerationStructureWritePartitionTranslationDataNVBuilder {
            inner: PartitionedAccelerationStructureWritePartitionTranslationDataNV {
                ..Default::default()
            },
        }
    }
}
impl PartitionedAccelerationStructureWritePartitionTranslationDataNVBuilder {
    #[inline]
    pub fn partition_index(mut self, value: u32) -> Self {
        self.inner.partition_index = value;
        self
    }
    #[inline]
    pub fn partition_translation(mut self, value: [f32; 3usize]) -> Self {
        self.inner.partition_translation = value;
        self
    }
}
impl core::ops::Deref
for PartitionedAccelerationStructureWritePartitionTranslationDataNVBuilder {
    type Target = PartitionedAccelerationStructureWritePartitionTranslationDataNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut
for PartitionedAccelerationStructureWritePartitionTranslationDataNVBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`WriteDescriptorSetPartitionedAccelerationStructureNV`] with lifetime-tied pNext safety.
pub struct WriteDescriptorSetPartitionedAccelerationStructureNVBuilder<'a> {
    inner: WriteDescriptorSetPartitionedAccelerationStructureNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl WriteDescriptorSetPartitionedAccelerationStructureNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> WriteDescriptorSetPartitionedAccelerationStructureNVBuilder<
        'a,
    > {
        WriteDescriptorSetPartitionedAccelerationStructureNVBuilder {
            inner: WriteDescriptorSetPartitionedAccelerationStructureNV {
                s_type: StructureType::from_raw(1000570002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> WriteDescriptorSetPartitionedAccelerationStructureNVBuilder<'a> {
    #[inline]
    pub fn acceleration_structure_count(mut self, value: u32) -> Self {
        self.inner.acceleration_structure_count = value;
        self
    }
    #[inline]
    pub fn acceleration_structures(mut self, slice: &'a [u64]) -> Self {
        self.inner.acceleration_structure_count = slice.len() as u32;
        self.inner.p_acceleration_structures = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`WriteDescriptorSetPartitionedAccelerationStructureNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsWriteDescriptorSetPartitionedAccelerationStructureNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref
for WriteDescriptorSetPartitionedAccelerationStructureNVBuilder<'a> {
    type Target = WriteDescriptorSetPartitionedAccelerationStructureNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for WriteDescriptorSetPartitionedAccelerationStructureNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PartitionedAccelerationStructureInstancesInputNV`] with lifetime-tied pNext safety.
pub struct PartitionedAccelerationStructureInstancesInputNVBuilder<'a> {
    inner: PartitionedAccelerationStructureInstancesInputNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PartitionedAccelerationStructureInstancesInputNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PartitionedAccelerationStructureInstancesInputNVBuilder<'a> {
        PartitionedAccelerationStructureInstancesInputNVBuilder {
            inner: PartitionedAccelerationStructureInstancesInputNV {
                s_type: StructureType::from_raw(1000570003i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PartitionedAccelerationStructureInstancesInputNVBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: BuildAccelerationStructureFlagsKHR) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn instance_count(mut self, value: u32) -> Self {
        self.inner.instance_count = value;
        self
    }
    #[inline]
    pub fn max_instance_per_partition_count(mut self, value: u32) -> Self {
        self.inner.max_instance_per_partition_count = value;
        self
    }
    #[inline]
    pub fn partition_count(mut self, value: u32) -> Self {
        self.inner.partition_count = value;
        self
    }
    #[inline]
    pub fn max_instance_in_global_partition_count(mut self, value: u32) -> Self {
        self.inner.max_instance_in_global_partition_count = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PartitionedAccelerationStructureInstancesInputNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPartitionedAccelerationStructureInstancesInputNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref
for PartitionedAccelerationStructureInstancesInputNVBuilder<'a> {
    type Target = PartitionedAccelerationStructureInstancesInputNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PartitionedAccelerationStructureInstancesInputNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`BuildPartitionedAccelerationStructureInfoNV`] with lifetime-tied pNext safety.
pub struct BuildPartitionedAccelerationStructureInfoNVBuilder<'a> {
    inner: BuildPartitionedAccelerationStructureInfoNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl BuildPartitionedAccelerationStructureInfoNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> BuildPartitionedAccelerationStructureInfoNVBuilder<'a> {
        BuildPartitionedAccelerationStructureInfoNVBuilder {
            inner: BuildPartitionedAccelerationStructureInfoNV {
                s_type: StructureType::from_raw(1000570004i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> BuildPartitionedAccelerationStructureInfoNVBuilder<'a> {
    #[inline]
    pub fn input(
        mut self,
        value: PartitionedAccelerationStructureInstancesInputNV,
    ) -> Self {
        self.inner.input = value;
        self
    }
    #[inline]
    pub fn src_acceleration_structure_data(mut self, value: u64) -> Self {
        self.inner.src_acceleration_structure_data = value;
        self
    }
    #[inline]
    pub fn dst_acceleration_structure_data(mut self, value: u64) -> Self {
        self.inner.dst_acceleration_structure_data = value;
        self
    }
    #[inline]
    pub fn scratch_data(mut self, value: u64) -> Self {
        self.inner.scratch_data = value;
        self
    }
    #[inline]
    pub fn src_infos(mut self, value: u64) -> Self {
        self.inner.src_infos = value;
        self
    }
    #[inline]
    pub fn src_infos_count(mut self, value: u64) -> Self {
        self.inner.src_infos_count = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`BuildPartitionedAccelerationStructureInfoNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsBuildPartitionedAccelerationStructureInfoNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for BuildPartitionedAccelerationStructureInfoNVBuilder<'a> {
    type Target = BuildPartitionedAccelerationStructureInfoNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for BuildPartitionedAccelerationStructureInfoNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceDiagnosticsConfigFeaturesNV`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceDiagnosticsConfigFeaturesNVBuilder<'a> {
    inner: PhysicalDeviceDiagnosticsConfigFeaturesNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceDiagnosticsConfigFeaturesNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceDiagnosticsConfigFeaturesNVBuilder<'a> {
        PhysicalDeviceDiagnosticsConfigFeaturesNVBuilder {
            inner: PhysicalDeviceDiagnosticsConfigFeaturesNV {
                s_type: StructureType::from_raw(1000300000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceDiagnosticsConfigFeaturesNVBuilder<'a> {
    #[inline]
    pub fn diagnostics_config(mut self, value: bool) -> Self {
        self.inner.diagnostics_config = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceDiagnosticsConfigFeaturesNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceDiagnosticsConfigFeaturesNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceDiagnosticsConfigFeaturesNVBuilder<'a> {
    type Target = PhysicalDeviceDiagnosticsConfigFeaturesNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceDiagnosticsConfigFeaturesNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DeviceDiagnosticsConfigCreateInfoNV`] with lifetime-tied pNext safety.
pub struct DeviceDiagnosticsConfigCreateInfoNVBuilder<'a> {
    inner: DeviceDiagnosticsConfigCreateInfoNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DeviceDiagnosticsConfigCreateInfoNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> DeviceDiagnosticsConfigCreateInfoNVBuilder<'a> {
        DeviceDiagnosticsConfigCreateInfoNVBuilder {
            inner: DeviceDiagnosticsConfigCreateInfoNV {
                s_type: StructureType::from_raw(1000300001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DeviceDiagnosticsConfigCreateInfoNVBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: DeviceDiagnosticsConfigFlagsNV) -> Self {
        self.inner.flags = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`DeviceDiagnosticsConfigCreateInfoNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsDeviceDiagnosticsConfigCreateInfoNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for DeviceDiagnosticsConfigCreateInfoNVBuilder<'a> {
    type Target = DeviceDiagnosticsConfigCreateInfoNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for DeviceDiagnosticsConfigCreateInfoNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PipelineOfflineCreateInfo`] with lifetime-tied pNext safety.
pub struct PipelineOfflineCreateInfoBuilder<'a> {
    inner: PipelineOfflineCreateInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PipelineOfflineCreateInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PipelineOfflineCreateInfoBuilder<'a> {
        PipelineOfflineCreateInfoBuilder {
            inner: PipelineOfflineCreateInfo {
                s_type: StructureType::from_raw(1000298010i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PipelineOfflineCreateInfoBuilder<'a> {
    #[inline]
    pub fn pipeline_identifier(mut self, value: [u8; UUID_SIZE as usize]) -> Self {
        self.inner.pipeline_identifier = value;
        self
    }
    #[inline]
    pub fn match_control(mut self, value: PipelineMatchControl) -> Self {
        self.inner.match_control = value;
        self
    }
    #[inline]
    pub fn pool_entry_size(mut self, value: u64) -> Self {
        self.inner.pool_entry_size = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PipelineOfflineCreateInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPipelineOfflineCreateInfo>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for PipelineOfflineCreateInfoBuilder<'a> {
    type Target = PipelineOfflineCreateInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PipelineOfflineCreateInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesBuilder<'a> {
    inner: PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesBuilder<
        'a,
    > {
        PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesBuilder {
            inner: PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures {
                s_type: StructureType::from_raw(1000325000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesBuilder<'a> {
    #[inline]
    pub fn shader_zero_initialize_workgroup_memory(mut self, value: bool) -> Self {
        self.inner.shader_zero_initialize_workgroup_memory = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesBuilder<'a> {
    type Target = PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHRBuilder<'a> {
    inner: PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHRBuilder<
        'a,
    > {
        PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHRBuilder {
            inner: PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR {
                s_type: StructureType::from_raw(1000323000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHRBuilder<'a> {
    #[inline]
    pub fn shader_subgroup_uniform_control_flow(mut self, value: bool) -> Self {
        self.inner.shader_subgroup_uniform_control_flow = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<
        T: ExtendsPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR,
    >(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHRBuilder<'a> {
    type Target = PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceRobustness2FeaturesKHR`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceRobustness2FeaturesKHRBuilder<'a> {
    inner: PhysicalDeviceRobustness2FeaturesKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceRobustness2FeaturesKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceRobustness2FeaturesKHRBuilder<'a> {
        PhysicalDeviceRobustness2FeaturesKHRBuilder {
            inner: PhysicalDeviceRobustness2FeaturesKHR {
                s_type: StructureType::from_raw(1000286000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceRobustness2FeaturesKHRBuilder<'a> {
    #[inline]
    pub fn robust_buffer_access2(mut self, value: bool) -> Self {
        self.inner.robust_buffer_access2 = value as u32;
        self
    }
    #[inline]
    pub fn robust_image_access2(mut self, value: bool) -> Self {
        self.inner.robust_image_access2 = value as u32;
        self
    }
    #[inline]
    pub fn null_descriptor(mut self, value: bool) -> Self {
        self.inner.null_descriptor = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceRobustness2FeaturesKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceRobustness2FeaturesKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceRobustness2FeaturesKHRBuilder<'a> {
    type Target = PhysicalDeviceRobustness2FeaturesKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceRobustness2FeaturesKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceRobustness2PropertiesKHR`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceRobustness2PropertiesKHRBuilder<'a> {
    inner: PhysicalDeviceRobustness2PropertiesKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceRobustness2PropertiesKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceRobustness2PropertiesKHRBuilder<'a> {
        PhysicalDeviceRobustness2PropertiesKHRBuilder {
            inner: PhysicalDeviceRobustness2PropertiesKHR {
                s_type: StructureType::from_raw(1000286001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceRobustness2PropertiesKHRBuilder<'a> {
    #[inline]
    pub fn robust_storage_buffer_access_size_alignment(mut self, value: u64) -> Self {
        self.inner.robust_storage_buffer_access_size_alignment = value;
        self
    }
    #[inline]
    pub fn robust_uniform_buffer_access_size_alignment(mut self, value: u64) -> Self {
        self.inner.robust_uniform_buffer_access_size_alignment = value;
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceRobustness2PropertiesKHRBuilder<'a> {
    type Target = PhysicalDeviceRobustness2PropertiesKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceRobustness2PropertiesKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceImageRobustnessFeatures`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceImageRobustnessFeaturesBuilder<'a> {
    inner: PhysicalDeviceImageRobustnessFeatures,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceImageRobustnessFeatures {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceImageRobustnessFeaturesBuilder<'a> {
        PhysicalDeviceImageRobustnessFeaturesBuilder {
            inner: PhysicalDeviceImageRobustnessFeatures {
                s_type: StructureType::from_raw(1000335000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceImageRobustnessFeaturesBuilder<'a> {
    #[inline]
    pub fn robust_image_access(mut self, value: bool) -> Self {
        self.inner.robust_image_access = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceImageRobustnessFeatures`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceImageRobustnessFeatures>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceImageRobustnessFeaturesBuilder<'a> {
    type Target = PhysicalDeviceImageRobustnessFeatures;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceImageRobustnessFeaturesBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHRBuilder<'a> {
    inner: PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHRBuilder<
        'a,
    > {
        PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHRBuilder {
            inner: PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR {
                s_type: StructureType::from_raw(1000336000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHRBuilder<'a> {
    #[inline]
    pub fn workgroup_memory_explicit_layout(mut self, value: bool) -> Self {
        self.inner.workgroup_memory_explicit_layout = value as u32;
        self
    }
    #[inline]
    pub fn workgroup_memory_explicit_layout_scalar_block_layout(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.workgroup_memory_explicit_layout_scalar_block_layout = value as u32;
        self
    }
    #[inline]
    pub fn workgroup_memory_explicit_layout8_bit_access(mut self, value: bool) -> Self {
        self.inner.workgroup_memory_explicit_layout8_bit_access = value as u32;
        self
    }
    #[inline]
    pub fn workgroup_memory_explicit_layout16_bit_access(mut self, value: bool) -> Self {
        self.inner.workgroup_memory_explicit_layout16_bit_access = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHRBuilder<'a> {
    type Target = PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDevicePortabilitySubsetFeaturesKHR`] with lifetime-tied pNext safety.
pub struct PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'a> {
    inner: PhysicalDevicePortabilitySubsetFeaturesKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDevicePortabilitySubsetFeaturesKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'a> {
        PhysicalDevicePortabilitySubsetFeaturesKHRBuilder {
            inner: PhysicalDevicePortabilitySubsetFeaturesKHR {
                s_type: StructureType::from_raw(1000163000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'a> {
    #[inline]
    pub fn constant_alpha_color_blend_factors(mut self, value: bool) -> Self {
        self.inner.constant_alpha_color_blend_factors = value as u32;
        self
    }
    #[inline]
    pub fn events(mut self, value: bool) -> Self {
        self.inner.events = value as u32;
        self
    }
    #[inline]
    pub fn image_view_format_reinterpretation(mut self, value: bool) -> Self {
        self.inner.image_view_format_reinterpretation = value as u32;
        self
    }
    #[inline]
    pub fn image_view_format_swizzle(mut self, value: bool) -> Self {
        self.inner.image_view_format_swizzle = value as u32;
        self
    }
    #[inline]
    pub fn image_view2_d_on3_d_image(mut self, value: bool) -> Self {
        self.inner.image_view2_d_on3_d_image = value as u32;
        self
    }
    #[inline]
    pub fn multisample_array_image(mut self, value: bool) -> Self {
        self.inner.multisample_array_image = value as u32;
        self
    }
    #[inline]
    pub fn mutable_comparison_samplers(mut self, value: bool) -> Self {
        self.inner.mutable_comparison_samplers = value as u32;
        self
    }
    #[inline]
    pub fn point_polygons(mut self, value: bool) -> Self {
        self.inner.point_polygons = value as u32;
        self
    }
    #[inline]
    pub fn sampler_mip_lod_bias(mut self, value: bool) -> Self {
        self.inner.sampler_mip_lod_bias = value as u32;
        self
    }
    #[inline]
    pub fn separate_stencil_mask_ref(mut self, value: bool) -> Self {
        self.inner.separate_stencil_mask_ref = value as u32;
        self
    }
    #[inline]
    pub fn shader_sample_rate_interpolation_functions(mut self, value: bool) -> Self {
        self.inner.shader_sample_rate_interpolation_functions = value as u32;
        self
    }
    #[inline]
    pub fn tessellation_isolines(mut self, value: bool) -> Self {
        self.inner.tessellation_isolines = value as u32;
        self
    }
    #[inline]
    pub fn tessellation_point_mode(mut self, value: bool) -> Self {
        self.inner.tessellation_point_mode = value as u32;
        self
    }
    #[inline]
    pub fn triangle_fans(mut self, value: bool) -> Self {
        self.inner.triangle_fans = value as u32;
        self
    }
    #[inline]
    pub fn vertex_attribute_access_beyond_stride(mut self, value: bool) -> Self {
        self.inner.vertex_attribute_access_beyond_stride = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDevicePortabilitySubsetFeaturesKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDevicePortabilitySubsetFeaturesKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'a> {
    type Target = PhysicalDevicePortabilitySubsetFeaturesKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDevicePortabilitySubsetPropertiesKHR`] with lifetime-tied pNext safety.
pub struct PhysicalDevicePortabilitySubsetPropertiesKHRBuilder<'a> {
    inner: PhysicalDevicePortabilitySubsetPropertiesKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDevicePortabilitySubsetPropertiesKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDevicePortabilitySubsetPropertiesKHRBuilder<'a> {
        PhysicalDevicePortabilitySubsetPropertiesKHRBuilder {
            inner: PhysicalDevicePortabilitySubsetPropertiesKHR {
                s_type: StructureType::from_raw(1000163001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDevicePortabilitySubsetPropertiesKHRBuilder<'a> {
    #[inline]
    pub fn min_vertex_input_binding_stride_alignment(mut self, value: u32) -> Self {
        self.inner.min_vertex_input_binding_stride_alignment = value;
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDevicePortabilitySubsetPropertiesKHRBuilder<'a> {
    type Target = PhysicalDevicePortabilitySubsetPropertiesKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDevicePortabilitySubsetPropertiesKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDevice4444FormatsFeaturesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDevice4444FormatsFeaturesEXTBuilder<'a> {
    inner: PhysicalDevice4444FormatsFeaturesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDevice4444FormatsFeaturesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDevice4444FormatsFeaturesEXTBuilder<'a> {
        PhysicalDevice4444FormatsFeaturesEXTBuilder {
            inner: PhysicalDevice4444FormatsFeaturesEXT {
                s_type: StructureType::from_raw(1000340000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDevice4444FormatsFeaturesEXTBuilder<'a> {
    #[inline]
    pub fn format_a4r4g4b4(mut self, value: bool) -> Self {
        self.inner.format_a4r4g4b4 = value as u32;
        self
    }
    #[inline]
    pub fn format_a4b4g4r4(mut self, value: bool) -> Self {
        self.inner.format_a4b4g4r4 = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDevice4444FormatsFeaturesEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDevice4444FormatsFeaturesEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDevice4444FormatsFeaturesEXTBuilder<'a> {
    type Target = PhysicalDevice4444FormatsFeaturesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDevice4444FormatsFeaturesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceSubpassShadingFeaturesHUAWEI`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceSubpassShadingFeaturesHUAWEIBuilder<'a> {
    inner: PhysicalDeviceSubpassShadingFeaturesHUAWEI,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceSubpassShadingFeaturesHUAWEI {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceSubpassShadingFeaturesHUAWEIBuilder<'a> {
        PhysicalDeviceSubpassShadingFeaturesHUAWEIBuilder {
            inner: PhysicalDeviceSubpassShadingFeaturesHUAWEI {
                s_type: StructureType::from_raw(1000369001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceSubpassShadingFeaturesHUAWEIBuilder<'a> {
    #[inline]
    pub fn subpass_shading(mut self, value: bool) -> Self {
        self.inner.subpass_shading = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceSubpassShadingFeaturesHUAWEI`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceSubpassShadingFeaturesHUAWEI>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceSubpassShadingFeaturesHUAWEIBuilder<'a> {
    type Target = PhysicalDeviceSubpassShadingFeaturesHUAWEI;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceSubpassShadingFeaturesHUAWEIBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceClusterCullingShaderFeaturesHUAWEI`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceClusterCullingShaderFeaturesHUAWEIBuilder<'a> {
    inner: PhysicalDeviceClusterCullingShaderFeaturesHUAWEI,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceClusterCullingShaderFeaturesHUAWEI {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceClusterCullingShaderFeaturesHUAWEIBuilder<'a> {
        PhysicalDeviceClusterCullingShaderFeaturesHUAWEIBuilder {
            inner: PhysicalDeviceClusterCullingShaderFeaturesHUAWEI {
                s_type: StructureType::from_raw(1000404000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceClusterCullingShaderFeaturesHUAWEIBuilder<'a> {
    #[inline]
    pub fn clusterculling_shader(mut self, value: bool) -> Self {
        self.inner.clusterculling_shader = value as u32;
        self
    }
    #[inline]
    pub fn multiview_cluster_culling_shader(mut self, value: bool) -> Self {
        self.inner.multiview_cluster_culling_shader = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceClusterCullingShaderFeaturesHUAWEI`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceClusterCullingShaderFeaturesHUAWEI>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDeviceClusterCullingShaderFeaturesHUAWEIBuilder<'a> {
    type Target = PhysicalDeviceClusterCullingShaderFeaturesHUAWEI;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceClusterCullingShaderFeaturesHUAWEIBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEIBuilder<'a> {
    inner: PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEIBuilder<
        'a,
    > {
        PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEIBuilder {
            inner: PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI {
                s_type: StructureType::from_raw(1000404002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEIBuilder<'a> {
    #[inline]
    pub fn cluster_shading_rate(mut self, value: bool) -> Self {
        self.inner.cluster_shading_rate = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEIBuilder<'a> {
    type Target = PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEIBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`BufferCopy2`] with lifetime-tied pNext safety.
pub struct BufferCopy2Builder<'a> {
    inner: BufferCopy2,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl BufferCopy2 {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> BufferCopy2Builder<'a> {
        BufferCopy2Builder {
            inner: BufferCopy2 {
                s_type: StructureType::from_raw(1000337006i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> BufferCopy2Builder<'a> {
    #[inline]
    pub fn src_offset(mut self, value: u64) -> Self {
        self.inner.src_offset = value;
        self
    }
    #[inline]
    pub fn dst_offset(mut self, value: u64) -> Self {
        self.inner.dst_offset = value;
        self
    }
    #[inline]
    pub fn size(mut self, value: u64) -> Self {
        self.inner.size = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`BufferCopy2`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsBufferCopy2>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for BufferCopy2Builder<'a> {
    type Target = BufferCopy2;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for BufferCopy2Builder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ImageCopy2`] with lifetime-tied pNext safety.
pub struct ImageCopy2Builder<'a> {
    inner: ImageCopy2,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ImageCopy2 {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ImageCopy2Builder<'a> {
        ImageCopy2Builder {
            inner: ImageCopy2 {
                s_type: StructureType::from_raw(1000337007i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ImageCopy2Builder<'a> {
    #[inline]
    pub fn src_subresource(mut self, value: ImageSubresourceLayers) -> Self {
        self.inner.src_subresource = value;
        self
    }
    #[inline]
    pub fn src_offset(mut self, value: Offset3D) -> Self {
        self.inner.src_offset = value;
        self
    }
    #[inline]
    pub fn dst_subresource(mut self, value: ImageSubresourceLayers) -> Self {
        self.inner.dst_subresource = value;
        self
    }
    #[inline]
    pub fn dst_offset(mut self, value: Offset3D) -> Self {
        self.inner.dst_offset = value;
        self
    }
    #[inline]
    pub fn extent(mut self, value: Extent3D) -> Self {
        self.inner.extent = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`ImageCopy2`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsImageCopy2>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for ImageCopy2Builder<'a> {
    type Target = ImageCopy2;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ImageCopy2Builder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ImageBlit2`] with lifetime-tied pNext safety.
pub struct ImageBlit2Builder<'a> {
    inner: ImageBlit2,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ImageBlit2 {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ImageBlit2Builder<'a> {
        ImageBlit2Builder {
            inner: ImageBlit2 {
                s_type: StructureType::from_raw(1000337008i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ImageBlit2Builder<'a> {
    #[inline]
    pub fn src_subresource(mut self, value: ImageSubresourceLayers) -> Self {
        self.inner.src_subresource = value;
        self
    }
    #[inline]
    pub fn src_offsets(mut self, value: [Offset3D; 2usize]) -> Self {
        self.inner.src_offsets = value;
        self
    }
    #[inline]
    pub fn dst_subresource(mut self, value: ImageSubresourceLayers) -> Self {
        self.inner.dst_subresource = value;
        self
    }
    #[inline]
    pub fn dst_offsets(mut self, value: [Offset3D; 2usize]) -> Self {
        self.inner.dst_offsets = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`ImageBlit2`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsImageBlit2>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for ImageBlit2Builder<'a> {
    type Target = ImageBlit2;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ImageBlit2Builder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`BufferImageCopy2`] with lifetime-tied pNext safety.
pub struct BufferImageCopy2Builder<'a> {
    inner: BufferImageCopy2,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl BufferImageCopy2 {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> BufferImageCopy2Builder<'a> {
        BufferImageCopy2Builder {
            inner: BufferImageCopy2 {
                s_type: StructureType::from_raw(1000337009i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> BufferImageCopy2Builder<'a> {
    #[inline]
    pub fn buffer_offset(mut self, value: u64) -> Self {
        self.inner.buffer_offset = value;
        self
    }
    #[inline]
    pub fn buffer_row_length(mut self, value: u32) -> Self {
        self.inner.buffer_row_length = value;
        self
    }
    #[inline]
    pub fn buffer_image_height(mut self, value: u32) -> Self {
        self.inner.buffer_image_height = value;
        self
    }
    #[inline]
    pub fn image_subresource(mut self, value: ImageSubresourceLayers) -> Self {
        self.inner.image_subresource = value;
        self
    }
    #[inline]
    pub fn image_offset(mut self, value: Offset3D) -> Self {
        self.inner.image_offset = value;
        self
    }
    #[inline]
    pub fn image_extent(mut self, value: Extent3D) -> Self {
        self.inner.image_extent = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`BufferImageCopy2`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsBufferImageCopy2>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for BufferImageCopy2Builder<'a> {
    type Target = BufferImageCopy2;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for BufferImageCopy2Builder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ImageResolve2`] with lifetime-tied pNext safety.
pub struct ImageResolve2Builder<'a> {
    inner: ImageResolve2,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ImageResolve2 {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ImageResolve2Builder<'a> {
        ImageResolve2Builder {
            inner: ImageResolve2 {
                s_type: StructureType::from_raw(1000337010i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ImageResolve2Builder<'a> {
    #[inline]
    pub fn src_subresource(mut self, value: ImageSubresourceLayers) -> Self {
        self.inner.src_subresource = value;
        self
    }
    #[inline]
    pub fn src_offset(mut self, value: Offset3D) -> Self {
        self.inner.src_offset = value;
        self
    }
    #[inline]
    pub fn dst_subresource(mut self, value: ImageSubresourceLayers) -> Self {
        self.inner.dst_subresource = value;
        self
    }
    #[inline]
    pub fn dst_offset(mut self, value: Offset3D) -> Self {
        self.inner.dst_offset = value;
        self
    }
    #[inline]
    pub fn extent(mut self, value: Extent3D) -> Self {
        self.inner.extent = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`ImageResolve2`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsImageResolve2>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for ImageResolve2Builder<'a> {
    type Target = ImageResolve2;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ImageResolve2Builder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`CopyBufferInfo2`] with lifetime-tied pNext safety.
pub struct CopyBufferInfo2Builder<'a> {
    inner: CopyBufferInfo2,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl CopyBufferInfo2 {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> CopyBufferInfo2Builder<'a> {
        CopyBufferInfo2Builder {
            inner: CopyBufferInfo2 {
                s_type: StructureType::from_raw(1000337000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> CopyBufferInfo2Builder<'a> {
    #[inline]
    pub fn src_buffer(mut self, value: Buffer) -> Self {
        self.inner.src_buffer = value;
        self
    }
    #[inline]
    pub fn dst_buffer(mut self, value: Buffer) -> Self {
        self.inner.dst_buffer = value;
        self
    }
    #[inline]
    pub fn regions(mut self, slice: &'a [BufferCopy2]) -> Self {
        self.inner.region_count = slice.len() as u32;
        self.inner.p_regions = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`CopyBufferInfo2`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsCopyBufferInfo2>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for CopyBufferInfo2Builder<'a> {
    type Target = CopyBufferInfo2;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for CopyBufferInfo2Builder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`CopyImageInfo2`] with lifetime-tied pNext safety.
pub struct CopyImageInfo2Builder<'a> {
    inner: CopyImageInfo2,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl CopyImageInfo2 {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> CopyImageInfo2Builder<'a> {
        CopyImageInfo2Builder {
            inner: CopyImageInfo2 {
                s_type: StructureType::from_raw(1000337001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> CopyImageInfo2Builder<'a> {
    #[inline]
    pub fn src_image(mut self, value: Image) -> Self {
        self.inner.src_image = value;
        self
    }
    #[inline]
    pub fn src_image_layout(mut self, value: ImageLayout) -> Self {
        self.inner.src_image_layout = value;
        self
    }
    #[inline]
    pub fn dst_image(mut self, value: Image) -> Self {
        self.inner.dst_image = value;
        self
    }
    #[inline]
    pub fn dst_image_layout(mut self, value: ImageLayout) -> Self {
        self.inner.dst_image_layout = value;
        self
    }
    #[inline]
    pub fn regions(mut self, slice: &'a [ImageCopy2]) -> Self {
        self.inner.region_count = slice.len() as u32;
        self.inner.p_regions = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`CopyImageInfo2`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsCopyImageInfo2>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for CopyImageInfo2Builder<'a> {
    type Target = CopyImageInfo2;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for CopyImageInfo2Builder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`BlitImageInfo2`] with lifetime-tied pNext safety.
pub struct BlitImageInfo2Builder<'a> {
    inner: BlitImageInfo2,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl BlitImageInfo2 {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> BlitImageInfo2Builder<'a> {
        BlitImageInfo2Builder {
            inner: BlitImageInfo2 {
                s_type: StructureType::from_raw(1000337004i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> BlitImageInfo2Builder<'a> {
    #[inline]
    pub fn src_image(mut self, value: Image) -> Self {
        self.inner.src_image = value;
        self
    }
    #[inline]
    pub fn src_image_layout(mut self, value: ImageLayout) -> Self {
        self.inner.src_image_layout = value;
        self
    }
    #[inline]
    pub fn dst_image(mut self, value: Image) -> Self {
        self.inner.dst_image = value;
        self
    }
    #[inline]
    pub fn dst_image_layout(mut self, value: ImageLayout) -> Self {
        self.inner.dst_image_layout = value;
        self
    }
    #[inline]
    pub fn regions(mut self, slice: &'a [ImageBlit2]) -> Self {
        self.inner.region_count = slice.len() as u32;
        self.inner.p_regions = slice.as_ptr();
        self
    }
    #[inline]
    pub fn filter(mut self, value: Filter) -> Self {
        self.inner.filter = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`BlitImageInfo2`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsBlitImageInfo2>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for BlitImageInfo2Builder<'a> {
    type Target = BlitImageInfo2;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for BlitImageInfo2Builder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`CopyBufferToImageInfo2`] with lifetime-tied pNext safety.
pub struct CopyBufferToImageInfo2Builder<'a> {
    inner: CopyBufferToImageInfo2,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl CopyBufferToImageInfo2 {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> CopyBufferToImageInfo2Builder<'a> {
        CopyBufferToImageInfo2Builder {
            inner: CopyBufferToImageInfo2 {
                s_type: StructureType::from_raw(1000337002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> CopyBufferToImageInfo2Builder<'a> {
    #[inline]
    pub fn src_buffer(mut self, value: Buffer) -> Self {
        self.inner.src_buffer = value;
        self
    }
    #[inline]
    pub fn dst_image(mut self, value: Image) -> Self {
        self.inner.dst_image = value;
        self
    }
    #[inline]
    pub fn dst_image_layout(mut self, value: ImageLayout) -> Self {
        self.inner.dst_image_layout = value;
        self
    }
    #[inline]
    pub fn regions(mut self, slice: &'a [BufferImageCopy2]) -> Self {
        self.inner.region_count = slice.len() as u32;
        self.inner.p_regions = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`CopyBufferToImageInfo2`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsCopyBufferToImageInfo2>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for CopyBufferToImageInfo2Builder<'a> {
    type Target = CopyBufferToImageInfo2;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for CopyBufferToImageInfo2Builder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`CopyImageToBufferInfo2`] with lifetime-tied pNext safety.
pub struct CopyImageToBufferInfo2Builder<'a> {
    inner: CopyImageToBufferInfo2,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl CopyImageToBufferInfo2 {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> CopyImageToBufferInfo2Builder<'a> {
        CopyImageToBufferInfo2Builder {
            inner: CopyImageToBufferInfo2 {
                s_type: StructureType::from_raw(1000337003i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> CopyImageToBufferInfo2Builder<'a> {
    #[inline]
    pub fn src_image(mut self, value: Image) -> Self {
        self.inner.src_image = value;
        self
    }
    #[inline]
    pub fn src_image_layout(mut self, value: ImageLayout) -> Self {
        self.inner.src_image_layout = value;
        self
    }
    #[inline]
    pub fn dst_buffer(mut self, value: Buffer) -> Self {
        self.inner.dst_buffer = value;
        self
    }
    #[inline]
    pub fn regions(mut self, slice: &'a [BufferImageCopy2]) -> Self {
        self.inner.region_count = slice.len() as u32;
        self.inner.p_regions = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`CopyImageToBufferInfo2`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsCopyImageToBufferInfo2>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for CopyImageToBufferInfo2Builder<'a> {
    type Target = CopyImageToBufferInfo2;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for CopyImageToBufferInfo2Builder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ResolveImageInfo2`] with lifetime-tied pNext safety.
pub struct ResolveImageInfo2Builder<'a> {
    inner: ResolveImageInfo2,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ResolveImageInfo2 {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ResolveImageInfo2Builder<'a> {
        ResolveImageInfo2Builder {
            inner: ResolveImageInfo2 {
                s_type: StructureType::from_raw(1000337005i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ResolveImageInfo2Builder<'a> {
    #[inline]
    pub fn src_image(mut self, value: Image) -> Self {
        self.inner.src_image = value;
        self
    }
    #[inline]
    pub fn src_image_layout(mut self, value: ImageLayout) -> Self {
        self.inner.src_image_layout = value;
        self
    }
    #[inline]
    pub fn dst_image(mut self, value: Image) -> Self {
        self.inner.dst_image = value;
        self
    }
    #[inline]
    pub fn dst_image_layout(mut self, value: ImageLayout) -> Self {
        self.inner.dst_image_layout = value;
        self
    }
    #[inline]
    pub fn regions(mut self, slice: &'a [ImageResolve2]) -> Self {
        self.inner.region_count = slice.len() as u32;
        self.inner.p_regions = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`ResolveImageInfo2`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsResolveImageInfo2>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for ResolveImageInfo2Builder<'a> {
    type Target = ResolveImageInfo2;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ResolveImageInfo2Builder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceShaderImageAtomicInt64FeaturesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceShaderImageAtomicInt64FeaturesEXTBuilder<'a> {
    inner: PhysicalDeviceShaderImageAtomicInt64FeaturesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceShaderImageAtomicInt64FeaturesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceShaderImageAtomicInt64FeaturesEXTBuilder<'a> {
        PhysicalDeviceShaderImageAtomicInt64FeaturesEXTBuilder {
            inner: PhysicalDeviceShaderImageAtomicInt64FeaturesEXT {
                s_type: StructureType::from_raw(1000234000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceShaderImageAtomicInt64FeaturesEXTBuilder<'a> {
    #[inline]
    pub fn shader_image_int64_atomics(mut self, value: bool) -> Self {
        self.inner.shader_image_int64_atomics = value as u32;
        self
    }
    #[inline]
    pub fn sparse_image_int64_atomics(mut self, value: bool) -> Self {
        self.inner.sparse_image_int64_atomics = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceShaderImageAtomicInt64FeaturesEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceShaderImageAtomicInt64FeaturesEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDeviceShaderImageAtomicInt64FeaturesEXTBuilder<'a> {
    type Target = PhysicalDeviceShaderImageAtomicInt64FeaturesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceShaderImageAtomicInt64FeaturesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`FragmentShadingRateAttachmentInfoKHR`] with lifetime-tied pNext safety.
pub struct FragmentShadingRateAttachmentInfoKHRBuilder<'a> {
    inner: FragmentShadingRateAttachmentInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl FragmentShadingRateAttachmentInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> FragmentShadingRateAttachmentInfoKHRBuilder<'a> {
        FragmentShadingRateAttachmentInfoKHRBuilder {
            inner: FragmentShadingRateAttachmentInfoKHR {
                s_type: StructureType::from_raw(1000226000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> FragmentShadingRateAttachmentInfoKHRBuilder<'a> {
    #[inline]
    pub fn fragment_shading_rate_attachment(
        mut self,
        value: &'a AttachmentReference2,
    ) -> Self {
        self.inner.p_fragment_shading_rate_attachment = value;
        self
    }
    #[inline]
    pub fn shading_rate_attachment_texel_size(mut self, value: Extent2D) -> Self {
        self.inner.shading_rate_attachment_texel_size = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`FragmentShadingRateAttachmentInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsFragmentShadingRateAttachmentInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for FragmentShadingRateAttachmentInfoKHRBuilder<'a> {
    type Target = FragmentShadingRateAttachmentInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for FragmentShadingRateAttachmentInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PipelineFragmentShadingRateStateCreateInfoKHR`] with lifetime-tied pNext safety.
pub struct PipelineFragmentShadingRateStateCreateInfoKHRBuilder<'a> {
    inner: PipelineFragmentShadingRateStateCreateInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PipelineFragmentShadingRateStateCreateInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PipelineFragmentShadingRateStateCreateInfoKHRBuilder<'a> {
        PipelineFragmentShadingRateStateCreateInfoKHRBuilder {
            inner: PipelineFragmentShadingRateStateCreateInfoKHR {
                s_type: StructureType::from_raw(1000226001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PipelineFragmentShadingRateStateCreateInfoKHRBuilder<'a> {
    #[inline]
    pub fn fragment_size(mut self, value: Extent2D) -> Self {
        self.inner.fragment_size = value;
        self
    }
    #[inline]
    pub fn combiner_ops(
        mut self,
        value: [FragmentShadingRateCombinerOpKHR; 2usize],
    ) -> Self {
        self.inner.combiner_ops = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PipelineFragmentShadingRateStateCreateInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPipelineFragmentShadingRateStateCreateInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for PipelineFragmentShadingRateStateCreateInfoKHRBuilder<'a> {
    type Target = PipelineFragmentShadingRateStateCreateInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PipelineFragmentShadingRateStateCreateInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceFragmentShadingRateFeaturesKHR`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceFragmentShadingRateFeaturesKHRBuilder<'a> {
    inner: PhysicalDeviceFragmentShadingRateFeaturesKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceFragmentShadingRateFeaturesKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceFragmentShadingRateFeaturesKHRBuilder<'a> {
        PhysicalDeviceFragmentShadingRateFeaturesKHRBuilder {
            inner: PhysicalDeviceFragmentShadingRateFeaturesKHR {
                s_type: StructureType::from_raw(1000226003i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceFragmentShadingRateFeaturesKHRBuilder<'a> {
    #[inline]
    pub fn pipeline_fragment_shading_rate(mut self, value: bool) -> Self {
        self.inner.pipeline_fragment_shading_rate = value as u32;
        self
    }
    #[inline]
    pub fn primitive_fragment_shading_rate(mut self, value: bool) -> Self {
        self.inner.primitive_fragment_shading_rate = value as u32;
        self
    }
    #[inline]
    pub fn attachment_fragment_shading_rate(mut self, value: bool) -> Self {
        self.inner.attachment_fragment_shading_rate = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceFragmentShadingRateFeaturesKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceFragmentShadingRateFeaturesKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceFragmentShadingRateFeaturesKHRBuilder<'a> {
    type Target = PhysicalDeviceFragmentShadingRateFeaturesKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceFragmentShadingRateFeaturesKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceFragmentShadingRatePropertiesKHR`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a> {
    inner: PhysicalDeviceFragmentShadingRatePropertiesKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceFragmentShadingRatePropertiesKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a> {
        PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder {
            inner: PhysicalDeviceFragmentShadingRatePropertiesKHR {
                s_type: StructureType::from_raw(1000226002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a> {
    #[inline]
    pub fn min_fragment_shading_rate_attachment_texel_size(
        mut self,
        value: Extent2D,
    ) -> Self {
        self.inner.min_fragment_shading_rate_attachment_texel_size = value;
        self
    }
    #[inline]
    pub fn max_fragment_shading_rate_attachment_texel_size(
        mut self,
        value: Extent2D,
    ) -> Self {
        self.inner.max_fragment_shading_rate_attachment_texel_size = value;
        self
    }
    #[inline]
    pub fn max_fragment_shading_rate_attachment_texel_size_aspect_ratio(
        mut self,
        value: u32,
    ) -> Self {
        self.inner.max_fragment_shading_rate_attachment_texel_size_aspect_ratio = value;
        self
    }
    #[inline]
    pub fn primitive_fragment_shading_rate_with_multiple_viewports(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.primitive_fragment_shading_rate_with_multiple_viewports = value
            as u32;
        self
    }
    #[inline]
    pub fn layered_shading_rate_attachments(mut self, value: bool) -> Self {
        self.inner.layered_shading_rate_attachments = value as u32;
        self
    }
    #[inline]
    pub fn fragment_shading_rate_non_trivial_combiner_ops(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.fragment_shading_rate_non_trivial_combiner_ops = value as u32;
        self
    }
    #[inline]
    pub fn max_fragment_size(mut self, value: Extent2D) -> Self {
        self.inner.max_fragment_size = value;
        self
    }
    #[inline]
    pub fn max_fragment_size_aspect_ratio(mut self, value: u32) -> Self {
        self.inner.max_fragment_size_aspect_ratio = value;
        self
    }
    #[inline]
    pub fn max_fragment_shading_rate_coverage_samples(mut self, value: u32) -> Self {
        self.inner.max_fragment_shading_rate_coverage_samples = value;
        self
    }
    #[inline]
    pub fn max_fragment_shading_rate_rasterization_samples(
        mut self,
        value: SampleCountFlagBits,
    ) -> Self {
        self.inner.max_fragment_shading_rate_rasterization_samples = value;
        self
    }
    #[inline]
    pub fn fragment_shading_rate_with_shader_depth_stencil_writes(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.fragment_shading_rate_with_shader_depth_stencil_writes = value as u32;
        self
    }
    #[inline]
    pub fn fragment_shading_rate_with_sample_mask(mut self, value: bool) -> Self {
        self.inner.fragment_shading_rate_with_sample_mask = value as u32;
        self
    }
    #[inline]
    pub fn fragment_shading_rate_with_shader_sample_mask(mut self, value: bool) -> Self {
        self.inner.fragment_shading_rate_with_shader_sample_mask = value as u32;
        self
    }
    #[inline]
    pub fn fragment_shading_rate_with_conservative_rasterization(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.fragment_shading_rate_with_conservative_rasterization = value as u32;
        self
    }
    #[inline]
    pub fn fragment_shading_rate_with_fragment_shader_interlock(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.fragment_shading_rate_with_fragment_shader_interlock = value as u32;
        self
    }
    #[inline]
    pub fn fragment_shading_rate_with_custom_sample_locations(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.fragment_shading_rate_with_custom_sample_locations = value as u32;
        self
    }
    #[inline]
    pub fn fragment_shading_rate_strict_multiply_combiner(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.fragment_shading_rate_strict_multiply_combiner = value as u32;
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a> {
    type Target = PhysicalDeviceFragmentShadingRatePropertiesKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceFragmentShadingRateKHR`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceFragmentShadingRateKHRBuilder<'a> {
    inner: PhysicalDeviceFragmentShadingRateKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceFragmentShadingRateKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceFragmentShadingRateKHRBuilder<'a> {
        PhysicalDeviceFragmentShadingRateKHRBuilder {
            inner: PhysicalDeviceFragmentShadingRateKHR {
                s_type: StructureType::from_raw(1000226004i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceFragmentShadingRateKHRBuilder<'a> {
    #[inline]
    pub fn sample_counts(mut self, value: SampleCountFlags) -> Self {
        self.inner.sample_counts = value;
        self
    }
    #[inline]
    pub fn fragment_size(mut self, value: Extent2D) -> Self {
        self.inner.fragment_size = value;
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceFragmentShadingRateKHRBuilder<'a> {
    type Target = PhysicalDeviceFragmentShadingRateKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceFragmentShadingRateKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceShaderTerminateInvocationFeatures`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceShaderTerminateInvocationFeaturesBuilder<'a> {
    inner: PhysicalDeviceShaderTerminateInvocationFeatures,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceShaderTerminateInvocationFeatures {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceShaderTerminateInvocationFeaturesBuilder<'a> {
        PhysicalDeviceShaderTerminateInvocationFeaturesBuilder {
            inner: PhysicalDeviceShaderTerminateInvocationFeatures {
                s_type: StructureType::from_raw(1000215000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceShaderTerminateInvocationFeaturesBuilder<'a> {
    #[inline]
    pub fn shader_terminate_invocation(mut self, value: bool) -> Self {
        self.inner.shader_terminate_invocation = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceShaderTerminateInvocationFeatures`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceShaderTerminateInvocationFeatures>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDeviceShaderTerminateInvocationFeaturesBuilder<'a> {
    type Target = PhysicalDeviceShaderTerminateInvocationFeatures;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceShaderTerminateInvocationFeaturesBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceFragmentShadingRateEnumsFeaturesNV`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceFragmentShadingRateEnumsFeaturesNVBuilder<'a> {
    inner: PhysicalDeviceFragmentShadingRateEnumsFeaturesNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceFragmentShadingRateEnumsFeaturesNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceFragmentShadingRateEnumsFeaturesNVBuilder<'a> {
        PhysicalDeviceFragmentShadingRateEnumsFeaturesNVBuilder {
            inner: PhysicalDeviceFragmentShadingRateEnumsFeaturesNV {
                s_type: StructureType::from_raw(1000326001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceFragmentShadingRateEnumsFeaturesNVBuilder<'a> {
    #[inline]
    pub fn fragment_shading_rate_enums(mut self, value: bool) -> Self {
        self.inner.fragment_shading_rate_enums = value as u32;
        self
    }
    #[inline]
    pub fn supersample_fragment_shading_rates(mut self, value: bool) -> Self {
        self.inner.supersample_fragment_shading_rates = value as u32;
        self
    }
    #[inline]
    pub fn no_invocation_fragment_shading_rates(mut self, value: bool) -> Self {
        self.inner.no_invocation_fragment_shading_rates = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceFragmentShadingRateEnumsFeaturesNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceFragmentShadingRateEnumsFeaturesNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDeviceFragmentShadingRateEnumsFeaturesNVBuilder<'a> {
    type Target = PhysicalDeviceFragmentShadingRateEnumsFeaturesNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceFragmentShadingRateEnumsFeaturesNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceFragmentShadingRateEnumsPropertiesNV`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceFragmentShadingRateEnumsPropertiesNVBuilder<'a> {
    inner: PhysicalDeviceFragmentShadingRateEnumsPropertiesNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceFragmentShadingRateEnumsPropertiesNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceFragmentShadingRateEnumsPropertiesNVBuilder<
        'a,
    > {
        PhysicalDeviceFragmentShadingRateEnumsPropertiesNVBuilder {
            inner: PhysicalDeviceFragmentShadingRateEnumsPropertiesNV {
                s_type: StructureType::from_raw(1000326000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceFragmentShadingRateEnumsPropertiesNVBuilder<'a> {
    #[inline]
    pub fn max_fragment_shading_rate_invocation_count(
        mut self,
        value: SampleCountFlagBits,
    ) -> Self {
        self.inner.max_fragment_shading_rate_invocation_count = value;
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDeviceFragmentShadingRateEnumsPropertiesNVBuilder<'a> {
    type Target = PhysicalDeviceFragmentShadingRateEnumsPropertiesNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceFragmentShadingRateEnumsPropertiesNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PipelineFragmentShadingRateEnumStateCreateInfoNV`] with lifetime-tied pNext safety.
pub struct PipelineFragmentShadingRateEnumStateCreateInfoNVBuilder<'a> {
    inner: PipelineFragmentShadingRateEnumStateCreateInfoNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PipelineFragmentShadingRateEnumStateCreateInfoNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PipelineFragmentShadingRateEnumStateCreateInfoNVBuilder<'a> {
        PipelineFragmentShadingRateEnumStateCreateInfoNVBuilder {
            inner: PipelineFragmentShadingRateEnumStateCreateInfoNV {
                s_type: StructureType::from_raw(1000326002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PipelineFragmentShadingRateEnumStateCreateInfoNVBuilder<'a> {
    #[inline]
    pub fn shading_rate_type(mut self, value: FragmentShadingRateTypeNV) -> Self {
        self.inner.shading_rate_type = value;
        self
    }
    #[inline]
    pub fn shading_rate(mut self, value: FragmentShadingRateNV) -> Self {
        self.inner.shading_rate = value;
        self
    }
    #[inline]
    pub fn combiner_ops(
        mut self,
        value: [FragmentShadingRateCombinerOpKHR; 2usize],
    ) -> Self {
        self.inner.combiner_ops = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PipelineFragmentShadingRateEnumStateCreateInfoNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPipelineFragmentShadingRateEnumStateCreateInfoNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref
for PipelineFragmentShadingRateEnumStateCreateInfoNVBuilder<'a> {
    type Target = PipelineFragmentShadingRateEnumStateCreateInfoNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PipelineFragmentShadingRateEnumStateCreateInfoNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`AccelerationStructureBuildSizesInfoKHR`] with lifetime-tied pNext safety.
pub struct AccelerationStructureBuildSizesInfoKHRBuilder<'a> {
    inner: AccelerationStructureBuildSizesInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl AccelerationStructureBuildSizesInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> AccelerationStructureBuildSizesInfoKHRBuilder<'a> {
        AccelerationStructureBuildSizesInfoKHRBuilder {
            inner: AccelerationStructureBuildSizesInfoKHR {
                s_type: StructureType::from_raw(1000150020i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> AccelerationStructureBuildSizesInfoKHRBuilder<'a> {
    #[inline]
    pub fn acceleration_structure_size(mut self, value: u64) -> Self {
        self.inner.acceleration_structure_size = value;
        self
    }
    #[inline]
    pub fn update_scratch_size(mut self, value: u64) -> Self {
        self.inner.update_scratch_size = value;
        self
    }
    #[inline]
    pub fn build_scratch_size(mut self, value: u64) -> Self {
        self.inner.build_scratch_size = value;
        self
    }
}
impl<'a> core::ops::Deref for AccelerationStructureBuildSizesInfoKHRBuilder<'a> {
    type Target = AccelerationStructureBuildSizesInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for AccelerationStructureBuildSizesInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceImage2DViewOf3DFeaturesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceImage2DViewOf3DFeaturesEXTBuilder<'a> {
    inner: PhysicalDeviceImage2DViewOf3DFeaturesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceImage2DViewOf3DFeaturesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceImage2DViewOf3DFeaturesEXTBuilder<'a> {
        PhysicalDeviceImage2DViewOf3DFeaturesEXTBuilder {
            inner: PhysicalDeviceImage2DViewOf3DFeaturesEXT {
                s_type: StructureType::from_raw(1000393000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceImage2DViewOf3DFeaturesEXTBuilder<'a> {
    #[inline]
    pub fn image2_d_view_of3_d(mut self, value: bool) -> Self {
        self.inner.image2_d_view_of3_d = value as u32;
        self
    }
    #[inline]
    pub fn sampler2_d_view_of3_d(mut self, value: bool) -> Self {
        self.inner.sampler2_d_view_of3_d = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceImage2DViewOf3DFeaturesEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceImage2DViewOf3DFeaturesEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceImage2DViewOf3DFeaturesEXTBuilder<'a> {
    type Target = PhysicalDeviceImage2DViewOf3DFeaturesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceImage2DViewOf3DFeaturesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceImageSlicedViewOf3DFeaturesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceImageSlicedViewOf3DFeaturesEXTBuilder<'a> {
    inner: PhysicalDeviceImageSlicedViewOf3DFeaturesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceImageSlicedViewOf3DFeaturesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceImageSlicedViewOf3DFeaturesEXTBuilder<'a> {
        PhysicalDeviceImageSlicedViewOf3DFeaturesEXTBuilder {
            inner: PhysicalDeviceImageSlicedViewOf3DFeaturesEXT {
                s_type: StructureType::from_raw(1000418000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceImageSlicedViewOf3DFeaturesEXTBuilder<'a> {
    #[inline]
    pub fn image_sliced_view_of3_d(mut self, value: bool) -> Self {
        self.inner.image_sliced_view_of3_d = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceImageSlicedViewOf3DFeaturesEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceImageSlicedViewOf3DFeaturesEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceImageSlicedViewOf3DFeaturesEXTBuilder<'a> {
    type Target = PhysicalDeviceImageSlicedViewOf3DFeaturesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceImageSlicedViewOf3DFeaturesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXTBuilder<'a> {
    inner: PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXTBuilder<
        'a,
    > {
        PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXTBuilder {
            inner: PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT {
                s_type: StructureType::from_raw(1000524000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXTBuilder<'a> {
    #[inline]
    pub fn attachment_feedback_loop_dynamic_state(mut self, value: bool) -> Self {
        self.inner.attachment_feedback_loop_dynamic_state = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<
        T: ExtendsPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT,
    >(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXTBuilder<'a> {
    type Target = PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceLegacyVertexAttributesFeaturesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceLegacyVertexAttributesFeaturesEXTBuilder<'a> {
    inner: PhysicalDeviceLegacyVertexAttributesFeaturesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceLegacyVertexAttributesFeaturesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceLegacyVertexAttributesFeaturesEXTBuilder<'a> {
        PhysicalDeviceLegacyVertexAttributesFeaturesEXTBuilder {
            inner: PhysicalDeviceLegacyVertexAttributesFeaturesEXT {
                s_type: StructureType::from_raw(1000495000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceLegacyVertexAttributesFeaturesEXTBuilder<'a> {
    #[inline]
    pub fn legacy_vertex_attributes(mut self, value: bool) -> Self {
        self.inner.legacy_vertex_attributes = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceLegacyVertexAttributesFeaturesEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceLegacyVertexAttributesFeaturesEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDeviceLegacyVertexAttributesFeaturesEXTBuilder<'a> {
    type Target = PhysicalDeviceLegacyVertexAttributesFeaturesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceLegacyVertexAttributesFeaturesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceLegacyVertexAttributesPropertiesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceLegacyVertexAttributesPropertiesEXTBuilder<'a> {
    inner: PhysicalDeviceLegacyVertexAttributesPropertiesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceLegacyVertexAttributesPropertiesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceLegacyVertexAttributesPropertiesEXTBuilder<
        'a,
    > {
        PhysicalDeviceLegacyVertexAttributesPropertiesEXTBuilder {
            inner: PhysicalDeviceLegacyVertexAttributesPropertiesEXT {
                s_type: StructureType::from_raw(1000495001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceLegacyVertexAttributesPropertiesEXTBuilder<'a> {
    #[inline]
    pub fn native_unaligned_performance(mut self, value: bool) -> Self {
        self.inner.native_unaligned_performance = value as u32;
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDeviceLegacyVertexAttributesPropertiesEXTBuilder<'a> {
    type Target = PhysicalDeviceLegacyVertexAttributesPropertiesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceLegacyVertexAttributesPropertiesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceMutableDescriptorTypeFeaturesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceMutableDescriptorTypeFeaturesEXTBuilder<'a> {
    inner: PhysicalDeviceMutableDescriptorTypeFeaturesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceMutableDescriptorTypeFeaturesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceMutableDescriptorTypeFeaturesEXTBuilder<'a> {
        PhysicalDeviceMutableDescriptorTypeFeaturesEXTBuilder {
            inner: PhysicalDeviceMutableDescriptorTypeFeaturesEXT {
                s_type: StructureType::from_raw(1000351000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceMutableDescriptorTypeFeaturesEXTBuilder<'a> {
    #[inline]
    pub fn mutable_descriptor_type(mut self, value: bool) -> Self {
        self.inner.mutable_descriptor_type = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceMutableDescriptorTypeFeaturesEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceMutableDescriptorTypeFeaturesEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceMutableDescriptorTypeFeaturesEXTBuilder<'a> {
    type Target = PhysicalDeviceMutableDescriptorTypeFeaturesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceMutableDescriptorTypeFeaturesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`MutableDescriptorTypeListEXT`].
pub struct MutableDescriptorTypeListEXTBuilder<'a> {
    inner: MutableDescriptorTypeListEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl MutableDescriptorTypeListEXT {
    /// Start building this struct.
    #[inline]
    pub fn builder<'a>() -> MutableDescriptorTypeListEXTBuilder<'a> {
        MutableDescriptorTypeListEXTBuilder {
            inner: MutableDescriptorTypeListEXT {
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> MutableDescriptorTypeListEXTBuilder<'a> {
    #[inline]
    pub fn descriptor_types(mut self, slice: &'a [DescriptorType]) -> Self {
        self.inner.descriptor_type_count = slice.len() as u32;
        self.inner.p_descriptor_types = slice.as_ptr();
        self
    }
}
impl<'a> core::ops::Deref for MutableDescriptorTypeListEXTBuilder<'a> {
    type Target = MutableDescriptorTypeListEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for MutableDescriptorTypeListEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`MutableDescriptorTypeCreateInfoEXT`] with lifetime-tied pNext safety.
pub struct MutableDescriptorTypeCreateInfoEXTBuilder<'a> {
    inner: MutableDescriptorTypeCreateInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl MutableDescriptorTypeCreateInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> MutableDescriptorTypeCreateInfoEXTBuilder<'a> {
        MutableDescriptorTypeCreateInfoEXTBuilder {
            inner: MutableDescriptorTypeCreateInfoEXT {
                s_type: StructureType::from_raw(1000351002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> MutableDescriptorTypeCreateInfoEXTBuilder<'a> {
    #[inline]
    pub fn mutable_descriptor_type_lists(
        mut self,
        slice: &'a [MutableDescriptorTypeListEXT],
    ) -> Self {
        self.inner.mutable_descriptor_type_list_count = slice.len() as u32;
        self.inner.p_mutable_descriptor_type_lists = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`MutableDescriptorTypeCreateInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsMutableDescriptorTypeCreateInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for MutableDescriptorTypeCreateInfoEXTBuilder<'a> {
    type Target = MutableDescriptorTypeCreateInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for MutableDescriptorTypeCreateInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceDepthClipControlFeaturesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceDepthClipControlFeaturesEXTBuilder<'a> {
    inner: PhysicalDeviceDepthClipControlFeaturesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceDepthClipControlFeaturesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceDepthClipControlFeaturesEXTBuilder<'a> {
        PhysicalDeviceDepthClipControlFeaturesEXTBuilder {
            inner: PhysicalDeviceDepthClipControlFeaturesEXT {
                s_type: StructureType::from_raw(1000355000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceDepthClipControlFeaturesEXTBuilder<'a> {
    #[inline]
    pub fn depth_clip_control(mut self, value: bool) -> Self {
        self.inner.depth_clip_control = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceDepthClipControlFeaturesEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceDepthClipControlFeaturesEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceDepthClipControlFeaturesEXTBuilder<'a> {
    type Target = PhysicalDeviceDepthClipControlFeaturesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceDepthClipControlFeaturesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXTBuilder<'a> {
    inner: PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXTBuilder<
        'a,
    > {
        PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXTBuilder {
            inner: PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT {
                s_type: StructureType::from_raw(1000620000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXTBuilder<'a> {
    #[inline]
    pub fn zero_initialize_device_memory(mut self, value: bool) -> Self {
        self.inner.zero_initialize_device_memory = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXTBuilder<'a> {
    type Target = PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`BeginCustomResolveInfoEXT`] with lifetime-tied pNext safety.
pub struct BeginCustomResolveInfoEXTBuilder<'a> {
    inner: BeginCustomResolveInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl BeginCustomResolveInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> BeginCustomResolveInfoEXTBuilder<'a> {
        BeginCustomResolveInfoEXTBuilder {
            inner: BeginCustomResolveInfoEXT {
                s_type: StructureType::from_raw(1000628001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> BeginCustomResolveInfoEXTBuilder<'a> {
    ///Prepend a struct to the pNext chain. See [`BeginCustomResolveInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsBeginCustomResolveInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for BeginCustomResolveInfoEXTBuilder<'a> {
    type Target = BeginCustomResolveInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for BeginCustomResolveInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceCustomResolveFeaturesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceCustomResolveFeaturesEXTBuilder<'a> {
    inner: PhysicalDeviceCustomResolveFeaturesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceCustomResolveFeaturesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceCustomResolveFeaturesEXTBuilder<'a> {
        PhysicalDeviceCustomResolveFeaturesEXTBuilder {
            inner: PhysicalDeviceCustomResolveFeaturesEXT {
                s_type: StructureType::from_raw(1000628000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceCustomResolveFeaturesEXTBuilder<'a> {
    #[inline]
    pub fn custom_resolve(mut self, value: bool) -> Self {
        self.inner.custom_resolve = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceCustomResolveFeaturesEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceCustomResolveFeaturesEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceCustomResolveFeaturesEXTBuilder<'a> {
    type Target = PhysicalDeviceCustomResolveFeaturesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceCustomResolveFeaturesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`CustomResolveCreateInfoEXT`] with lifetime-tied pNext safety.
pub struct CustomResolveCreateInfoEXTBuilder<'a> {
    inner: CustomResolveCreateInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl CustomResolveCreateInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> CustomResolveCreateInfoEXTBuilder<'a> {
        CustomResolveCreateInfoEXTBuilder {
            inner: CustomResolveCreateInfoEXT {
                s_type: StructureType::from_raw(1000628002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> CustomResolveCreateInfoEXTBuilder<'a> {
    #[inline]
    pub fn custom_resolve(mut self, value: bool) -> Self {
        self.inner.custom_resolve = value as u32;
        self
    }
    #[inline]
    pub fn color_attachment_formats(mut self, slice: &'a [Format]) -> Self {
        self.inner.color_attachment_count = slice.len() as u32;
        self.inner.p_color_attachment_formats = slice.as_ptr();
        self
    }
    #[inline]
    pub fn depth_attachment_format(mut self, value: Format) -> Self {
        self.inner.depth_attachment_format = value;
        self
    }
    #[inline]
    pub fn stencil_attachment_format(mut self, value: Format) -> Self {
        self.inner.stencil_attachment_format = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`CustomResolveCreateInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsCustomResolveCreateInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for CustomResolveCreateInfoEXTBuilder<'a> {
    type Target = CustomResolveCreateInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for CustomResolveCreateInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceDeviceGeneratedCommandsFeaturesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceDeviceGeneratedCommandsFeaturesEXTBuilder<'a> {
    inner: PhysicalDeviceDeviceGeneratedCommandsFeaturesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceDeviceGeneratedCommandsFeaturesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceDeviceGeneratedCommandsFeaturesEXTBuilder<'a> {
        PhysicalDeviceDeviceGeneratedCommandsFeaturesEXTBuilder {
            inner: PhysicalDeviceDeviceGeneratedCommandsFeaturesEXT {
                s_type: StructureType::from_raw(1000572000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceDeviceGeneratedCommandsFeaturesEXTBuilder<'a> {
    #[inline]
    pub fn device_generated_commands(mut self, value: bool) -> Self {
        self.inner.device_generated_commands = value as u32;
        self
    }
    #[inline]
    pub fn dynamic_generated_pipeline_layout(mut self, value: bool) -> Self {
        self.inner.dynamic_generated_pipeline_layout = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceDeviceGeneratedCommandsFeaturesEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDeviceDeviceGeneratedCommandsFeaturesEXTBuilder<'a> {
    type Target = PhysicalDeviceDeviceGeneratedCommandsFeaturesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceDeviceGeneratedCommandsFeaturesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceDeviceGeneratedCommandsPropertiesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceDeviceGeneratedCommandsPropertiesEXTBuilder<'a> {
    inner: PhysicalDeviceDeviceGeneratedCommandsPropertiesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceDeviceGeneratedCommandsPropertiesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceDeviceGeneratedCommandsPropertiesEXTBuilder<
        'a,
    > {
        PhysicalDeviceDeviceGeneratedCommandsPropertiesEXTBuilder {
            inner: PhysicalDeviceDeviceGeneratedCommandsPropertiesEXT {
                s_type: StructureType::from_raw(1000572001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceDeviceGeneratedCommandsPropertiesEXTBuilder<'a> {
    #[inline]
    pub fn max_indirect_pipeline_count(mut self, value: u32) -> Self {
        self.inner.max_indirect_pipeline_count = value;
        self
    }
    #[inline]
    pub fn max_indirect_shader_object_count(mut self, value: u32) -> Self {
        self.inner.max_indirect_shader_object_count = value;
        self
    }
    #[inline]
    pub fn max_indirect_sequence_count(mut self, value: u32) -> Self {
        self.inner.max_indirect_sequence_count = value;
        self
    }
    #[inline]
    pub fn max_indirect_commands_token_count(mut self, value: u32) -> Self {
        self.inner.max_indirect_commands_token_count = value;
        self
    }
    #[inline]
    pub fn max_indirect_commands_token_offset(mut self, value: u32) -> Self {
        self.inner.max_indirect_commands_token_offset = value;
        self
    }
    #[inline]
    pub fn max_indirect_commands_indirect_stride(mut self, value: u32) -> Self {
        self.inner.max_indirect_commands_indirect_stride = value;
        self
    }
    #[inline]
    pub fn supported_indirect_commands_input_modes(
        mut self,
        value: IndirectCommandsInputModeFlagsEXT,
    ) -> Self {
        self.inner.supported_indirect_commands_input_modes = value;
        self
    }
    #[inline]
    pub fn supported_indirect_commands_shader_stages(
        mut self,
        value: ShaderStageFlags,
    ) -> Self {
        self.inner.supported_indirect_commands_shader_stages = value;
        self
    }
    #[inline]
    pub fn supported_indirect_commands_shader_stages_pipeline_binding(
        mut self,
        value: ShaderStageFlags,
    ) -> Self {
        self.inner.supported_indirect_commands_shader_stages_pipeline_binding = value;
        self
    }
    #[inline]
    pub fn supported_indirect_commands_shader_stages_shader_binding(
        mut self,
        value: ShaderStageFlags,
    ) -> Self {
        self.inner.supported_indirect_commands_shader_stages_shader_binding = value;
        self
    }
    #[inline]
    pub fn device_generated_commands_transform_feedback(mut self, value: bool) -> Self {
        self.inner.device_generated_commands_transform_feedback = value as u32;
        self
    }
    #[inline]
    pub fn device_generated_commands_multi_draw_indirect_count(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.device_generated_commands_multi_draw_indirect_count = value as u32;
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDeviceDeviceGeneratedCommandsPropertiesEXTBuilder<'a> {
    type Target = PhysicalDeviceDeviceGeneratedCommandsPropertiesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceDeviceGeneratedCommandsPropertiesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`GeneratedCommandsPipelineInfoEXT`] with lifetime-tied pNext safety.
pub struct GeneratedCommandsPipelineInfoEXTBuilder<'a> {
    inner: GeneratedCommandsPipelineInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl GeneratedCommandsPipelineInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> GeneratedCommandsPipelineInfoEXTBuilder<'a> {
        GeneratedCommandsPipelineInfoEXTBuilder {
            inner: GeneratedCommandsPipelineInfoEXT {
                s_type: StructureType::from_raw(1000572013i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> GeneratedCommandsPipelineInfoEXTBuilder<'a> {
    #[inline]
    pub fn pipeline(mut self, value: Pipeline) -> Self {
        self.inner.pipeline = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`GeneratedCommandsPipelineInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsGeneratedCommandsPipelineInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for GeneratedCommandsPipelineInfoEXTBuilder<'a> {
    type Target = GeneratedCommandsPipelineInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for GeneratedCommandsPipelineInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`GeneratedCommandsShaderInfoEXT`] with lifetime-tied pNext safety.
pub struct GeneratedCommandsShaderInfoEXTBuilder<'a> {
    inner: GeneratedCommandsShaderInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl GeneratedCommandsShaderInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> GeneratedCommandsShaderInfoEXTBuilder<'a> {
        GeneratedCommandsShaderInfoEXTBuilder {
            inner: GeneratedCommandsShaderInfoEXT {
                s_type: StructureType::from_raw(1000572014i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> GeneratedCommandsShaderInfoEXTBuilder<'a> {
    #[inline]
    pub fn shaders(mut self, slice: &'a [ShaderEXT]) -> Self {
        self.inner.shader_count = slice.len() as u32;
        self.inner.p_shaders = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`GeneratedCommandsShaderInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsGeneratedCommandsShaderInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for GeneratedCommandsShaderInfoEXTBuilder<'a> {
    type Target = GeneratedCommandsShaderInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for GeneratedCommandsShaderInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`GeneratedCommandsMemoryRequirementsInfoEXT`] with lifetime-tied pNext safety.
pub struct GeneratedCommandsMemoryRequirementsInfoEXTBuilder<'a> {
    inner: GeneratedCommandsMemoryRequirementsInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl GeneratedCommandsMemoryRequirementsInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> GeneratedCommandsMemoryRequirementsInfoEXTBuilder<'a> {
        GeneratedCommandsMemoryRequirementsInfoEXTBuilder {
            inner: GeneratedCommandsMemoryRequirementsInfoEXT {
                s_type: StructureType::from_raw(1000572002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> GeneratedCommandsMemoryRequirementsInfoEXTBuilder<'a> {
    #[inline]
    pub fn indirect_execution_set(mut self, value: IndirectExecutionSetEXT) -> Self {
        self.inner.indirect_execution_set = value;
        self
    }
    #[inline]
    pub fn indirect_commands_layout(mut self, value: IndirectCommandsLayoutEXT) -> Self {
        self.inner.indirect_commands_layout = value;
        self
    }
    #[inline]
    pub fn max_sequence_count(mut self, value: u32) -> Self {
        self.inner.max_sequence_count = value;
        self
    }
    #[inline]
    pub fn max_draw_count(mut self, value: u32) -> Self {
        self.inner.max_draw_count = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`GeneratedCommandsMemoryRequirementsInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsGeneratedCommandsMemoryRequirementsInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for GeneratedCommandsMemoryRequirementsInfoEXTBuilder<'a> {
    type Target = GeneratedCommandsMemoryRequirementsInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for GeneratedCommandsMemoryRequirementsInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`IndirectExecutionSetPipelineInfoEXT`] with lifetime-tied pNext safety.
pub struct IndirectExecutionSetPipelineInfoEXTBuilder<'a> {
    inner: IndirectExecutionSetPipelineInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl IndirectExecutionSetPipelineInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> IndirectExecutionSetPipelineInfoEXTBuilder<'a> {
        IndirectExecutionSetPipelineInfoEXTBuilder {
            inner: IndirectExecutionSetPipelineInfoEXT {
                s_type: StructureType::from_raw(1000572010i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> IndirectExecutionSetPipelineInfoEXTBuilder<'a> {
    #[inline]
    pub fn initial_pipeline(mut self, value: Pipeline) -> Self {
        self.inner.initial_pipeline = value;
        self
    }
    #[inline]
    pub fn max_pipeline_count(mut self, value: u32) -> Self {
        self.inner.max_pipeline_count = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`IndirectExecutionSetPipelineInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsIndirectExecutionSetPipelineInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for IndirectExecutionSetPipelineInfoEXTBuilder<'a> {
    type Target = IndirectExecutionSetPipelineInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for IndirectExecutionSetPipelineInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`IndirectExecutionSetShaderLayoutInfoEXT`] with lifetime-tied pNext safety.
pub struct IndirectExecutionSetShaderLayoutInfoEXTBuilder<'a> {
    inner: IndirectExecutionSetShaderLayoutInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl IndirectExecutionSetShaderLayoutInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> IndirectExecutionSetShaderLayoutInfoEXTBuilder<'a> {
        IndirectExecutionSetShaderLayoutInfoEXTBuilder {
            inner: IndirectExecutionSetShaderLayoutInfoEXT {
                s_type: StructureType::from_raw(1000572012i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> IndirectExecutionSetShaderLayoutInfoEXTBuilder<'a> {
    #[inline]
    pub fn set_layout_count(mut self, value: u32) -> Self {
        self.inner.set_layout_count = value;
        self
    }
    #[inline]
    pub fn set_layouts(mut self, slice: &'a [DescriptorSetLayout]) -> Self {
        self.inner.set_layout_count = slice.len() as u32;
        self.inner.p_set_layouts = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`IndirectExecutionSetShaderLayoutInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsIndirectExecutionSetShaderLayoutInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for IndirectExecutionSetShaderLayoutInfoEXTBuilder<'a> {
    type Target = IndirectExecutionSetShaderLayoutInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for IndirectExecutionSetShaderLayoutInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`IndirectExecutionSetShaderInfoEXT`] with lifetime-tied pNext safety.
pub struct IndirectExecutionSetShaderInfoEXTBuilder<'a> {
    inner: IndirectExecutionSetShaderInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl IndirectExecutionSetShaderInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> IndirectExecutionSetShaderInfoEXTBuilder<'a> {
        IndirectExecutionSetShaderInfoEXTBuilder {
            inner: IndirectExecutionSetShaderInfoEXT {
                s_type: StructureType::from_raw(1000572011i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> IndirectExecutionSetShaderInfoEXTBuilder<'a> {
    #[inline]
    pub fn initial_shaders(mut self, slice: &'a [ShaderEXT]) -> Self {
        self.inner.shader_count = slice.len() as u32;
        self.inner.p_initial_shaders = slice.as_ptr();
        self
    }
    #[inline]
    pub fn set_layout_infos(
        mut self,
        slice: &'a [IndirectExecutionSetShaderLayoutInfoEXT],
    ) -> Self {
        self.inner.shader_count = slice.len() as u32;
        self.inner.p_set_layout_infos = slice.as_ptr();
        self
    }
    #[inline]
    pub fn max_shader_count(mut self, value: u32) -> Self {
        self.inner.max_shader_count = value;
        self
    }
    #[inline]
    pub fn push_constant_ranges(mut self, slice: &'a [PushConstantRange]) -> Self {
        self.inner.push_constant_range_count = slice.len() as u32;
        self.inner.p_push_constant_ranges = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`IndirectExecutionSetShaderInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsIndirectExecutionSetShaderInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for IndirectExecutionSetShaderInfoEXTBuilder<'a> {
    type Target = IndirectExecutionSetShaderInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for IndirectExecutionSetShaderInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`IndirectExecutionSetCreateInfoEXT`] with lifetime-tied pNext safety.
pub struct IndirectExecutionSetCreateInfoEXTBuilder<'a> {
    inner: IndirectExecutionSetCreateInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl IndirectExecutionSetCreateInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> IndirectExecutionSetCreateInfoEXTBuilder<'a> {
        IndirectExecutionSetCreateInfoEXTBuilder {
            inner: IndirectExecutionSetCreateInfoEXT {
                s_type: StructureType::from_raw(1000572003i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> IndirectExecutionSetCreateInfoEXTBuilder<'a> {
    #[inline]
    pub fn r#type(mut self, value: IndirectExecutionSetInfoTypeEXT) -> Self {
        self.inner.r#type = value;
        self
    }
    #[inline]
    pub fn info(mut self, value: IndirectExecutionSetInfoEXT) -> Self {
        self.inner.info = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`IndirectExecutionSetCreateInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsIndirectExecutionSetCreateInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for IndirectExecutionSetCreateInfoEXTBuilder<'a> {
    type Target = IndirectExecutionSetCreateInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for IndirectExecutionSetCreateInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`GeneratedCommandsInfoEXT`] with lifetime-tied pNext safety.
pub struct GeneratedCommandsInfoEXTBuilder<'a> {
    inner: GeneratedCommandsInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl GeneratedCommandsInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> GeneratedCommandsInfoEXTBuilder<'a> {
        GeneratedCommandsInfoEXTBuilder {
            inner: GeneratedCommandsInfoEXT {
                s_type: StructureType::from_raw(1000572004i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> GeneratedCommandsInfoEXTBuilder<'a> {
    #[inline]
    pub fn shader_stages(mut self, value: ShaderStageFlags) -> Self {
        self.inner.shader_stages = value;
        self
    }
    #[inline]
    pub fn indirect_execution_set(mut self, value: IndirectExecutionSetEXT) -> Self {
        self.inner.indirect_execution_set = value;
        self
    }
    #[inline]
    pub fn indirect_commands_layout(mut self, value: IndirectCommandsLayoutEXT) -> Self {
        self.inner.indirect_commands_layout = value;
        self
    }
    #[inline]
    pub fn indirect_address(mut self, value: u64) -> Self {
        self.inner.indirect_address = value;
        self
    }
    #[inline]
    pub fn indirect_address_size(mut self, value: u64) -> Self {
        self.inner.indirect_address_size = value;
        self
    }
    #[inline]
    pub fn preprocess_address(mut self, value: u64) -> Self {
        self.inner.preprocess_address = value;
        self
    }
    #[inline]
    pub fn preprocess_size(mut self, value: u64) -> Self {
        self.inner.preprocess_size = value;
        self
    }
    #[inline]
    pub fn max_sequence_count(mut self, value: u32) -> Self {
        self.inner.max_sequence_count = value;
        self
    }
    #[inline]
    pub fn sequence_count_address(mut self, value: u64) -> Self {
        self.inner.sequence_count_address = value;
        self
    }
    #[inline]
    pub fn max_draw_count(mut self, value: u32) -> Self {
        self.inner.max_draw_count = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`GeneratedCommandsInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsGeneratedCommandsInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for GeneratedCommandsInfoEXTBuilder<'a> {
    type Target = GeneratedCommandsInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for GeneratedCommandsInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`WriteIndirectExecutionSetPipelineEXT`] with lifetime-tied pNext safety.
pub struct WriteIndirectExecutionSetPipelineEXTBuilder<'a> {
    inner: WriteIndirectExecutionSetPipelineEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl WriteIndirectExecutionSetPipelineEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> WriteIndirectExecutionSetPipelineEXTBuilder<'a> {
        WriteIndirectExecutionSetPipelineEXTBuilder {
            inner: WriteIndirectExecutionSetPipelineEXT {
                s_type: StructureType::from_raw(1000572008i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> WriteIndirectExecutionSetPipelineEXTBuilder<'a> {
    #[inline]
    pub fn index(mut self, value: u32) -> Self {
        self.inner.index = value;
        self
    }
    #[inline]
    pub fn pipeline(mut self, value: Pipeline) -> Self {
        self.inner.pipeline = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`WriteIndirectExecutionSetPipelineEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsWriteIndirectExecutionSetPipelineEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for WriteIndirectExecutionSetPipelineEXTBuilder<'a> {
    type Target = WriteIndirectExecutionSetPipelineEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for WriteIndirectExecutionSetPipelineEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`WriteIndirectExecutionSetShaderEXT`] with lifetime-tied pNext safety.
pub struct WriteIndirectExecutionSetShaderEXTBuilder<'a> {
    inner: WriteIndirectExecutionSetShaderEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl WriteIndirectExecutionSetShaderEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> WriteIndirectExecutionSetShaderEXTBuilder<'a> {
        WriteIndirectExecutionSetShaderEXTBuilder {
            inner: WriteIndirectExecutionSetShaderEXT {
                s_type: StructureType::from_raw(1000572009i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> WriteIndirectExecutionSetShaderEXTBuilder<'a> {
    #[inline]
    pub fn index(mut self, value: u32) -> Self {
        self.inner.index = value;
        self
    }
    #[inline]
    pub fn shader(mut self, value: ShaderEXT) -> Self {
        self.inner.shader = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`WriteIndirectExecutionSetShaderEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsWriteIndirectExecutionSetShaderEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for WriteIndirectExecutionSetShaderEXTBuilder<'a> {
    type Target = WriteIndirectExecutionSetShaderEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for WriteIndirectExecutionSetShaderEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`IndirectCommandsLayoutCreateInfoEXT`] with lifetime-tied pNext safety.
pub struct IndirectCommandsLayoutCreateInfoEXTBuilder<'a> {
    inner: IndirectCommandsLayoutCreateInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl IndirectCommandsLayoutCreateInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> IndirectCommandsLayoutCreateInfoEXTBuilder<'a> {
        IndirectCommandsLayoutCreateInfoEXTBuilder {
            inner: IndirectCommandsLayoutCreateInfoEXT {
                s_type: StructureType::from_raw(1000572006i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> IndirectCommandsLayoutCreateInfoEXTBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: IndirectCommandsLayoutUsageFlagsEXT) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn shader_stages(mut self, value: ShaderStageFlags) -> Self {
        self.inner.shader_stages = value;
        self
    }
    #[inline]
    pub fn indirect_stride(mut self, value: u32) -> Self {
        self.inner.indirect_stride = value;
        self
    }
    #[inline]
    pub fn pipeline_layout(mut self, value: PipelineLayout) -> Self {
        self.inner.pipeline_layout = value;
        self
    }
    #[inline]
    pub fn tokens(mut self, slice: &'a [IndirectCommandsLayoutTokenEXT]) -> Self {
        self.inner.token_count = slice.len() as u32;
        self.inner.p_tokens = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`IndirectCommandsLayoutCreateInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsIndirectCommandsLayoutCreateInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for IndirectCommandsLayoutCreateInfoEXTBuilder<'a> {
    type Target = IndirectCommandsLayoutCreateInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for IndirectCommandsLayoutCreateInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`IndirectCommandsLayoutTokenEXT`] with lifetime-tied pNext safety.
pub struct IndirectCommandsLayoutTokenEXTBuilder<'a> {
    inner: IndirectCommandsLayoutTokenEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl IndirectCommandsLayoutTokenEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> IndirectCommandsLayoutTokenEXTBuilder<'a> {
        IndirectCommandsLayoutTokenEXTBuilder {
            inner: IndirectCommandsLayoutTokenEXT {
                s_type: StructureType::from_raw(1000572007i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> IndirectCommandsLayoutTokenEXTBuilder<'a> {
    #[inline]
    pub fn r#type(mut self, value: IndirectCommandsTokenTypeEXT) -> Self {
        self.inner.r#type = value;
        self
    }
    #[inline]
    pub fn data(mut self, value: IndirectCommandsTokenDataEXT) -> Self {
        self.inner.data = value;
        self
    }
    #[inline]
    pub fn offset(mut self, value: u32) -> Self {
        self.inner.offset = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`IndirectCommandsLayoutTokenEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsIndirectCommandsLayoutTokenEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for IndirectCommandsLayoutTokenEXTBuilder<'a> {
    type Target = IndirectCommandsLayoutTokenEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for IndirectCommandsLayoutTokenEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DrawIndirectCountIndirectCommandEXT`].
pub struct DrawIndirectCountIndirectCommandEXTBuilder {
    inner: DrawIndirectCountIndirectCommandEXT,
}
impl DrawIndirectCountIndirectCommandEXT {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> DrawIndirectCountIndirectCommandEXTBuilder {
        DrawIndirectCountIndirectCommandEXTBuilder {
            inner: DrawIndirectCountIndirectCommandEXT {
                ..Default::default()
            },
        }
    }
}
impl DrawIndirectCountIndirectCommandEXTBuilder {
    #[inline]
    pub fn buffer_address(mut self, value: u64) -> Self {
        self.inner.buffer_address = value;
        self
    }
    #[inline]
    pub fn stride(mut self, value: u32) -> Self {
        self.inner.stride = value;
        self
    }
    #[inline]
    pub fn command_count(mut self, value: u32) -> Self {
        self.inner.command_count = value;
        self
    }
}
impl core::ops::Deref for DrawIndirectCountIndirectCommandEXTBuilder {
    type Target = DrawIndirectCountIndirectCommandEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for DrawIndirectCountIndirectCommandEXTBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`IndirectCommandsVertexBufferTokenEXT`].
pub struct IndirectCommandsVertexBufferTokenEXTBuilder {
    inner: IndirectCommandsVertexBufferTokenEXT,
}
impl IndirectCommandsVertexBufferTokenEXT {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> IndirectCommandsVertexBufferTokenEXTBuilder {
        IndirectCommandsVertexBufferTokenEXTBuilder {
            inner: IndirectCommandsVertexBufferTokenEXT {
                ..Default::default()
            },
        }
    }
}
impl IndirectCommandsVertexBufferTokenEXTBuilder {
    #[inline]
    pub fn vertex_binding_unit(mut self, value: u32) -> Self {
        self.inner.vertex_binding_unit = value;
        self
    }
}
impl core::ops::Deref for IndirectCommandsVertexBufferTokenEXTBuilder {
    type Target = IndirectCommandsVertexBufferTokenEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for IndirectCommandsVertexBufferTokenEXTBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`BindVertexBufferIndirectCommandEXT`].
pub struct BindVertexBufferIndirectCommandEXTBuilder {
    inner: BindVertexBufferIndirectCommandEXT,
}
impl BindVertexBufferIndirectCommandEXT {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> BindVertexBufferIndirectCommandEXTBuilder {
        BindVertexBufferIndirectCommandEXTBuilder {
            inner: BindVertexBufferIndirectCommandEXT {
                ..Default::default()
            },
        }
    }
}
impl BindVertexBufferIndirectCommandEXTBuilder {
    #[inline]
    pub fn buffer_address(mut self, value: u64) -> Self {
        self.inner.buffer_address = value;
        self
    }
    #[inline]
    pub fn size(mut self, value: u32) -> Self {
        self.inner.size = value;
        self
    }
    #[inline]
    pub fn stride(mut self, value: u32) -> Self {
        self.inner.stride = value;
        self
    }
}
impl core::ops::Deref for BindVertexBufferIndirectCommandEXTBuilder {
    type Target = BindVertexBufferIndirectCommandEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for BindVertexBufferIndirectCommandEXTBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`IndirectCommandsIndexBufferTokenEXT`].
pub struct IndirectCommandsIndexBufferTokenEXTBuilder {
    inner: IndirectCommandsIndexBufferTokenEXT,
}
impl IndirectCommandsIndexBufferTokenEXT {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> IndirectCommandsIndexBufferTokenEXTBuilder {
        IndirectCommandsIndexBufferTokenEXTBuilder {
            inner: IndirectCommandsIndexBufferTokenEXT {
                ..Default::default()
            },
        }
    }
}
impl IndirectCommandsIndexBufferTokenEXTBuilder {
    #[inline]
    pub fn mode(mut self, value: IndirectCommandsInputModeFlagBitsEXT) -> Self {
        self.inner.mode = value;
        self
    }
}
impl core::ops::Deref for IndirectCommandsIndexBufferTokenEXTBuilder {
    type Target = IndirectCommandsIndexBufferTokenEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for IndirectCommandsIndexBufferTokenEXTBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`BindIndexBufferIndirectCommandEXT`].
pub struct BindIndexBufferIndirectCommandEXTBuilder {
    inner: BindIndexBufferIndirectCommandEXT,
}
impl BindIndexBufferIndirectCommandEXT {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> BindIndexBufferIndirectCommandEXTBuilder {
        BindIndexBufferIndirectCommandEXTBuilder {
            inner: BindIndexBufferIndirectCommandEXT {
                ..Default::default()
            },
        }
    }
}
impl BindIndexBufferIndirectCommandEXTBuilder {
    #[inline]
    pub fn buffer_address(mut self, value: u64) -> Self {
        self.inner.buffer_address = value;
        self
    }
    #[inline]
    pub fn size(mut self, value: u32) -> Self {
        self.inner.size = value;
        self
    }
    #[inline]
    pub fn index_type(mut self, value: IndexType) -> Self {
        self.inner.index_type = value;
        self
    }
}
impl core::ops::Deref for BindIndexBufferIndirectCommandEXTBuilder {
    type Target = BindIndexBufferIndirectCommandEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for BindIndexBufferIndirectCommandEXTBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`IndirectCommandsPushConstantTokenEXT`].
pub struct IndirectCommandsPushConstantTokenEXTBuilder {
    inner: IndirectCommandsPushConstantTokenEXT,
}
impl IndirectCommandsPushConstantTokenEXT {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> IndirectCommandsPushConstantTokenEXTBuilder {
        IndirectCommandsPushConstantTokenEXTBuilder {
            inner: IndirectCommandsPushConstantTokenEXT {
                ..Default::default()
            },
        }
    }
}
impl IndirectCommandsPushConstantTokenEXTBuilder {
    #[inline]
    pub fn update_range(mut self, value: PushConstantRange) -> Self {
        self.inner.update_range = value;
        self
    }
}
impl core::ops::Deref for IndirectCommandsPushConstantTokenEXTBuilder {
    type Target = IndirectCommandsPushConstantTokenEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for IndirectCommandsPushConstantTokenEXTBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`IndirectCommandsExecutionSetTokenEXT`].
pub struct IndirectCommandsExecutionSetTokenEXTBuilder {
    inner: IndirectCommandsExecutionSetTokenEXT,
}
impl IndirectCommandsExecutionSetTokenEXT {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> IndirectCommandsExecutionSetTokenEXTBuilder {
        IndirectCommandsExecutionSetTokenEXTBuilder {
            inner: IndirectCommandsExecutionSetTokenEXT {
                ..Default::default()
            },
        }
    }
}
impl IndirectCommandsExecutionSetTokenEXTBuilder {
    #[inline]
    pub fn r#type(mut self, value: IndirectExecutionSetInfoTypeEXT) -> Self {
        self.inner.r#type = value;
        self
    }
    #[inline]
    pub fn shader_stages(mut self, value: ShaderStageFlags) -> Self {
        self.inner.shader_stages = value;
        self
    }
}
impl core::ops::Deref for IndirectCommandsExecutionSetTokenEXTBuilder {
    type Target = IndirectCommandsExecutionSetTokenEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for IndirectCommandsExecutionSetTokenEXTBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PipelineViewportDepthClipControlCreateInfoEXT`] with lifetime-tied pNext safety.
pub struct PipelineViewportDepthClipControlCreateInfoEXTBuilder<'a> {
    inner: PipelineViewportDepthClipControlCreateInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PipelineViewportDepthClipControlCreateInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PipelineViewportDepthClipControlCreateInfoEXTBuilder<'a> {
        PipelineViewportDepthClipControlCreateInfoEXTBuilder {
            inner: PipelineViewportDepthClipControlCreateInfoEXT {
                s_type: StructureType::from_raw(1000355001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PipelineViewportDepthClipControlCreateInfoEXTBuilder<'a> {
    #[inline]
    pub fn negative_one_to_one(mut self, value: bool) -> Self {
        self.inner.negative_one_to_one = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PipelineViewportDepthClipControlCreateInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPipelineViewportDepthClipControlCreateInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for PipelineViewportDepthClipControlCreateInfoEXTBuilder<'a> {
    type Target = PipelineViewportDepthClipControlCreateInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PipelineViewportDepthClipControlCreateInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceDepthClampControlFeaturesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceDepthClampControlFeaturesEXTBuilder<'a> {
    inner: PhysicalDeviceDepthClampControlFeaturesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceDepthClampControlFeaturesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceDepthClampControlFeaturesEXTBuilder<'a> {
        PhysicalDeviceDepthClampControlFeaturesEXTBuilder {
            inner: PhysicalDeviceDepthClampControlFeaturesEXT {
                s_type: StructureType::from_raw(1000582000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceDepthClampControlFeaturesEXTBuilder<'a> {
    #[inline]
    pub fn depth_clamp_control(mut self, value: bool) -> Self {
        self.inner.depth_clamp_control = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceDepthClampControlFeaturesEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceDepthClampControlFeaturesEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceDepthClampControlFeaturesEXTBuilder<'a> {
    type Target = PhysicalDeviceDepthClampControlFeaturesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceDepthClampControlFeaturesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PipelineViewportDepthClampControlCreateInfoEXT`] with lifetime-tied pNext safety.
pub struct PipelineViewportDepthClampControlCreateInfoEXTBuilder<'a> {
    inner: PipelineViewportDepthClampControlCreateInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PipelineViewportDepthClampControlCreateInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PipelineViewportDepthClampControlCreateInfoEXTBuilder<'a> {
        PipelineViewportDepthClampControlCreateInfoEXTBuilder {
            inner: PipelineViewportDepthClampControlCreateInfoEXT {
                s_type: StructureType::from_raw(1000582001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PipelineViewportDepthClampControlCreateInfoEXTBuilder<'a> {
    #[inline]
    pub fn depth_clamp_mode(mut self, value: DepthClampModeEXT) -> Self {
        self.inner.depth_clamp_mode = value;
        self
    }
    #[inline]
    pub fn depth_clamp_range(mut self, value: &'a DepthClampRangeEXT) -> Self {
        self.inner.p_depth_clamp_range = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PipelineViewportDepthClampControlCreateInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPipelineViewportDepthClampControlCreateInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for PipelineViewportDepthClampControlCreateInfoEXTBuilder<'a> {
    type Target = PipelineViewportDepthClampControlCreateInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PipelineViewportDepthClampControlCreateInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceVertexInputDynamicStateFeaturesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceVertexInputDynamicStateFeaturesEXTBuilder<'a> {
    inner: PhysicalDeviceVertexInputDynamicStateFeaturesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceVertexInputDynamicStateFeaturesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceVertexInputDynamicStateFeaturesEXTBuilder<'a> {
        PhysicalDeviceVertexInputDynamicStateFeaturesEXTBuilder {
            inner: PhysicalDeviceVertexInputDynamicStateFeaturesEXT {
                s_type: StructureType::from_raw(1000352000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceVertexInputDynamicStateFeaturesEXTBuilder<'a> {
    #[inline]
    pub fn vertex_input_dynamic_state(mut self, value: bool) -> Self {
        self.inner.vertex_input_dynamic_state = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceVertexInputDynamicStateFeaturesEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceVertexInputDynamicStateFeaturesEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDeviceVertexInputDynamicStateFeaturesEXTBuilder<'a> {
    type Target = PhysicalDeviceVertexInputDynamicStateFeaturesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceVertexInputDynamicStateFeaturesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceExternalMemoryRDMAFeaturesNV`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceExternalMemoryRDMAFeaturesNVBuilder<'a> {
    inner: PhysicalDeviceExternalMemoryRDMAFeaturesNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceExternalMemoryRDMAFeaturesNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceExternalMemoryRDMAFeaturesNVBuilder<'a> {
        PhysicalDeviceExternalMemoryRDMAFeaturesNVBuilder {
            inner: PhysicalDeviceExternalMemoryRDMAFeaturesNV {
                s_type: StructureType::from_raw(1000371001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceExternalMemoryRDMAFeaturesNVBuilder<'a> {
    #[inline]
    pub fn external_memory_rdma(mut self, value: bool) -> Self {
        self.inner.external_memory_rdma = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceExternalMemoryRDMAFeaturesNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceExternalMemoryRDMAFeaturesNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceExternalMemoryRDMAFeaturesNVBuilder<'a> {
    type Target = PhysicalDeviceExternalMemoryRDMAFeaturesNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceExternalMemoryRDMAFeaturesNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHRBuilder<'a> {
    inner: PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHRBuilder<
        'a,
    > {
        PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHRBuilder {
            inner: PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR {
                s_type: StructureType::from_raw(1000558000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHRBuilder<'a> {
    #[inline]
    pub fn shader_relaxed_extended_instruction(mut self, value: bool) -> Self {
        self.inner.shader_relaxed_extended_instruction = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<
        T: ExtendsPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR,
    >(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHRBuilder<'a> {
    type Target = PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VertexInputBindingDescription2EXT`] with lifetime-tied pNext safety.
pub struct VertexInputBindingDescription2EXTBuilder<'a> {
    inner: VertexInputBindingDescription2EXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl VertexInputBindingDescription2EXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> VertexInputBindingDescription2EXTBuilder<'a> {
        VertexInputBindingDescription2EXTBuilder {
            inner: VertexInputBindingDescription2EXT {
                s_type: StructureType::from_raw(1000352001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> VertexInputBindingDescription2EXTBuilder<'a> {
    #[inline]
    pub fn binding(mut self, value: u32) -> Self {
        self.inner.binding = value;
        self
    }
    #[inline]
    pub fn stride(mut self, value: u32) -> Self {
        self.inner.stride = value;
        self
    }
    #[inline]
    pub fn input_rate(mut self, value: VertexInputRate) -> Self {
        self.inner.input_rate = value;
        self
    }
    #[inline]
    pub fn divisor(mut self, value: u32) -> Self {
        self.inner.divisor = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`VertexInputBindingDescription2EXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsVertexInputBindingDescription2EXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for VertexInputBindingDescription2EXTBuilder<'a> {
    type Target = VertexInputBindingDescription2EXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for VertexInputBindingDescription2EXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VertexInputAttributeDescription2EXT`] with lifetime-tied pNext safety.
pub struct VertexInputAttributeDescription2EXTBuilder<'a> {
    inner: VertexInputAttributeDescription2EXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl VertexInputAttributeDescription2EXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> VertexInputAttributeDescription2EXTBuilder<'a> {
        VertexInputAttributeDescription2EXTBuilder {
            inner: VertexInputAttributeDescription2EXT {
                s_type: StructureType::from_raw(1000352002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> VertexInputAttributeDescription2EXTBuilder<'a> {
    #[inline]
    pub fn location(mut self, value: u32) -> Self {
        self.inner.location = value;
        self
    }
    #[inline]
    pub fn binding(mut self, value: u32) -> Self {
        self.inner.binding = value;
        self
    }
    #[inline]
    pub fn format(mut self, value: Format) -> Self {
        self.inner.format = value;
        self
    }
    #[inline]
    pub fn offset(mut self, value: u32) -> Self {
        self.inner.offset = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`VertexInputAttributeDescription2EXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsVertexInputAttributeDescription2EXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for VertexInputAttributeDescription2EXTBuilder<'a> {
    type Target = VertexInputAttributeDescription2EXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for VertexInputAttributeDescription2EXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceColorWriteEnableFeaturesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceColorWriteEnableFeaturesEXTBuilder<'a> {
    inner: PhysicalDeviceColorWriteEnableFeaturesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceColorWriteEnableFeaturesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceColorWriteEnableFeaturesEXTBuilder<'a> {
        PhysicalDeviceColorWriteEnableFeaturesEXTBuilder {
            inner: PhysicalDeviceColorWriteEnableFeaturesEXT {
                s_type: StructureType::from_raw(1000381000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceColorWriteEnableFeaturesEXTBuilder<'a> {
    #[inline]
    pub fn color_write_enable(mut self, value: bool) -> Self {
        self.inner.color_write_enable = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceColorWriteEnableFeaturesEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceColorWriteEnableFeaturesEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceColorWriteEnableFeaturesEXTBuilder<'a> {
    type Target = PhysicalDeviceColorWriteEnableFeaturesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceColorWriteEnableFeaturesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PipelineColorWriteCreateInfoEXT`] with lifetime-tied pNext safety.
pub struct PipelineColorWriteCreateInfoEXTBuilder<'a> {
    inner: PipelineColorWriteCreateInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PipelineColorWriteCreateInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PipelineColorWriteCreateInfoEXTBuilder<'a> {
        PipelineColorWriteCreateInfoEXTBuilder {
            inner: PipelineColorWriteCreateInfoEXT {
                s_type: StructureType::from_raw(1000381001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PipelineColorWriteCreateInfoEXTBuilder<'a> {
    #[inline]
    pub fn color_write_enables(mut self, slice: &'a [u32]) -> Self {
        self.inner.attachment_count = slice.len() as u32;
        self.inner.p_color_write_enables = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`PipelineColorWriteCreateInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPipelineColorWriteCreateInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for PipelineColorWriteCreateInfoEXTBuilder<'a> {
    type Target = PipelineColorWriteCreateInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PipelineColorWriteCreateInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`MemoryBarrier2`] with lifetime-tied pNext safety.
pub struct MemoryBarrier2Builder<'a> {
    inner: MemoryBarrier2,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl MemoryBarrier2 {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> MemoryBarrier2Builder<'a> {
        MemoryBarrier2Builder {
            inner: MemoryBarrier2 {
                s_type: StructureType::from_raw(1000314000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> MemoryBarrier2Builder<'a> {
    #[inline]
    pub fn src_stage_mask(mut self, value: PipelineStageFlags2) -> Self {
        self.inner.src_stage_mask = value;
        self
    }
    #[inline]
    pub fn src_access_mask(mut self, value: AccessFlags2) -> Self {
        self.inner.src_access_mask = value;
        self
    }
    #[inline]
    pub fn dst_stage_mask(mut self, value: PipelineStageFlags2) -> Self {
        self.inner.dst_stage_mask = value;
        self
    }
    #[inline]
    pub fn dst_access_mask(mut self, value: AccessFlags2) -> Self {
        self.inner.dst_access_mask = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`MemoryBarrier2`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsMemoryBarrier2>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for MemoryBarrier2Builder<'a> {
    type Target = MemoryBarrier2;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for MemoryBarrier2Builder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ImageMemoryBarrier2`] with lifetime-tied pNext safety.
pub struct ImageMemoryBarrier2Builder<'a> {
    inner: ImageMemoryBarrier2,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ImageMemoryBarrier2 {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ImageMemoryBarrier2Builder<'a> {
        ImageMemoryBarrier2Builder {
            inner: ImageMemoryBarrier2 {
                s_type: StructureType::from_raw(1000314002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ImageMemoryBarrier2Builder<'a> {
    #[inline]
    pub fn src_stage_mask(mut self, value: PipelineStageFlags2) -> Self {
        self.inner.src_stage_mask = value;
        self
    }
    #[inline]
    pub fn src_access_mask(mut self, value: AccessFlags2) -> Self {
        self.inner.src_access_mask = value;
        self
    }
    #[inline]
    pub fn dst_stage_mask(mut self, value: PipelineStageFlags2) -> Self {
        self.inner.dst_stage_mask = value;
        self
    }
    #[inline]
    pub fn dst_access_mask(mut self, value: AccessFlags2) -> Self {
        self.inner.dst_access_mask = value;
        self
    }
    #[inline]
    pub fn old_layout(mut self, value: ImageLayout) -> Self {
        self.inner.old_layout = value;
        self
    }
    #[inline]
    pub fn new_layout(mut self, value: ImageLayout) -> Self {
        self.inner.new_layout = value;
        self
    }
    #[inline]
    pub fn src_queue_family_index(mut self, value: u32) -> Self {
        self.inner.src_queue_family_index = value;
        self
    }
    #[inline]
    pub fn dst_queue_family_index(mut self, value: u32) -> Self {
        self.inner.dst_queue_family_index = value;
        self
    }
    #[inline]
    pub fn image(mut self, value: Image) -> Self {
        self.inner.image = value;
        self
    }
    #[inline]
    pub fn subresource_range(mut self, value: ImageSubresourceRange) -> Self {
        self.inner.subresource_range = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`ImageMemoryBarrier2`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsImageMemoryBarrier2>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for ImageMemoryBarrier2Builder<'a> {
    type Target = ImageMemoryBarrier2;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ImageMemoryBarrier2Builder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`BufferMemoryBarrier2`] with lifetime-tied pNext safety.
pub struct BufferMemoryBarrier2Builder<'a> {
    inner: BufferMemoryBarrier2,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl BufferMemoryBarrier2 {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> BufferMemoryBarrier2Builder<'a> {
        BufferMemoryBarrier2Builder {
            inner: BufferMemoryBarrier2 {
                s_type: StructureType::from_raw(1000314001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> BufferMemoryBarrier2Builder<'a> {
    #[inline]
    pub fn src_stage_mask(mut self, value: PipelineStageFlags2) -> Self {
        self.inner.src_stage_mask = value;
        self
    }
    #[inline]
    pub fn src_access_mask(mut self, value: AccessFlags2) -> Self {
        self.inner.src_access_mask = value;
        self
    }
    #[inline]
    pub fn dst_stage_mask(mut self, value: PipelineStageFlags2) -> Self {
        self.inner.dst_stage_mask = value;
        self
    }
    #[inline]
    pub fn dst_access_mask(mut self, value: AccessFlags2) -> Self {
        self.inner.dst_access_mask = value;
        self
    }
    #[inline]
    pub fn src_queue_family_index(mut self, value: u32) -> Self {
        self.inner.src_queue_family_index = value;
        self
    }
    #[inline]
    pub fn dst_queue_family_index(mut self, value: u32) -> Self {
        self.inner.dst_queue_family_index = value;
        self
    }
    #[inline]
    pub fn buffer(mut self, value: Buffer) -> Self {
        self.inner.buffer = value;
        self
    }
    #[inline]
    pub fn offset(mut self, value: u64) -> Self {
        self.inner.offset = value;
        self
    }
    #[inline]
    pub fn size(mut self, value: u64) -> Self {
        self.inner.size = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`BufferMemoryBarrier2`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsBufferMemoryBarrier2>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for BufferMemoryBarrier2Builder<'a> {
    type Target = BufferMemoryBarrier2;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for BufferMemoryBarrier2Builder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`MemoryBarrierAccessFlags3KHR`] with lifetime-tied pNext safety.
pub struct MemoryBarrierAccessFlags3KHRBuilder<'a> {
    inner: MemoryBarrierAccessFlags3KHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl MemoryBarrierAccessFlags3KHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> MemoryBarrierAccessFlags3KHRBuilder<'a> {
        MemoryBarrierAccessFlags3KHRBuilder {
            inner: MemoryBarrierAccessFlags3KHR {
                s_type: StructureType::from_raw(1000574002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> MemoryBarrierAccessFlags3KHRBuilder<'a> {
    #[inline]
    pub fn src_access_mask3(mut self, value: AccessFlags3KHR) -> Self {
        self.inner.src_access_mask3 = value;
        self
    }
    #[inline]
    pub fn dst_access_mask3(mut self, value: AccessFlags3KHR) -> Self {
        self.inner.dst_access_mask3 = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`MemoryBarrierAccessFlags3KHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsMemoryBarrierAccessFlags3KHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for MemoryBarrierAccessFlags3KHRBuilder<'a> {
    type Target = MemoryBarrierAccessFlags3KHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for MemoryBarrierAccessFlags3KHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DependencyInfo`] with lifetime-tied pNext safety.
pub struct DependencyInfoBuilder<'a> {
    inner: DependencyInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DependencyInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> DependencyInfoBuilder<'a> {
        DependencyInfoBuilder {
            inner: DependencyInfo {
                s_type: StructureType::from_raw(1000314003i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DependencyInfoBuilder<'a> {
    #[inline]
    pub fn dependency_flags(mut self, value: DependencyFlags) -> Self {
        self.inner.dependency_flags = value;
        self
    }
    #[inline]
    pub fn memory_barriers(mut self, slice: &'a [MemoryBarrier2]) -> Self {
        self.inner.memory_barrier_count = slice.len() as u32;
        self.inner.p_memory_barriers = slice.as_ptr();
        self
    }
    #[inline]
    pub fn buffer_memory_barriers(mut self, slice: &'a [BufferMemoryBarrier2]) -> Self {
        self.inner.buffer_memory_barrier_count = slice.len() as u32;
        self.inner.p_buffer_memory_barriers = slice.as_ptr();
        self
    }
    #[inline]
    pub fn image_memory_barriers(mut self, slice: &'a [ImageMemoryBarrier2]) -> Self {
        self.inner.image_memory_barrier_count = slice.len() as u32;
        self.inner.p_image_memory_barriers = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`DependencyInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsDependencyInfo>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for DependencyInfoBuilder<'a> {
    type Target = DependencyInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for DependencyInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`SemaphoreSubmitInfo`] with lifetime-tied pNext safety.
pub struct SemaphoreSubmitInfoBuilder<'a> {
    inner: SemaphoreSubmitInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl SemaphoreSubmitInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> SemaphoreSubmitInfoBuilder<'a> {
        SemaphoreSubmitInfoBuilder {
            inner: SemaphoreSubmitInfo {
                s_type: StructureType::from_raw(1000314005i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> SemaphoreSubmitInfoBuilder<'a> {
    #[inline]
    pub fn semaphore(mut self, value: Semaphore) -> Self {
        self.inner.semaphore = value;
        self
    }
    #[inline]
    pub fn value(mut self, value: u64) -> Self {
        self.inner.value = value;
        self
    }
    #[inline]
    pub fn stage_mask(mut self, value: PipelineStageFlags2) -> Self {
        self.inner.stage_mask = value;
        self
    }
    #[inline]
    pub fn device_index(mut self, value: u32) -> Self {
        self.inner.device_index = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`SemaphoreSubmitInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsSemaphoreSubmitInfo>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for SemaphoreSubmitInfoBuilder<'a> {
    type Target = SemaphoreSubmitInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for SemaphoreSubmitInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`CommandBufferSubmitInfo`] with lifetime-tied pNext safety.
pub struct CommandBufferSubmitInfoBuilder<'a> {
    inner: CommandBufferSubmitInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl CommandBufferSubmitInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> CommandBufferSubmitInfoBuilder<'a> {
        CommandBufferSubmitInfoBuilder {
            inner: CommandBufferSubmitInfo {
                s_type: StructureType::from_raw(1000314006i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> CommandBufferSubmitInfoBuilder<'a> {
    #[inline]
    pub fn command_buffer(mut self, value: CommandBuffer) -> Self {
        self.inner.command_buffer = value;
        self
    }
    #[inline]
    pub fn device_mask(mut self, value: u32) -> Self {
        self.inner.device_mask = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`CommandBufferSubmitInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsCommandBufferSubmitInfo>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for CommandBufferSubmitInfoBuilder<'a> {
    type Target = CommandBufferSubmitInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for CommandBufferSubmitInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`SubmitInfo2`] with lifetime-tied pNext safety.
pub struct SubmitInfo2Builder<'a> {
    inner: SubmitInfo2,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl SubmitInfo2 {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> SubmitInfo2Builder<'a> {
        SubmitInfo2Builder {
            inner: SubmitInfo2 {
                s_type: StructureType::from_raw(1000314004i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> SubmitInfo2Builder<'a> {
    #[inline]
    pub fn flags(mut self, value: SubmitFlags) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn wait_semaphore_infos(mut self, slice: &'a [SemaphoreSubmitInfo]) -> Self {
        self.inner.wait_semaphore_info_count = slice.len() as u32;
        self.inner.p_wait_semaphore_infos = slice.as_ptr();
        self
    }
    #[inline]
    pub fn command_buffer_infos(mut self, slice: &'a [CommandBufferSubmitInfo]) -> Self {
        self.inner.command_buffer_info_count = slice.len() as u32;
        self.inner.p_command_buffer_infos = slice.as_ptr();
        self
    }
    #[inline]
    pub fn signal_semaphore_infos(mut self, slice: &'a [SemaphoreSubmitInfo]) -> Self {
        self.inner.signal_semaphore_info_count = slice.len() as u32;
        self.inner.p_signal_semaphore_infos = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`SubmitInfo2`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsSubmitInfo2>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for SubmitInfo2Builder<'a> {
    type Target = SubmitInfo2;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for SubmitInfo2Builder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`QueueFamilyCheckpointProperties2NV`] with lifetime-tied pNext safety.
pub struct QueueFamilyCheckpointProperties2NVBuilder<'a> {
    inner: QueueFamilyCheckpointProperties2NV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl QueueFamilyCheckpointProperties2NV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> QueueFamilyCheckpointProperties2NVBuilder<'a> {
        QueueFamilyCheckpointProperties2NVBuilder {
            inner: QueueFamilyCheckpointProperties2NV {
                s_type: StructureType::from_raw(1000314008i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> QueueFamilyCheckpointProperties2NVBuilder<'a> {
    #[inline]
    pub fn checkpoint_execution_stage_mask(
        mut self,
        value: PipelineStageFlags2,
    ) -> Self {
        self.inner.checkpoint_execution_stage_mask = value;
        self
    }
}
impl<'a> core::ops::Deref for QueueFamilyCheckpointProperties2NVBuilder<'a> {
    type Target = QueueFamilyCheckpointProperties2NV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for QueueFamilyCheckpointProperties2NVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`CheckpointData2NV`] with lifetime-tied pNext safety.
pub struct CheckpointData2NVBuilder<'a> {
    inner: CheckpointData2NV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl CheckpointData2NV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> CheckpointData2NVBuilder<'a> {
        CheckpointData2NVBuilder {
            inner: CheckpointData2NV {
                s_type: StructureType::from_raw(1000314009i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> CheckpointData2NVBuilder<'a> {
    #[inline]
    pub fn stage(mut self, value: PipelineStageFlags2) -> Self {
        self.inner.stage = value;
        self
    }
    #[inline]
    pub fn checkpoint_marker(mut self, value: *mut core::ffi::c_void) -> Self {
        self.inner.p_checkpoint_marker = value;
        self
    }
}
impl<'a> core::ops::Deref for CheckpointData2NVBuilder<'a> {
    type Target = CheckpointData2NV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for CheckpointData2NVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceSynchronization2Features`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceSynchronization2FeaturesBuilder<'a> {
    inner: PhysicalDeviceSynchronization2Features,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceSynchronization2Features {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceSynchronization2FeaturesBuilder<'a> {
        PhysicalDeviceSynchronization2FeaturesBuilder {
            inner: PhysicalDeviceSynchronization2Features {
                s_type: StructureType::from_raw(1000314007i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceSynchronization2FeaturesBuilder<'a> {
    #[inline]
    pub fn synchronization2(mut self, value: bool) -> Self {
        self.inner.synchronization2 = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceSynchronization2Features`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceSynchronization2Features>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceSynchronization2FeaturesBuilder<'a> {
    type Target = PhysicalDeviceSynchronization2Features;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceSynchronization2FeaturesBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceUnifiedImageLayoutsFeaturesKHR`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceUnifiedImageLayoutsFeaturesKHRBuilder<'a> {
    inner: PhysicalDeviceUnifiedImageLayoutsFeaturesKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceUnifiedImageLayoutsFeaturesKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceUnifiedImageLayoutsFeaturesKHRBuilder<'a> {
        PhysicalDeviceUnifiedImageLayoutsFeaturesKHRBuilder {
            inner: PhysicalDeviceUnifiedImageLayoutsFeaturesKHR {
                s_type: StructureType::from_raw(1000527000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceUnifiedImageLayoutsFeaturesKHRBuilder<'a> {
    #[inline]
    pub fn unified_image_layouts(mut self, value: bool) -> Self {
        self.inner.unified_image_layouts = value as u32;
        self
    }
    #[inline]
    pub fn unified_image_layouts_video(mut self, value: bool) -> Self {
        self.inner.unified_image_layouts_video = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceUnifiedImageLayoutsFeaturesKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceUnifiedImageLayoutsFeaturesKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceUnifiedImageLayoutsFeaturesKHRBuilder<'a> {
    type Target = PhysicalDeviceUnifiedImageLayoutsFeaturesKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceUnifiedImageLayoutsFeaturesKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceHostImageCopyFeatures`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceHostImageCopyFeaturesBuilder<'a> {
    inner: PhysicalDeviceHostImageCopyFeatures,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceHostImageCopyFeatures {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceHostImageCopyFeaturesBuilder<'a> {
        PhysicalDeviceHostImageCopyFeaturesBuilder {
            inner: PhysicalDeviceHostImageCopyFeatures {
                s_type: StructureType::from_raw(1000270000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceHostImageCopyFeaturesBuilder<'a> {
    #[inline]
    pub fn host_image_copy(mut self, value: bool) -> Self {
        self.inner.host_image_copy = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceHostImageCopyFeatures`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceHostImageCopyFeatures>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceHostImageCopyFeaturesBuilder<'a> {
    type Target = PhysicalDeviceHostImageCopyFeatures;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceHostImageCopyFeaturesBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceHostImageCopyProperties`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceHostImageCopyPropertiesBuilder<'a> {
    inner: PhysicalDeviceHostImageCopyProperties,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceHostImageCopyProperties {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceHostImageCopyPropertiesBuilder<'a> {
        PhysicalDeviceHostImageCopyPropertiesBuilder {
            inner: PhysicalDeviceHostImageCopyProperties {
                s_type: StructureType::from_raw(1000270001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceHostImageCopyPropertiesBuilder<'a> {
    #[inline]
    pub fn copy_src_layout_count(mut self, value: u32) -> Self {
        self.inner.copy_src_layout_count = value;
        self
    }
    #[inline]
    pub fn copy_src_layouts(mut self, slice: &'a mut [ImageLayout]) -> Self {
        self.inner.copy_src_layout_count = slice.len() as u32;
        self.inner.p_copy_src_layouts = slice.as_mut_ptr();
        self
    }
    #[inline]
    pub fn copy_dst_layout_count(mut self, value: u32) -> Self {
        self.inner.copy_dst_layout_count = value;
        self
    }
    #[inline]
    pub fn copy_dst_layouts(mut self, slice: &'a mut [ImageLayout]) -> Self {
        self.inner.copy_dst_layout_count = slice.len() as u32;
        self.inner.p_copy_dst_layouts = slice.as_mut_ptr();
        self
    }
    #[inline]
    pub fn optimal_tiling_layout_uuid(
        mut self,
        value: [u8; UUID_SIZE as usize],
    ) -> Self {
        self.inner.optimal_tiling_layout_uuid = value;
        self
    }
    #[inline]
    pub fn identical_memory_type_requirements(mut self, value: bool) -> Self {
        self.inner.identical_memory_type_requirements = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceHostImageCopyProperties`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceHostImageCopyProperties>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceHostImageCopyPropertiesBuilder<'a> {
    type Target = PhysicalDeviceHostImageCopyProperties;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceHostImageCopyPropertiesBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`MemoryToImageCopy`] with lifetime-tied pNext safety.
pub struct MemoryToImageCopyBuilder<'a> {
    inner: MemoryToImageCopy,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl MemoryToImageCopy {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> MemoryToImageCopyBuilder<'a> {
        MemoryToImageCopyBuilder {
            inner: MemoryToImageCopy {
                s_type: StructureType::from_raw(1000270002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> MemoryToImageCopyBuilder<'a> {
    #[inline]
    pub fn host_pointer(mut self, value: *const core::ffi::c_void) -> Self {
        self.inner.p_host_pointer = value;
        self
    }
    #[inline]
    pub fn memory_row_length(mut self, value: u32) -> Self {
        self.inner.memory_row_length = value;
        self
    }
    #[inline]
    pub fn memory_image_height(mut self, value: u32) -> Self {
        self.inner.memory_image_height = value;
        self
    }
    #[inline]
    pub fn image_subresource(mut self, value: ImageSubresourceLayers) -> Self {
        self.inner.image_subresource = value;
        self
    }
    #[inline]
    pub fn image_offset(mut self, value: Offset3D) -> Self {
        self.inner.image_offset = value;
        self
    }
    #[inline]
    pub fn image_extent(mut self, value: Extent3D) -> Self {
        self.inner.image_extent = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`MemoryToImageCopy`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsMemoryToImageCopy>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for MemoryToImageCopyBuilder<'a> {
    type Target = MemoryToImageCopy;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for MemoryToImageCopyBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ImageToMemoryCopy`] with lifetime-tied pNext safety.
pub struct ImageToMemoryCopyBuilder<'a> {
    inner: ImageToMemoryCopy,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ImageToMemoryCopy {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ImageToMemoryCopyBuilder<'a> {
        ImageToMemoryCopyBuilder {
            inner: ImageToMemoryCopy {
                s_type: StructureType::from_raw(1000270003i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ImageToMemoryCopyBuilder<'a> {
    #[inline]
    pub fn host_pointer(mut self, value: *mut core::ffi::c_void) -> Self {
        self.inner.p_host_pointer = value;
        self
    }
    #[inline]
    pub fn memory_row_length(mut self, value: u32) -> Self {
        self.inner.memory_row_length = value;
        self
    }
    #[inline]
    pub fn memory_image_height(mut self, value: u32) -> Self {
        self.inner.memory_image_height = value;
        self
    }
    #[inline]
    pub fn image_subresource(mut self, value: ImageSubresourceLayers) -> Self {
        self.inner.image_subresource = value;
        self
    }
    #[inline]
    pub fn image_offset(mut self, value: Offset3D) -> Self {
        self.inner.image_offset = value;
        self
    }
    #[inline]
    pub fn image_extent(mut self, value: Extent3D) -> Self {
        self.inner.image_extent = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`ImageToMemoryCopy`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsImageToMemoryCopy>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for ImageToMemoryCopyBuilder<'a> {
    type Target = ImageToMemoryCopy;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ImageToMemoryCopyBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`CopyMemoryToImageInfo`] with lifetime-tied pNext safety.
pub struct CopyMemoryToImageInfoBuilder<'a> {
    inner: CopyMemoryToImageInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl CopyMemoryToImageInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> CopyMemoryToImageInfoBuilder<'a> {
        CopyMemoryToImageInfoBuilder {
            inner: CopyMemoryToImageInfo {
                s_type: StructureType::from_raw(1000270005i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> CopyMemoryToImageInfoBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: HostImageCopyFlags) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn dst_image(mut self, value: Image) -> Self {
        self.inner.dst_image = value;
        self
    }
    #[inline]
    pub fn dst_image_layout(mut self, value: ImageLayout) -> Self {
        self.inner.dst_image_layout = value;
        self
    }
    #[inline]
    pub fn regions(mut self, slice: &'a [MemoryToImageCopy]) -> Self {
        self.inner.region_count = slice.len() as u32;
        self.inner.p_regions = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`CopyMemoryToImageInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsCopyMemoryToImageInfo>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for CopyMemoryToImageInfoBuilder<'a> {
    type Target = CopyMemoryToImageInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for CopyMemoryToImageInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`CopyImageToMemoryInfo`] with lifetime-tied pNext safety.
pub struct CopyImageToMemoryInfoBuilder<'a> {
    inner: CopyImageToMemoryInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl CopyImageToMemoryInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> CopyImageToMemoryInfoBuilder<'a> {
        CopyImageToMemoryInfoBuilder {
            inner: CopyImageToMemoryInfo {
                s_type: StructureType::from_raw(1000270004i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> CopyImageToMemoryInfoBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: HostImageCopyFlags) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn src_image(mut self, value: Image) -> Self {
        self.inner.src_image = value;
        self
    }
    #[inline]
    pub fn src_image_layout(mut self, value: ImageLayout) -> Self {
        self.inner.src_image_layout = value;
        self
    }
    #[inline]
    pub fn regions(mut self, slice: &'a [ImageToMemoryCopy]) -> Self {
        self.inner.region_count = slice.len() as u32;
        self.inner.p_regions = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`CopyImageToMemoryInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsCopyImageToMemoryInfo>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for CopyImageToMemoryInfoBuilder<'a> {
    type Target = CopyImageToMemoryInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for CopyImageToMemoryInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`CopyImageToImageInfo`] with lifetime-tied pNext safety.
pub struct CopyImageToImageInfoBuilder<'a> {
    inner: CopyImageToImageInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl CopyImageToImageInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> CopyImageToImageInfoBuilder<'a> {
        CopyImageToImageInfoBuilder {
            inner: CopyImageToImageInfo {
                s_type: StructureType::from_raw(1000270007i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> CopyImageToImageInfoBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: HostImageCopyFlags) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn src_image(mut self, value: Image) -> Self {
        self.inner.src_image = value;
        self
    }
    #[inline]
    pub fn src_image_layout(mut self, value: ImageLayout) -> Self {
        self.inner.src_image_layout = value;
        self
    }
    #[inline]
    pub fn dst_image(mut self, value: Image) -> Self {
        self.inner.dst_image = value;
        self
    }
    #[inline]
    pub fn dst_image_layout(mut self, value: ImageLayout) -> Self {
        self.inner.dst_image_layout = value;
        self
    }
    #[inline]
    pub fn regions(mut self, slice: &'a [ImageCopy2]) -> Self {
        self.inner.region_count = slice.len() as u32;
        self.inner.p_regions = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`CopyImageToImageInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsCopyImageToImageInfo>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for CopyImageToImageInfoBuilder<'a> {
    type Target = CopyImageToImageInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for CopyImageToImageInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`HostImageLayoutTransitionInfo`] with lifetime-tied pNext safety.
pub struct HostImageLayoutTransitionInfoBuilder<'a> {
    inner: HostImageLayoutTransitionInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl HostImageLayoutTransitionInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> HostImageLayoutTransitionInfoBuilder<'a> {
        HostImageLayoutTransitionInfoBuilder {
            inner: HostImageLayoutTransitionInfo {
                s_type: StructureType::from_raw(1000270006i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> HostImageLayoutTransitionInfoBuilder<'a> {
    #[inline]
    pub fn image(mut self, value: Image) -> Self {
        self.inner.image = value;
        self
    }
    #[inline]
    pub fn old_layout(mut self, value: ImageLayout) -> Self {
        self.inner.old_layout = value;
        self
    }
    #[inline]
    pub fn new_layout(mut self, value: ImageLayout) -> Self {
        self.inner.new_layout = value;
        self
    }
    #[inline]
    pub fn subresource_range(mut self, value: ImageSubresourceRange) -> Self {
        self.inner.subresource_range = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`HostImageLayoutTransitionInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsHostImageLayoutTransitionInfo>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for HostImageLayoutTransitionInfoBuilder<'a> {
    type Target = HostImageLayoutTransitionInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for HostImageLayoutTransitionInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`SubresourceHostMemcpySize`] with lifetime-tied pNext safety.
pub struct SubresourceHostMemcpySizeBuilder<'a> {
    inner: SubresourceHostMemcpySize,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl SubresourceHostMemcpySize {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> SubresourceHostMemcpySizeBuilder<'a> {
        SubresourceHostMemcpySizeBuilder {
            inner: SubresourceHostMemcpySize {
                s_type: StructureType::from_raw(1000270008i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> SubresourceHostMemcpySizeBuilder<'a> {
    #[inline]
    pub fn size(mut self, value: u64) -> Self {
        self.inner.size = value;
        self
    }
}
impl<'a> core::ops::Deref for SubresourceHostMemcpySizeBuilder<'a> {
    type Target = SubresourceHostMemcpySize;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for SubresourceHostMemcpySizeBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`HostImageCopyDevicePerformanceQuery`] with lifetime-tied pNext safety.
pub struct HostImageCopyDevicePerformanceQueryBuilder<'a> {
    inner: HostImageCopyDevicePerformanceQuery,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl HostImageCopyDevicePerformanceQuery {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> HostImageCopyDevicePerformanceQueryBuilder<'a> {
        HostImageCopyDevicePerformanceQueryBuilder {
            inner: HostImageCopyDevicePerformanceQuery {
                s_type: StructureType::from_raw(1000270009i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> HostImageCopyDevicePerformanceQueryBuilder<'a> {
    #[inline]
    pub fn optimal_device_access(mut self, value: bool) -> Self {
        self.inner.optimal_device_access = value as u32;
        self
    }
    #[inline]
    pub fn identical_memory_layout(mut self, value: bool) -> Self {
        self.inner.identical_memory_layout = value as u32;
        self
    }
}
impl<'a> core::ops::Deref for HostImageCopyDevicePerformanceQueryBuilder<'a> {
    type Target = HostImageCopyDevicePerformanceQuery;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for HostImageCopyDevicePerformanceQueryBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceVulkanSC10Properties`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceVulkanSC10PropertiesBuilder<'a> {
    inner: PhysicalDeviceVulkanSC10Properties,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceVulkanSC10Properties {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceVulkanSC10PropertiesBuilder<'a> {
        PhysicalDeviceVulkanSC10PropertiesBuilder {
            inner: PhysicalDeviceVulkanSC10Properties {
                s_type: StructureType::from_raw(1000298001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceVulkanSC10PropertiesBuilder<'a> {
    #[inline]
    pub fn device_no_dynamic_host_allocations(mut self, value: bool) -> Self {
        self.inner.device_no_dynamic_host_allocations = value as u32;
        self
    }
    #[inline]
    pub fn device_destroy_frees_memory(mut self, value: bool) -> Self {
        self.inner.device_destroy_frees_memory = value as u32;
        self
    }
    #[inline]
    pub fn command_pool_multiple_command_buffers_recording(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.command_pool_multiple_command_buffers_recording = value as u32;
        self
    }
    #[inline]
    pub fn command_pool_reset_command_buffer(mut self, value: bool) -> Self {
        self.inner.command_pool_reset_command_buffer = value as u32;
        self
    }
    #[inline]
    pub fn command_buffer_simultaneous_use(mut self, value: bool) -> Self {
        self.inner.command_buffer_simultaneous_use = value as u32;
        self
    }
    #[inline]
    pub fn secondary_command_buffer_null_or_imageless_framebuffer(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.secondary_command_buffer_null_or_imageless_framebuffer = value as u32;
        self
    }
    #[inline]
    pub fn recycle_descriptor_set_memory(mut self, value: bool) -> Self {
        self.inner.recycle_descriptor_set_memory = value as u32;
        self
    }
    #[inline]
    pub fn recycle_pipeline_memory(mut self, value: bool) -> Self {
        self.inner.recycle_pipeline_memory = value as u32;
        self
    }
    #[inline]
    pub fn max_render_pass_subpasses(mut self, value: u32) -> Self {
        self.inner.max_render_pass_subpasses = value;
        self
    }
    #[inline]
    pub fn max_render_pass_dependencies(mut self, value: u32) -> Self {
        self.inner.max_render_pass_dependencies = value;
        self
    }
    #[inline]
    pub fn max_subpass_input_attachments(mut self, value: u32) -> Self {
        self.inner.max_subpass_input_attachments = value;
        self
    }
    #[inline]
    pub fn max_subpass_preserve_attachments(mut self, value: u32) -> Self {
        self.inner.max_subpass_preserve_attachments = value;
        self
    }
    #[inline]
    pub fn max_framebuffer_attachments(mut self, value: u32) -> Self {
        self.inner.max_framebuffer_attachments = value;
        self
    }
    #[inline]
    pub fn max_descriptor_set_layout_bindings(mut self, value: u32) -> Self {
        self.inner.max_descriptor_set_layout_bindings = value;
        self
    }
    #[inline]
    pub fn max_query_fault_count(mut self, value: u32) -> Self {
        self.inner.max_query_fault_count = value;
        self
    }
    #[inline]
    pub fn max_callback_fault_count(mut self, value: u32) -> Self {
        self.inner.max_callback_fault_count = value;
        self
    }
    #[inline]
    pub fn max_command_pool_command_buffers(mut self, value: u32) -> Self {
        self.inner.max_command_pool_command_buffers = value;
        self
    }
    #[inline]
    pub fn max_command_buffer_size(mut self, value: u64) -> Self {
        self.inner.max_command_buffer_size = value;
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceVulkanSC10PropertiesBuilder<'a> {
    type Target = PhysicalDeviceVulkanSC10Properties;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceVulkanSC10PropertiesBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PipelinePoolSize`] with lifetime-tied pNext safety.
pub struct PipelinePoolSizeBuilder<'a> {
    inner: PipelinePoolSize,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PipelinePoolSize {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PipelinePoolSizeBuilder<'a> {
        PipelinePoolSizeBuilder {
            inner: PipelinePoolSize {
                s_type: StructureType::from_raw(1000298005i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PipelinePoolSizeBuilder<'a> {
    #[inline]
    pub fn pool_entry_size(mut self, value: u64) -> Self {
        self.inner.pool_entry_size = value;
        self
    }
    #[inline]
    pub fn pool_entry_count(mut self, value: u32) -> Self {
        self.inner.pool_entry_count = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PipelinePoolSize`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPipelinePoolSize>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for PipelinePoolSizeBuilder<'a> {
    type Target = PipelinePoolSize;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PipelinePoolSizeBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DeviceObjectReservationCreateInfo`] with lifetime-tied pNext safety.
pub struct DeviceObjectReservationCreateInfoBuilder<'a> {
    inner: DeviceObjectReservationCreateInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DeviceObjectReservationCreateInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> DeviceObjectReservationCreateInfoBuilder<'a> {
        DeviceObjectReservationCreateInfoBuilder {
            inner: DeviceObjectReservationCreateInfo {
                s_type: StructureType::from_raw(1000298002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DeviceObjectReservationCreateInfoBuilder<'a> {
    #[inline]
    pub fn pipeline_cache_create_infos(
        mut self,
        slice: &'a [PipelineCacheCreateInfo],
    ) -> Self {
        self.inner.pipeline_cache_create_info_count = slice.len() as u32;
        self.inner.p_pipeline_cache_create_infos = slice.as_ptr();
        self
    }
    #[inline]
    pub fn pipeline_pool_sizes(mut self, slice: &'a [PipelinePoolSize]) -> Self {
        self.inner.pipeline_pool_size_count = slice.len() as u32;
        self.inner.p_pipeline_pool_sizes = slice.as_ptr();
        self
    }
    #[inline]
    pub fn semaphore_request_count(mut self, value: u32) -> Self {
        self.inner.semaphore_request_count = value;
        self
    }
    #[inline]
    pub fn command_buffer_request_count(mut self, value: u32) -> Self {
        self.inner.command_buffer_request_count = value;
        self
    }
    #[inline]
    pub fn fence_request_count(mut self, value: u32) -> Self {
        self.inner.fence_request_count = value;
        self
    }
    #[inline]
    pub fn device_memory_request_count(mut self, value: u32) -> Self {
        self.inner.device_memory_request_count = value;
        self
    }
    #[inline]
    pub fn buffer_request_count(mut self, value: u32) -> Self {
        self.inner.buffer_request_count = value;
        self
    }
    #[inline]
    pub fn image_request_count(mut self, value: u32) -> Self {
        self.inner.image_request_count = value;
        self
    }
    #[inline]
    pub fn event_request_count(mut self, value: u32) -> Self {
        self.inner.event_request_count = value;
        self
    }
    #[inline]
    pub fn query_pool_request_count(mut self, value: u32) -> Self {
        self.inner.query_pool_request_count = value;
        self
    }
    #[inline]
    pub fn buffer_view_request_count(mut self, value: u32) -> Self {
        self.inner.buffer_view_request_count = value;
        self
    }
    #[inline]
    pub fn image_view_request_count(mut self, value: u32) -> Self {
        self.inner.image_view_request_count = value;
        self
    }
    #[inline]
    pub fn layered_image_view_request_count(mut self, value: u32) -> Self {
        self.inner.layered_image_view_request_count = value;
        self
    }
    #[inline]
    pub fn pipeline_cache_request_count(mut self, value: u32) -> Self {
        self.inner.pipeline_cache_request_count = value;
        self
    }
    #[inline]
    pub fn pipeline_layout_request_count(mut self, value: u32) -> Self {
        self.inner.pipeline_layout_request_count = value;
        self
    }
    #[inline]
    pub fn render_pass_request_count(mut self, value: u32) -> Self {
        self.inner.render_pass_request_count = value;
        self
    }
    #[inline]
    pub fn graphics_pipeline_request_count(mut self, value: u32) -> Self {
        self.inner.graphics_pipeline_request_count = value;
        self
    }
    #[inline]
    pub fn compute_pipeline_request_count(mut self, value: u32) -> Self {
        self.inner.compute_pipeline_request_count = value;
        self
    }
    #[inline]
    pub fn descriptor_set_layout_request_count(mut self, value: u32) -> Self {
        self.inner.descriptor_set_layout_request_count = value;
        self
    }
    #[inline]
    pub fn sampler_request_count(mut self, value: u32) -> Self {
        self.inner.sampler_request_count = value;
        self
    }
    #[inline]
    pub fn descriptor_pool_request_count(mut self, value: u32) -> Self {
        self.inner.descriptor_pool_request_count = value;
        self
    }
    #[inline]
    pub fn descriptor_set_request_count(mut self, value: u32) -> Self {
        self.inner.descriptor_set_request_count = value;
        self
    }
    #[inline]
    pub fn framebuffer_request_count(mut self, value: u32) -> Self {
        self.inner.framebuffer_request_count = value;
        self
    }
    #[inline]
    pub fn command_pool_request_count(mut self, value: u32) -> Self {
        self.inner.command_pool_request_count = value;
        self
    }
    #[inline]
    pub fn sampler_ycbcr_conversion_request_count(mut self, value: u32) -> Self {
        self.inner.sampler_ycbcr_conversion_request_count = value;
        self
    }
    #[inline]
    pub fn surface_request_count(mut self, value: u32) -> Self {
        self.inner.surface_request_count = value;
        self
    }
    #[inline]
    pub fn swapchain_request_count(mut self, value: u32) -> Self {
        self.inner.swapchain_request_count = value;
        self
    }
    #[inline]
    pub fn display_mode_request_count(mut self, value: u32) -> Self {
        self.inner.display_mode_request_count = value;
        self
    }
    #[inline]
    pub fn subpass_description_request_count(mut self, value: u32) -> Self {
        self.inner.subpass_description_request_count = value;
        self
    }
    #[inline]
    pub fn attachment_description_request_count(mut self, value: u32) -> Self {
        self.inner.attachment_description_request_count = value;
        self
    }
    #[inline]
    pub fn descriptor_set_layout_binding_request_count(mut self, value: u32) -> Self {
        self.inner.descriptor_set_layout_binding_request_count = value;
        self
    }
    #[inline]
    pub fn descriptor_set_layout_binding_limit(mut self, value: u32) -> Self {
        self.inner.descriptor_set_layout_binding_limit = value;
        self
    }
    #[inline]
    pub fn max_image_view_mip_levels(mut self, value: u32) -> Self {
        self.inner.max_image_view_mip_levels = value;
        self
    }
    #[inline]
    pub fn max_image_view_array_layers(mut self, value: u32) -> Self {
        self.inner.max_image_view_array_layers = value;
        self
    }
    #[inline]
    pub fn max_layered_image_view_mip_levels(mut self, value: u32) -> Self {
        self.inner.max_layered_image_view_mip_levels = value;
        self
    }
    #[inline]
    pub fn max_occlusion_queries_per_pool(mut self, value: u32) -> Self {
        self.inner.max_occlusion_queries_per_pool = value;
        self
    }
    #[inline]
    pub fn max_pipeline_statistics_queries_per_pool(mut self, value: u32) -> Self {
        self.inner.max_pipeline_statistics_queries_per_pool = value;
        self
    }
    #[inline]
    pub fn max_timestamp_queries_per_pool(mut self, value: u32) -> Self {
        self.inner.max_timestamp_queries_per_pool = value;
        self
    }
    #[inline]
    pub fn max_immutable_samplers_per_descriptor_set_layout(
        mut self,
        value: u32,
    ) -> Self {
        self.inner.max_immutable_samplers_per_descriptor_set_layout = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`DeviceObjectReservationCreateInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsDeviceObjectReservationCreateInfo>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for DeviceObjectReservationCreateInfoBuilder<'a> {
    type Target = DeviceObjectReservationCreateInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for DeviceObjectReservationCreateInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`CommandPoolMemoryReservationCreateInfo`] with lifetime-tied pNext safety.
pub struct CommandPoolMemoryReservationCreateInfoBuilder<'a> {
    inner: CommandPoolMemoryReservationCreateInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl CommandPoolMemoryReservationCreateInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> CommandPoolMemoryReservationCreateInfoBuilder<'a> {
        CommandPoolMemoryReservationCreateInfoBuilder {
            inner: CommandPoolMemoryReservationCreateInfo {
                s_type: StructureType::from_raw(1000298003i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> CommandPoolMemoryReservationCreateInfoBuilder<'a> {
    #[inline]
    pub fn command_pool_reserved_size(mut self, value: u64) -> Self {
        self.inner.command_pool_reserved_size = value;
        self
    }
    #[inline]
    pub fn command_pool_max_command_buffers(mut self, value: u32) -> Self {
        self.inner.command_pool_max_command_buffers = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`CommandPoolMemoryReservationCreateInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsCommandPoolMemoryReservationCreateInfo>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for CommandPoolMemoryReservationCreateInfoBuilder<'a> {
    type Target = CommandPoolMemoryReservationCreateInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for CommandPoolMemoryReservationCreateInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`CommandPoolMemoryConsumption`] with lifetime-tied pNext safety.
pub struct CommandPoolMemoryConsumptionBuilder<'a> {
    inner: CommandPoolMemoryConsumption,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl CommandPoolMemoryConsumption {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> CommandPoolMemoryConsumptionBuilder<'a> {
        CommandPoolMemoryConsumptionBuilder {
            inner: CommandPoolMemoryConsumption {
                s_type: StructureType::from_raw(1000298004i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> CommandPoolMemoryConsumptionBuilder<'a> {
    #[inline]
    pub fn command_pool_allocated(mut self, value: u64) -> Self {
        self.inner.command_pool_allocated = value;
        self
    }
    #[inline]
    pub fn command_pool_reserved_size(mut self, value: u64) -> Self {
        self.inner.command_pool_reserved_size = value;
        self
    }
    #[inline]
    pub fn command_buffer_allocated(mut self, value: u64) -> Self {
        self.inner.command_buffer_allocated = value;
        self
    }
}
impl<'a> core::ops::Deref for CommandPoolMemoryConsumptionBuilder<'a> {
    type Target = CommandPoolMemoryConsumption;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for CommandPoolMemoryConsumptionBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceVulkanSC10Features`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceVulkanSC10FeaturesBuilder<'a> {
    inner: PhysicalDeviceVulkanSC10Features,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceVulkanSC10Features {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceVulkanSC10FeaturesBuilder<'a> {
        PhysicalDeviceVulkanSC10FeaturesBuilder {
            inner: PhysicalDeviceVulkanSC10Features {
                s_type: StructureType::from_raw(1000298000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceVulkanSC10FeaturesBuilder<'a> {
    #[inline]
    pub fn shader_atomic_instructions(mut self, value: bool) -> Self {
        self.inner.shader_atomic_instructions = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceVulkanSC10Features`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceVulkanSC10Features>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceVulkanSC10FeaturesBuilder<'a> {
    type Target = PhysicalDeviceVulkanSC10Features;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceVulkanSC10FeaturesBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDevicePrimitivesGeneratedQueryFeaturesEXTBuilder<'a> {
    inner: PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDevicePrimitivesGeneratedQueryFeaturesEXTBuilder<
        'a,
    > {
        PhysicalDevicePrimitivesGeneratedQueryFeaturesEXTBuilder {
            inner: PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT {
                s_type: StructureType::from_raw(1000382000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDevicePrimitivesGeneratedQueryFeaturesEXTBuilder<'a> {
    #[inline]
    pub fn primitives_generated_query(mut self, value: bool) -> Self {
        self.inner.primitives_generated_query = value as u32;
        self
    }
    #[inline]
    pub fn primitives_generated_query_with_rasterizer_discard(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.primitives_generated_query_with_rasterizer_discard = value as u32;
        self
    }
    #[inline]
    pub fn primitives_generated_query_with_non_zero_streams(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.primitives_generated_query_with_non_zero_streams = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDevicePrimitivesGeneratedQueryFeaturesEXTBuilder<'a> {
    type Target = PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDevicePrimitivesGeneratedQueryFeaturesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceLegacyDitheringFeaturesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceLegacyDitheringFeaturesEXTBuilder<'a> {
    inner: PhysicalDeviceLegacyDitheringFeaturesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceLegacyDitheringFeaturesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceLegacyDitheringFeaturesEXTBuilder<'a> {
        PhysicalDeviceLegacyDitheringFeaturesEXTBuilder {
            inner: PhysicalDeviceLegacyDitheringFeaturesEXT {
                s_type: StructureType::from_raw(1000465000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceLegacyDitheringFeaturesEXTBuilder<'a> {
    #[inline]
    pub fn legacy_dithering(mut self, value: bool) -> Self {
        self.inner.legacy_dithering = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceLegacyDitheringFeaturesEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceLegacyDitheringFeaturesEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceLegacyDitheringFeaturesEXTBuilder<'a> {
    type Target = PhysicalDeviceLegacyDitheringFeaturesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceLegacyDitheringFeaturesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXTBuilder<'a> {
    inner: PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXTBuilder<
        'a,
    > {
        PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXTBuilder {
            inner: PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT {
                s_type: StructureType::from_raw(1000376000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXTBuilder<'a> {
    #[inline]
    pub fn multisampled_render_to_single_sampled(mut self, value: bool) -> Self {
        self.inner.multisampled_render_to_single_sampled = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<
        T: ExtendsPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT,
    >(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXTBuilder<'a> {
    type Target = PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`SurfaceCapabilitiesPresentId2KHR`] with lifetime-tied pNext safety.
pub struct SurfaceCapabilitiesPresentId2KHRBuilder<'a> {
    inner: SurfaceCapabilitiesPresentId2KHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl SurfaceCapabilitiesPresentId2KHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> SurfaceCapabilitiesPresentId2KHRBuilder<'a> {
        SurfaceCapabilitiesPresentId2KHRBuilder {
            inner: SurfaceCapabilitiesPresentId2KHR {
                s_type: StructureType::from_raw(1000479000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> SurfaceCapabilitiesPresentId2KHRBuilder<'a> {
    #[inline]
    pub fn present_id2_supported(mut self, value: bool) -> Self {
        self.inner.present_id2_supported = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`SurfaceCapabilitiesPresentId2KHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsSurfaceCapabilitiesPresentId2KHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for SurfaceCapabilitiesPresentId2KHRBuilder<'a> {
    type Target = SurfaceCapabilitiesPresentId2KHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for SurfaceCapabilitiesPresentId2KHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`SurfaceCapabilitiesPresentWait2KHR`] with lifetime-tied pNext safety.
pub struct SurfaceCapabilitiesPresentWait2KHRBuilder<'a> {
    inner: SurfaceCapabilitiesPresentWait2KHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl SurfaceCapabilitiesPresentWait2KHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> SurfaceCapabilitiesPresentWait2KHRBuilder<'a> {
        SurfaceCapabilitiesPresentWait2KHRBuilder {
            inner: SurfaceCapabilitiesPresentWait2KHR {
                s_type: StructureType::from_raw(1000480000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> SurfaceCapabilitiesPresentWait2KHRBuilder<'a> {
    #[inline]
    pub fn present_wait2_supported(mut self, value: bool) -> Self {
        self.inner.present_wait2_supported = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`SurfaceCapabilitiesPresentWait2KHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsSurfaceCapabilitiesPresentWait2KHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for SurfaceCapabilitiesPresentWait2KHRBuilder<'a> {
    type Target = SurfaceCapabilitiesPresentWait2KHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for SurfaceCapabilitiesPresentWait2KHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`SubpassResolvePerformanceQueryEXT`] with lifetime-tied pNext safety.
pub struct SubpassResolvePerformanceQueryEXTBuilder<'a> {
    inner: SubpassResolvePerformanceQueryEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl SubpassResolvePerformanceQueryEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> SubpassResolvePerformanceQueryEXTBuilder<'a> {
        SubpassResolvePerformanceQueryEXTBuilder {
            inner: SubpassResolvePerformanceQueryEXT {
                s_type: StructureType::from_raw(1000376001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> SubpassResolvePerformanceQueryEXTBuilder<'a> {
    #[inline]
    pub fn optimal(mut self, value: bool) -> Self {
        self.inner.optimal = value as u32;
        self
    }
}
impl<'a> core::ops::Deref for SubpassResolvePerformanceQueryEXTBuilder<'a> {
    type Target = SubpassResolvePerformanceQueryEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for SubpassResolvePerformanceQueryEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`MultisampledRenderToSingleSampledInfoEXT`] with lifetime-tied pNext safety.
pub struct MultisampledRenderToSingleSampledInfoEXTBuilder<'a> {
    inner: MultisampledRenderToSingleSampledInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl MultisampledRenderToSingleSampledInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> MultisampledRenderToSingleSampledInfoEXTBuilder<'a> {
        MultisampledRenderToSingleSampledInfoEXTBuilder {
            inner: MultisampledRenderToSingleSampledInfoEXT {
                s_type: StructureType::from_raw(1000376002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> MultisampledRenderToSingleSampledInfoEXTBuilder<'a> {
    #[inline]
    pub fn multisampled_render_to_single_sampled_enable(mut self, value: bool) -> Self {
        self.inner.multisampled_render_to_single_sampled_enable = value as u32;
        self
    }
    #[inline]
    pub fn rasterization_samples(mut self, value: SampleCountFlagBits) -> Self {
        self.inner.rasterization_samples = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`MultisampledRenderToSingleSampledInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsMultisampledRenderToSingleSampledInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for MultisampledRenderToSingleSampledInfoEXTBuilder<'a> {
    type Target = MultisampledRenderToSingleSampledInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for MultisampledRenderToSingleSampledInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDevicePipelineProtectedAccessFeatures`] with lifetime-tied pNext safety.
pub struct PhysicalDevicePipelineProtectedAccessFeaturesBuilder<'a> {
    inner: PhysicalDevicePipelineProtectedAccessFeatures,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDevicePipelineProtectedAccessFeatures {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDevicePipelineProtectedAccessFeaturesBuilder<'a> {
        PhysicalDevicePipelineProtectedAccessFeaturesBuilder {
            inner: PhysicalDevicePipelineProtectedAccessFeatures {
                s_type: StructureType::from_raw(1000466000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDevicePipelineProtectedAccessFeaturesBuilder<'a> {
    #[inline]
    pub fn pipeline_protected_access(mut self, value: bool) -> Self {
        self.inner.pipeline_protected_access = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDevicePipelineProtectedAccessFeatures`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDevicePipelineProtectedAccessFeatures>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDevicePipelineProtectedAccessFeaturesBuilder<'a> {
    type Target = PhysicalDevicePipelineProtectedAccessFeatures;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDevicePipelineProtectedAccessFeaturesBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`QueueFamilyVideoPropertiesKHR`] with lifetime-tied pNext safety.
pub struct QueueFamilyVideoPropertiesKHRBuilder<'a> {
    inner: QueueFamilyVideoPropertiesKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl QueueFamilyVideoPropertiesKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> QueueFamilyVideoPropertiesKHRBuilder<'a> {
        QueueFamilyVideoPropertiesKHRBuilder {
            inner: QueueFamilyVideoPropertiesKHR {
                s_type: StructureType::from_raw(1000023012i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> QueueFamilyVideoPropertiesKHRBuilder<'a> {
    #[inline]
    pub fn video_codec_operations(mut self, value: VideoCodecOperationFlagsKHR) -> Self {
        self.inner.video_codec_operations = value;
        self
    }
}
impl<'a> core::ops::Deref for QueueFamilyVideoPropertiesKHRBuilder<'a> {
    type Target = QueueFamilyVideoPropertiesKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for QueueFamilyVideoPropertiesKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`QueueFamilyQueryResultStatusPropertiesKHR`] with lifetime-tied pNext safety.
pub struct QueueFamilyQueryResultStatusPropertiesKHRBuilder<'a> {
    inner: QueueFamilyQueryResultStatusPropertiesKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl QueueFamilyQueryResultStatusPropertiesKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> QueueFamilyQueryResultStatusPropertiesKHRBuilder<'a> {
        QueueFamilyQueryResultStatusPropertiesKHRBuilder {
            inner: QueueFamilyQueryResultStatusPropertiesKHR {
                s_type: StructureType::from_raw(1000023016i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> QueueFamilyQueryResultStatusPropertiesKHRBuilder<'a> {
    #[inline]
    pub fn query_result_status_support(mut self, value: bool) -> Self {
        self.inner.query_result_status_support = value as u32;
        self
    }
}
impl<'a> core::ops::Deref for QueueFamilyQueryResultStatusPropertiesKHRBuilder<'a> {
    type Target = QueueFamilyQueryResultStatusPropertiesKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for QueueFamilyQueryResultStatusPropertiesKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VideoProfileListInfoKHR`] with lifetime-tied pNext safety.
pub struct VideoProfileListInfoKHRBuilder<'a> {
    inner: VideoProfileListInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl VideoProfileListInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> VideoProfileListInfoKHRBuilder<'a> {
        VideoProfileListInfoKHRBuilder {
            inner: VideoProfileListInfoKHR {
                s_type: StructureType::from_raw(1000023013i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> VideoProfileListInfoKHRBuilder<'a> {
    #[inline]
    pub fn profiles(mut self, slice: &'a [VideoProfileInfoKHR]) -> Self {
        self.inner.profile_count = slice.len() as u32;
        self.inner.p_profiles = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`VideoProfileListInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsVideoProfileListInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for VideoProfileListInfoKHRBuilder<'a> {
    type Target = VideoProfileListInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for VideoProfileListInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceVideoFormatInfoKHR`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceVideoFormatInfoKHRBuilder<'a> {
    inner: PhysicalDeviceVideoFormatInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceVideoFormatInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceVideoFormatInfoKHRBuilder<'a> {
        PhysicalDeviceVideoFormatInfoKHRBuilder {
            inner: PhysicalDeviceVideoFormatInfoKHR {
                s_type: StructureType::from_raw(1000023014i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceVideoFormatInfoKHRBuilder<'a> {
    #[inline]
    pub fn image_usage(mut self, value: ImageUsageFlags) -> Self {
        self.inner.image_usage = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceVideoFormatInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceVideoFormatInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceVideoFormatInfoKHRBuilder<'a> {
    type Target = PhysicalDeviceVideoFormatInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceVideoFormatInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VideoFormatPropertiesKHR`] with lifetime-tied pNext safety.
pub struct VideoFormatPropertiesKHRBuilder<'a> {
    inner: VideoFormatPropertiesKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl VideoFormatPropertiesKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> VideoFormatPropertiesKHRBuilder<'a> {
        VideoFormatPropertiesKHRBuilder {
            inner: VideoFormatPropertiesKHR {
                s_type: StructureType::from_raw(1000023015i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> VideoFormatPropertiesKHRBuilder<'a> {
    #[inline]
    pub fn format(mut self, value: Format) -> Self {
        self.inner.format = value;
        self
    }
    #[inline]
    pub fn component_mapping(mut self, value: ComponentMapping) -> Self {
        self.inner.component_mapping = value;
        self
    }
    #[inline]
    pub fn image_create_flags(mut self, value: ImageCreateFlags) -> Self {
        self.inner.image_create_flags = value;
        self
    }
    #[inline]
    pub fn image_type(mut self, value: ImageType) -> Self {
        self.inner.image_type = value;
        self
    }
    #[inline]
    pub fn image_tiling(mut self, value: ImageTiling) -> Self {
        self.inner.image_tiling = value;
        self
    }
    #[inline]
    pub fn image_usage_flags(mut self, value: ImageUsageFlags) -> Self {
        self.inner.image_usage_flags = value;
        self
    }
}
impl<'a> core::ops::Deref for VideoFormatPropertiesKHRBuilder<'a> {
    type Target = VideoFormatPropertiesKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for VideoFormatPropertiesKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VideoEncodeQuantizationMapCapabilitiesKHR`] with lifetime-tied pNext safety.
pub struct VideoEncodeQuantizationMapCapabilitiesKHRBuilder<'a> {
    inner: VideoEncodeQuantizationMapCapabilitiesKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl VideoEncodeQuantizationMapCapabilitiesKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> VideoEncodeQuantizationMapCapabilitiesKHRBuilder<'a> {
        VideoEncodeQuantizationMapCapabilitiesKHRBuilder {
            inner: VideoEncodeQuantizationMapCapabilitiesKHR {
                s_type: StructureType::from_raw(1000553000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> VideoEncodeQuantizationMapCapabilitiesKHRBuilder<'a> {
    #[inline]
    pub fn max_quantization_map_extent(mut self, value: Extent2D) -> Self {
        self.inner.max_quantization_map_extent = value;
        self
    }
}
impl<'a> core::ops::Deref for VideoEncodeQuantizationMapCapabilitiesKHRBuilder<'a> {
    type Target = VideoEncodeQuantizationMapCapabilitiesKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for VideoEncodeQuantizationMapCapabilitiesKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VideoEncodeH264QuantizationMapCapabilitiesKHR`] with lifetime-tied pNext safety.
pub struct VideoEncodeH264QuantizationMapCapabilitiesKHRBuilder<'a> {
    inner: VideoEncodeH264QuantizationMapCapabilitiesKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl VideoEncodeH264QuantizationMapCapabilitiesKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> VideoEncodeH264QuantizationMapCapabilitiesKHRBuilder<'a> {
        VideoEncodeH264QuantizationMapCapabilitiesKHRBuilder {
            inner: VideoEncodeH264QuantizationMapCapabilitiesKHR {
                s_type: StructureType::from_raw(1000553003i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> VideoEncodeH264QuantizationMapCapabilitiesKHRBuilder<'a> {
    #[inline]
    pub fn min_qp_delta(mut self, value: i32) -> Self {
        self.inner.min_qp_delta = value;
        self
    }
    #[inline]
    pub fn max_qp_delta(mut self, value: i32) -> Self {
        self.inner.max_qp_delta = value;
        self
    }
}
impl<'a> core::ops::Deref for VideoEncodeH264QuantizationMapCapabilitiesKHRBuilder<'a> {
    type Target = VideoEncodeH264QuantizationMapCapabilitiesKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for VideoEncodeH264QuantizationMapCapabilitiesKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VideoEncodeH265QuantizationMapCapabilitiesKHR`] with lifetime-tied pNext safety.
pub struct VideoEncodeH265QuantizationMapCapabilitiesKHRBuilder<'a> {
    inner: VideoEncodeH265QuantizationMapCapabilitiesKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl VideoEncodeH265QuantizationMapCapabilitiesKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> VideoEncodeH265QuantizationMapCapabilitiesKHRBuilder<'a> {
        VideoEncodeH265QuantizationMapCapabilitiesKHRBuilder {
            inner: VideoEncodeH265QuantizationMapCapabilitiesKHR {
                s_type: StructureType::from_raw(1000553004i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> VideoEncodeH265QuantizationMapCapabilitiesKHRBuilder<'a> {
    #[inline]
    pub fn min_qp_delta(mut self, value: i32) -> Self {
        self.inner.min_qp_delta = value;
        self
    }
    #[inline]
    pub fn max_qp_delta(mut self, value: i32) -> Self {
        self.inner.max_qp_delta = value;
        self
    }
}
impl<'a> core::ops::Deref for VideoEncodeH265QuantizationMapCapabilitiesKHRBuilder<'a> {
    type Target = VideoEncodeH265QuantizationMapCapabilitiesKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for VideoEncodeH265QuantizationMapCapabilitiesKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VideoEncodeAV1QuantizationMapCapabilitiesKHR`] with lifetime-tied pNext safety.
pub struct VideoEncodeAV1QuantizationMapCapabilitiesKHRBuilder<'a> {
    inner: VideoEncodeAV1QuantizationMapCapabilitiesKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl VideoEncodeAV1QuantizationMapCapabilitiesKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> VideoEncodeAV1QuantizationMapCapabilitiesKHRBuilder<'a> {
        VideoEncodeAV1QuantizationMapCapabilitiesKHRBuilder {
            inner: VideoEncodeAV1QuantizationMapCapabilitiesKHR {
                s_type: StructureType::from_raw(1000553007i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> VideoEncodeAV1QuantizationMapCapabilitiesKHRBuilder<'a> {
    #[inline]
    pub fn min_q_index_delta(mut self, value: i32) -> Self {
        self.inner.min_q_index_delta = value;
        self
    }
    #[inline]
    pub fn max_q_index_delta(mut self, value: i32) -> Self {
        self.inner.max_q_index_delta = value;
        self
    }
}
impl<'a> core::ops::Deref for VideoEncodeAV1QuantizationMapCapabilitiesKHRBuilder<'a> {
    type Target = VideoEncodeAV1QuantizationMapCapabilitiesKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for VideoEncodeAV1QuantizationMapCapabilitiesKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VideoFormatQuantizationMapPropertiesKHR`] with lifetime-tied pNext safety.
pub struct VideoFormatQuantizationMapPropertiesKHRBuilder<'a> {
    inner: VideoFormatQuantizationMapPropertiesKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl VideoFormatQuantizationMapPropertiesKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> VideoFormatQuantizationMapPropertiesKHRBuilder<'a> {
        VideoFormatQuantizationMapPropertiesKHRBuilder {
            inner: VideoFormatQuantizationMapPropertiesKHR {
                s_type: StructureType::from_raw(1000553001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> VideoFormatQuantizationMapPropertiesKHRBuilder<'a> {
    #[inline]
    pub fn quantization_map_texel_size(mut self, value: Extent2D) -> Self {
        self.inner.quantization_map_texel_size = value;
        self
    }
}
impl<'a> core::ops::Deref for VideoFormatQuantizationMapPropertiesKHRBuilder<'a> {
    type Target = VideoFormatQuantizationMapPropertiesKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for VideoFormatQuantizationMapPropertiesKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VideoFormatH265QuantizationMapPropertiesKHR`] with lifetime-tied pNext safety.
pub struct VideoFormatH265QuantizationMapPropertiesKHRBuilder<'a> {
    inner: VideoFormatH265QuantizationMapPropertiesKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl VideoFormatH265QuantizationMapPropertiesKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> VideoFormatH265QuantizationMapPropertiesKHRBuilder<'a> {
        VideoFormatH265QuantizationMapPropertiesKHRBuilder {
            inner: VideoFormatH265QuantizationMapPropertiesKHR {
                s_type: StructureType::from_raw(1000553006i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> VideoFormatH265QuantizationMapPropertiesKHRBuilder<'a> {
    #[inline]
    pub fn compatible_ctb_sizes(
        mut self,
        value: VideoEncodeH265CtbSizeFlagsKHR,
    ) -> Self {
        self.inner.compatible_ctb_sizes = value;
        self
    }
}
impl<'a> core::ops::Deref for VideoFormatH265QuantizationMapPropertiesKHRBuilder<'a> {
    type Target = VideoFormatH265QuantizationMapPropertiesKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for VideoFormatH265QuantizationMapPropertiesKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VideoFormatAV1QuantizationMapPropertiesKHR`] with lifetime-tied pNext safety.
pub struct VideoFormatAV1QuantizationMapPropertiesKHRBuilder<'a> {
    inner: VideoFormatAV1QuantizationMapPropertiesKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl VideoFormatAV1QuantizationMapPropertiesKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> VideoFormatAV1QuantizationMapPropertiesKHRBuilder<'a> {
        VideoFormatAV1QuantizationMapPropertiesKHRBuilder {
            inner: VideoFormatAV1QuantizationMapPropertiesKHR {
                s_type: StructureType::from_raw(1000553008i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> VideoFormatAV1QuantizationMapPropertiesKHRBuilder<'a> {
    #[inline]
    pub fn compatible_superblock_sizes(
        mut self,
        value: VideoEncodeAV1SuperblockSizeFlagsKHR,
    ) -> Self {
        self.inner.compatible_superblock_sizes = value;
        self
    }
}
impl<'a> core::ops::Deref for VideoFormatAV1QuantizationMapPropertiesKHRBuilder<'a> {
    type Target = VideoFormatAV1QuantizationMapPropertiesKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for VideoFormatAV1QuantizationMapPropertiesKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VideoProfileInfoKHR`] with lifetime-tied pNext safety.
pub struct VideoProfileInfoKHRBuilder<'a> {
    inner: VideoProfileInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl VideoProfileInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> VideoProfileInfoKHRBuilder<'a> {
        VideoProfileInfoKHRBuilder {
            inner: VideoProfileInfoKHR {
                s_type: StructureType::from_raw(1000023000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> VideoProfileInfoKHRBuilder<'a> {
    #[inline]
    pub fn video_codec_operation(
        mut self,
        value: VideoCodecOperationFlagBitsKHR,
    ) -> Self {
        self.inner.video_codec_operation = value;
        self
    }
    #[inline]
    pub fn chroma_subsampling(mut self, value: VideoChromaSubsamplingFlagsKHR) -> Self {
        self.inner.chroma_subsampling = value;
        self
    }
    #[inline]
    pub fn luma_bit_depth(mut self, value: VideoComponentBitDepthFlagsKHR) -> Self {
        self.inner.luma_bit_depth = value;
        self
    }
    #[inline]
    pub fn chroma_bit_depth(mut self, value: VideoComponentBitDepthFlagsKHR) -> Self {
        self.inner.chroma_bit_depth = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`VideoProfileInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsVideoProfileInfoKHR>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for VideoProfileInfoKHRBuilder<'a> {
    type Target = VideoProfileInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for VideoProfileInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VideoCapabilitiesKHR`] with lifetime-tied pNext safety.
pub struct VideoCapabilitiesKHRBuilder<'a> {
    inner: VideoCapabilitiesKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl VideoCapabilitiesKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> VideoCapabilitiesKHRBuilder<'a> {
        VideoCapabilitiesKHRBuilder {
            inner: VideoCapabilitiesKHR {
                s_type: StructureType::from_raw(1000023001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> VideoCapabilitiesKHRBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: VideoCapabilityFlagsKHR) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn min_bitstream_buffer_offset_alignment(mut self, value: u64) -> Self {
        self.inner.min_bitstream_buffer_offset_alignment = value;
        self
    }
    #[inline]
    pub fn min_bitstream_buffer_size_alignment(mut self, value: u64) -> Self {
        self.inner.min_bitstream_buffer_size_alignment = value;
        self
    }
    #[inline]
    pub fn picture_access_granularity(mut self, value: Extent2D) -> Self {
        self.inner.picture_access_granularity = value;
        self
    }
    #[inline]
    pub fn min_coded_extent(mut self, value: Extent2D) -> Self {
        self.inner.min_coded_extent = value;
        self
    }
    #[inline]
    pub fn max_coded_extent(mut self, value: Extent2D) -> Self {
        self.inner.max_coded_extent = value;
        self
    }
    #[inline]
    pub fn max_dpb_slots(mut self, value: u32) -> Self {
        self.inner.max_dpb_slots = value;
        self
    }
    #[inline]
    pub fn max_active_reference_pictures(mut self, value: u32) -> Self {
        self.inner.max_active_reference_pictures = value;
        self
    }
    #[inline]
    pub fn std_header_version(mut self, value: ExtensionProperties) -> Self {
        self.inner.std_header_version = value;
        self
    }
}
impl<'a> core::ops::Deref for VideoCapabilitiesKHRBuilder<'a> {
    type Target = VideoCapabilitiesKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for VideoCapabilitiesKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VideoSessionMemoryRequirementsKHR`] with lifetime-tied pNext safety.
pub struct VideoSessionMemoryRequirementsKHRBuilder<'a> {
    inner: VideoSessionMemoryRequirementsKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl VideoSessionMemoryRequirementsKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> VideoSessionMemoryRequirementsKHRBuilder<'a> {
        VideoSessionMemoryRequirementsKHRBuilder {
            inner: VideoSessionMemoryRequirementsKHR {
                s_type: StructureType::from_raw(1000023003i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> VideoSessionMemoryRequirementsKHRBuilder<'a> {
    #[inline]
    pub fn memory_bind_index(mut self, value: u32) -> Self {
        self.inner.memory_bind_index = value;
        self
    }
    #[inline]
    pub fn memory_requirements(mut self, value: MemoryRequirements) -> Self {
        self.inner.memory_requirements = value;
        self
    }
}
impl<'a> core::ops::Deref for VideoSessionMemoryRequirementsKHRBuilder<'a> {
    type Target = VideoSessionMemoryRequirementsKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for VideoSessionMemoryRequirementsKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`BindVideoSessionMemoryInfoKHR`] with lifetime-tied pNext safety.
pub struct BindVideoSessionMemoryInfoKHRBuilder<'a> {
    inner: BindVideoSessionMemoryInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl BindVideoSessionMemoryInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> BindVideoSessionMemoryInfoKHRBuilder<'a> {
        BindVideoSessionMemoryInfoKHRBuilder {
            inner: BindVideoSessionMemoryInfoKHR {
                s_type: StructureType::from_raw(1000023004i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> BindVideoSessionMemoryInfoKHRBuilder<'a> {
    #[inline]
    pub fn memory_bind_index(mut self, value: u32) -> Self {
        self.inner.memory_bind_index = value;
        self
    }
    #[inline]
    pub fn memory(mut self, value: DeviceMemory) -> Self {
        self.inner.memory = value;
        self
    }
    #[inline]
    pub fn memory_offset(mut self, value: u64) -> Self {
        self.inner.memory_offset = value;
        self
    }
    #[inline]
    pub fn memory_size(mut self, value: u64) -> Self {
        self.inner.memory_size = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`BindVideoSessionMemoryInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsBindVideoSessionMemoryInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for BindVideoSessionMemoryInfoKHRBuilder<'a> {
    type Target = BindVideoSessionMemoryInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for BindVideoSessionMemoryInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VideoPictureResourceInfoKHR`] with lifetime-tied pNext safety.
pub struct VideoPictureResourceInfoKHRBuilder<'a> {
    inner: VideoPictureResourceInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl VideoPictureResourceInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> VideoPictureResourceInfoKHRBuilder<'a> {
        VideoPictureResourceInfoKHRBuilder {
            inner: VideoPictureResourceInfoKHR {
                s_type: StructureType::from_raw(1000023002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> VideoPictureResourceInfoKHRBuilder<'a> {
    #[inline]
    pub fn coded_offset(mut self, value: Offset2D) -> Self {
        self.inner.coded_offset = value;
        self
    }
    #[inline]
    pub fn coded_extent(mut self, value: Extent2D) -> Self {
        self.inner.coded_extent = value;
        self
    }
    #[inline]
    pub fn base_array_layer(mut self, value: u32) -> Self {
        self.inner.base_array_layer = value;
        self
    }
    #[inline]
    pub fn image_view_binding(mut self, value: ImageView) -> Self {
        self.inner.image_view_binding = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`VideoPictureResourceInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsVideoPictureResourceInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for VideoPictureResourceInfoKHRBuilder<'a> {
    type Target = VideoPictureResourceInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for VideoPictureResourceInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VideoReferenceSlotInfoKHR`] with lifetime-tied pNext safety.
pub struct VideoReferenceSlotInfoKHRBuilder<'a> {
    inner: VideoReferenceSlotInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl VideoReferenceSlotInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> VideoReferenceSlotInfoKHRBuilder<'a> {
        VideoReferenceSlotInfoKHRBuilder {
            inner: VideoReferenceSlotInfoKHR {
                s_type: StructureType::from_raw(1000023011i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> VideoReferenceSlotInfoKHRBuilder<'a> {
    #[inline]
    pub fn slot_index(mut self, value: i32) -> Self {
        self.inner.slot_index = value;
        self
    }
    #[inline]
    pub fn picture_resource(mut self, value: &'a VideoPictureResourceInfoKHR) -> Self {
        self.inner.p_picture_resource = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`VideoReferenceSlotInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsVideoReferenceSlotInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for VideoReferenceSlotInfoKHRBuilder<'a> {
    type Target = VideoReferenceSlotInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for VideoReferenceSlotInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VideoDecodeCapabilitiesKHR`] with lifetime-tied pNext safety.
pub struct VideoDecodeCapabilitiesKHRBuilder<'a> {
    inner: VideoDecodeCapabilitiesKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl VideoDecodeCapabilitiesKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> VideoDecodeCapabilitiesKHRBuilder<'a> {
        VideoDecodeCapabilitiesKHRBuilder {
            inner: VideoDecodeCapabilitiesKHR {
                s_type: StructureType::from_raw(1000024001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> VideoDecodeCapabilitiesKHRBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: VideoDecodeCapabilityFlagsKHR) -> Self {
        self.inner.flags = value;
        self
    }
}
impl<'a> core::ops::Deref for VideoDecodeCapabilitiesKHRBuilder<'a> {
    type Target = VideoDecodeCapabilitiesKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for VideoDecodeCapabilitiesKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VideoDecodeUsageInfoKHR`] with lifetime-tied pNext safety.
pub struct VideoDecodeUsageInfoKHRBuilder<'a> {
    inner: VideoDecodeUsageInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl VideoDecodeUsageInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> VideoDecodeUsageInfoKHRBuilder<'a> {
        VideoDecodeUsageInfoKHRBuilder {
            inner: VideoDecodeUsageInfoKHR {
                s_type: StructureType::from_raw(1000024002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> VideoDecodeUsageInfoKHRBuilder<'a> {
    #[inline]
    pub fn video_usage_hints(mut self, value: VideoDecodeUsageFlagsKHR) -> Self {
        self.inner.video_usage_hints = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`VideoDecodeUsageInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsVideoDecodeUsageInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for VideoDecodeUsageInfoKHRBuilder<'a> {
    type Target = VideoDecodeUsageInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for VideoDecodeUsageInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VideoDecodeInfoKHR`] with lifetime-tied pNext safety.
pub struct VideoDecodeInfoKHRBuilder<'a> {
    inner: VideoDecodeInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl VideoDecodeInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> VideoDecodeInfoKHRBuilder<'a> {
        VideoDecodeInfoKHRBuilder {
            inner: VideoDecodeInfoKHR {
                s_type: StructureType::from_raw(1000024000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> VideoDecodeInfoKHRBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: VideoDecodeFlagsKHR) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn src_buffer(mut self, value: Buffer) -> Self {
        self.inner.src_buffer = value;
        self
    }
    #[inline]
    pub fn src_buffer_offset(mut self, value: u64) -> Self {
        self.inner.src_buffer_offset = value;
        self
    }
    #[inline]
    pub fn src_buffer_range(mut self, value: u64) -> Self {
        self.inner.src_buffer_range = value;
        self
    }
    #[inline]
    pub fn dst_picture_resource(mut self, value: VideoPictureResourceInfoKHR) -> Self {
        self.inner.dst_picture_resource = value;
        self
    }
    #[inline]
    pub fn setup_reference_slot(mut self, value: &'a VideoReferenceSlotInfoKHR) -> Self {
        self.inner.p_setup_reference_slot = value;
        self
    }
    #[inline]
    pub fn reference_slots(mut self, slice: &'a [VideoReferenceSlotInfoKHR]) -> Self {
        self.inner.reference_slot_count = slice.len() as u32;
        self.inner.p_reference_slots = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`VideoDecodeInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsVideoDecodeInfoKHR>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for VideoDecodeInfoKHRBuilder<'a> {
    type Target = VideoDecodeInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for VideoDecodeInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceVideoMaintenance1FeaturesKHR`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceVideoMaintenance1FeaturesKHRBuilder<'a> {
    inner: PhysicalDeviceVideoMaintenance1FeaturesKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceVideoMaintenance1FeaturesKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceVideoMaintenance1FeaturesKHRBuilder<'a> {
        PhysicalDeviceVideoMaintenance1FeaturesKHRBuilder {
            inner: PhysicalDeviceVideoMaintenance1FeaturesKHR {
                s_type: StructureType::from_raw(1000515000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceVideoMaintenance1FeaturesKHRBuilder<'a> {
    #[inline]
    pub fn video_maintenance1(mut self, value: bool) -> Self {
        self.inner.video_maintenance1 = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceVideoMaintenance1FeaturesKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceVideoMaintenance1FeaturesKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceVideoMaintenance1FeaturesKHRBuilder<'a> {
    type Target = PhysicalDeviceVideoMaintenance1FeaturesKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceVideoMaintenance1FeaturesKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceVideoMaintenance2FeaturesKHR`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceVideoMaintenance2FeaturesKHRBuilder<'a> {
    inner: PhysicalDeviceVideoMaintenance2FeaturesKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceVideoMaintenance2FeaturesKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceVideoMaintenance2FeaturesKHRBuilder<'a> {
        PhysicalDeviceVideoMaintenance2FeaturesKHRBuilder {
            inner: PhysicalDeviceVideoMaintenance2FeaturesKHR {
                s_type: StructureType::from_raw(1000586000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceVideoMaintenance2FeaturesKHRBuilder<'a> {
    #[inline]
    pub fn video_maintenance2(mut self, value: bool) -> Self {
        self.inner.video_maintenance2 = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceVideoMaintenance2FeaturesKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceVideoMaintenance2FeaturesKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceVideoMaintenance2FeaturesKHRBuilder<'a> {
    type Target = PhysicalDeviceVideoMaintenance2FeaturesKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceVideoMaintenance2FeaturesKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VideoInlineQueryInfoKHR`] with lifetime-tied pNext safety.
pub struct VideoInlineQueryInfoKHRBuilder<'a> {
    inner: VideoInlineQueryInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl VideoInlineQueryInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> VideoInlineQueryInfoKHRBuilder<'a> {
        VideoInlineQueryInfoKHRBuilder {
            inner: VideoInlineQueryInfoKHR {
                s_type: StructureType::from_raw(1000515001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> VideoInlineQueryInfoKHRBuilder<'a> {
    #[inline]
    pub fn query_pool(mut self, value: QueryPool) -> Self {
        self.inner.query_pool = value;
        self
    }
    #[inline]
    pub fn first_query(mut self, value: u32) -> Self {
        self.inner.first_query = value;
        self
    }
    #[inline]
    pub fn query_count(mut self, value: u32) -> Self {
        self.inner.query_count = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`VideoInlineQueryInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsVideoInlineQueryInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for VideoInlineQueryInfoKHRBuilder<'a> {
    type Target = VideoInlineQueryInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for VideoInlineQueryInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VideoDecodeH264ProfileInfoKHR`] with lifetime-tied pNext safety.
pub struct VideoDecodeH264ProfileInfoKHRBuilder<'a> {
    inner: VideoDecodeH264ProfileInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl VideoDecodeH264ProfileInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> VideoDecodeH264ProfileInfoKHRBuilder<'a> {
        VideoDecodeH264ProfileInfoKHRBuilder {
            inner: VideoDecodeH264ProfileInfoKHR {
                s_type: StructureType::from_raw(1000040003i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> VideoDecodeH264ProfileInfoKHRBuilder<'a> {
    #[inline]
    pub fn std_profile_idc(mut self, value: StdVideoH264ProfileIdc) -> Self {
        self.inner.std_profile_idc = value;
        self
    }
    #[inline]
    pub fn picture_layout(
        mut self,
        value: VideoDecodeH264PictureLayoutFlagBitsKHR,
    ) -> Self {
        self.inner.picture_layout = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`VideoDecodeH264ProfileInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsVideoDecodeH264ProfileInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for VideoDecodeH264ProfileInfoKHRBuilder<'a> {
    type Target = VideoDecodeH264ProfileInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for VideoDecodeH264ProfileInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VideoDecodeH264CapabilitiesKHR`] with lifetime-tied pNext safety.
pub struct VideoDecodeH264CapabilitiesKHRBuilder<'a> {
    inner: VideoDecodeH264CapabilitiesKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl VideoDecodeH264CapabilitiesKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> VideoDecodeH264CapabilitiesKHRBuilder<'a> {
        VideoDecodeH264CapabilitiesKHRBuilder {
            inner: VideoDecodeH264CapabilitiesKHR {
                s_type: StructureType::from_raw(1000040000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> VideoDecodeH264CapabilitiesKHRBuilder<'a> {
    #[inline]
    pub fn max_level_idc(mut self, value: StdVideoH264LevelIdc) -> Self {
        self.inner.max_level_idc = value;
        self
    }
    #[inline]
    pub fn field_offset_granularity(mut self, value: Offset2D) -> Self {
        self.inner.field_offset_granularity = value;
        self
    }
}
impl<'a> core::ops::Deref for VideoDecodeH264CapabilitiesKHRBuilder<'a> {
    type Target = VideoDecodeH264CapabilitiesKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for VideoDecodeH264CapabilitiesKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VideoDecodeH264SessionParametersAddInfoKHR`] with lifetime-tied pNext safety.
pub struct VideoDecodeH264SessionParametersAddInfoKHRBuilder<'a> {
    inner: VideoDecodeH264SessionParametersAddInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl VideoDecodeH264SessionParametersAddInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> VideoDecodeH264SessionParametersAddInfoKHRBuilder<'a> {
        VideoDecodeH264SessionParametersAddInfoKHRBuilder {
            inner: VideoDecodeH264SessionParametersAddInfoKHR {
                s_type: StructureType::from_raw(1000040005i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> VideoDecodeH264SessionParametersAddInfoKHRBuilder<'a> {
    #[inline]
    pub fn std_sp_ss(mut self, slice: &'a [StdVideoH264SequenceParameterSet]) -> Self {
        self.inner.std_sps_count = slice.len() as u32;
        self.inner.p_std_sp_ss = slice.as_ptr();
        self
    }
    #[inline]
    pub fn std_pp_ss(mut self, slice: &'a [StdVideoH264PictureParameterSet]) -> Self {
        self.inner.std_pps_count = slice.len() as u32;
        self.inner.p_std_pp_ss = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`VideoDecodeH264SessionParametersAddInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsVideoDecodeH264SessionParametersAddInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for VideoDecodeH264SessionParametersAddInfoKHRBuilder<'a> {
    type Target = VideoDecodeH264SessionParametersAddInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for VideoDecodeH264SessionParametersAddInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VideoDecodeH264SessionParametersCreateInfoKHR`] with lifetime-tied pNext safety.
pub struct VideoDecodeH264SessionParametersCreateInfoKHRBuilder<'a> {
    inner: VideoDecodeH264SessionParametersCreateInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl VideoDecodeH264SessionParametersCreateInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> VideoDecodeH264SessionParametersCreateInfoKHRBuilder<'a> {
        VideoDecodeH264SessionParametersCreateInfoKHRBuilder {
            inner: VideoDecodeH264SessionParametersCreateInfoKHR {
                s_type: StructureType::from_raw(1000040004i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> VideoDecodeH264SessionParametersCreateInfoKHRBuilder<'a> {
    #[inline]
    pub fn max_std_sps_count(mut self, value: u32) -> Self {
        self.inner.max_std_sps_count = value;
        self
    }
    #[inline]
    pub fn max_std_pps_count(mut self, value: u32) -> Self {
        self.inner.max_std_pps_count = value;
        self
    }
    #[inline]
    pub fn parameters_add_info(
        mut self,
        value: &'a VideoDecodeH264SessionParametersAddInfoKHR,
    ) -> Self {
        self.inner.p_parameters_add_info = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`VideoDecodeH264SessionParametersCreateInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsVideoDecodeH264SessionParametersCreateInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for VideoDecodeH264SessionParametersCreateInfoKHRBuilder<'a> {
    type Target = VideoDecodeH264SessionParametersCreateInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for VideoDecodeH264SessionParametersCreateInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VideoDecodeH264InlineSessionParametersInfoKHR`] with lifetime-tied pNext safety.
pub struct VideoDecodeH264InlineSessionParametersInfoKHRBuilder<'a> {
    inner: VideoDecodeH264InlineSessionParametersInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl VideoDecodeH264InlineSessionParametersInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> VideoDecodeH264InlineSessionParametersInfoKHRBuilder<'a> {
        VideoDecodeH264InlineSessionParametersInfoKHRBuilder {
            inner: VideoDecodeH264InlineSessionParametersInfoKHR {
                s_type: StructureType::from_raw(1000586001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> VideoDecodeH264InlineSessionParametersInfoKHRBuilder<'a> {
    #[inline]
    pub fn std_sps(mut self, value: *const StdVideoH264SequenceParameterSet) -> Self {
        self.inner.p_std_sps = value;
        self
    }
    #[inline]
    pub fn std_pps(mut self, value: *const StdVideoH264PictureParameterSet) -> Self {
        self.inner.p_std_pps = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`VideoDecodeH264InlineSessionParametersInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsVideoDecodeH264InlineSessionParametersInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for VideoDecodeH264InlineSessionParametersInfoKHRBuilder<'a> {
    type Target = VideoDecodeH264InlineSessionParametersInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for VideoDecodeH264InlineSessionParametersInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VideoDecodeH264PictureInfoKHR`] with lifetime-tied pNext safety.
pub struct VideoDecodeH264PictureInfoKHRBuilder<'a> {
    inner: VideoDecodeH264PictureInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl VideoDecodeH264PictureInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> VideoDecodeH264PictureInfoKHRBuilder<'a> {
        VideoDecodeH264PictureInfoKHRBuilder {
            inner: VideoDecodeH264PictureInfoKHR {
                s_type: StructureType::from_raw(1000040001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> VideoDecodeH264PictureInfoKHRBuilder<'a> {
    #[inline]
    pub fn std_picture_info(
        mut self,
        value: *const StdVideoDecodeH264PictureInfo,
    ) -> Self {
        self.inner.p_std_picture_info = value;
        self
    }
    #[inline]
    pub fn slice_offsets(mut self, slice: &'a [u32]) -> Self {
        self.inner.slice_count = slice.len() as u32;
        self.inner.p_slice_offsets = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`VideoDecodeH264PictureInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsVideoDecodeH264PictureInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for VideoDecodeH264PictureInfoKHRBuilder<'a> {
    type Target = VideoDecodeH264PictureInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for VideoDecodeH264PictureInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VideoDecodeH264DpbSlotInfoKHR`] with lifetime-tied pNext safety.
pub struct VideoDecodeH264DpbSlotInfoKHRBuilder<'a> {
    inner: VideoDecodeH264DpbSlotInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl VideoDecodeH264DpbSlotInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> VideoDecodeH264DpbSlotInfoKHRBuilder<'a> {
        VideoDecodeH264DpbSlotInfoKHRBuilder {
            inner: VideoDecodeH264DpbSlotInfoKHR {
                s_type: StructureType::from_raw(1000040006i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> VideoDecodeH264DpbSlotInfoKHRBuilder<'a> {
    #[inline]
    pub fn std_reference_info(
        mut self,
        value: *const StdVideoDecodeH264ReferenceInfo,
    ) -> Self {
        self.inner.p_std_reference_info = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`VideoDecodeH264DpbSlotInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsVideoDecodeH264DpbSlotInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for VideoDecodeH264DpbSlotInfoKHRBuilder<'a> {
    type Target = VideoDecodeH264DpbSlotInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for VideoDecodeH264DpbSlotInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VideoDecodeH265ProfileInfoKHR`] with lifetime-tied pNext safety.
pub struct VideoDecodeH265ProfileInfoKHRBuilder<'a> {
    inner: VideoDecodeH265ProfileInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl VideoDecodeH265ProfileInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> VideoDecodeH265ProfileInfoKHRBuilder<'a> {
        VideoDecodeH265ProfileInfoKHRBuilder {
            inner: VideoDecodeH265ProfileInfoKHR {
                s_type: StructureType::from_raw(1000187003i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> VideoDecodeH265ProfileInfoKHRBuilder<'a> {
    #[inline]
    pub fn std_profile_idc(mut self, value: StdVideoH265ProfileIdc) -> Self {
        self.inner.std_profile_idc = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`VideoDecodeH265ProfileInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsVideoDecodeH265ProfileInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for VideoDecodeH265ProfileInfoKHRBuilder<'a> {
    type Target = VideoDecodeH265ProfileInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for VideoDecodeH265ProfileInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VideoDecodeH265CapabilitiesKHR`] with lifetime-tied pNext safety.
pub struct VideoDecodeH265CapabilitiesKHRBuilder<'a> {
    inner: VideoDecodeH265CapabilitiesKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl VideoDecodeH265CapabilitiesKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> VideoDecodeH265CapabilitiesKHRBuilder<'a> {
        VideoDecodeH265CapabilitiesKHRBuilder {
            inner: VideoDecodeH265CapabilitiesKHR {
                s_type: StructureType::from_raw(1000187000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> VideoDecodeH265CapabilitiesKHRBuilder<'a> {
    #[inline]
    pub fn max_level_idc(mut self, value: StdVideoH265LevelIdc) -> Self {
        self.inner.max_level_idc = value;
        self
    }
}
impl<'a> core::ops::Deref for VideoDecodeH265CapabilitiesKHRBuilder<'a> {
    type Target = VideoDecodeH265CapabilitiesKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for VideoDecodeH265CapabilitiesKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VideoDecodeH265SessionParametersAddInfoKHR`] with lifetime-tied pNext safety.
pub struct VideoDecodeH265SessionParametersAddInfoKHRBuilder<'a> {
    inner: VideoDecodeH265SessionParametersAddInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl VideoDecodeH265SessionParametersAddInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> VideoDecodeH265SessionParametersAddInfoKHRBuilder<'a> {
        VideoDecodeH265SessionParametersAddInfoKHRBuilder {
            inner: VideoDecodeH265SessionParametersAddInfoKHR {
                s_type: StructureType::from_raw(1000187002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> VideoDecodeH265SessionParametersAddInfoKHRBuilder<'a> {
    #[inline]
    pub fn std_vp_ss(mut self, slice: &'a [StdVideoH265VideoParameterSet]) -> Self {
        self.inner.std_vps_count = slice.len() as u32;
        self.inner.p_std_vp_ss = slice.as_ptr();
        self
    }
    #[inline]
    pub fn std_sp_ss(mut self, slice: &'a [StdVideoH265SequenceParameterSet]) -> Self {
        self.inner.std_sps_count = slice.len() as u32;
        self.inner.p_std_sp_ss = slice.as_ptr();
        self
    }
    #[inline]
    pub fn std_pp_ss(mut self, slice: &'a [StdVideoH265PictureParameterSet]) -> Self {
        self.inner.std_pps_count = slice.len() as u32;
        self.inner.p_std_pp_ss = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`VideoDecodeH265SessionParametersAddInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsVideoDecodeH265SessionParametersAddInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for VideoDecodeH265SessionParametersAddInfoKHRBuilder<'a> {
    type Target = VideoDecodeH265SessionParametersAddInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for VideoDecodeH265SessionParametersAddInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VideoDecodeH265SessionParametersCreateInfoKHR`] with lifetime-tied pNext safety.
pub struct VideoDecodeH265SessionParametersCreateInfoKHRBuilder<'a> {
    inner: VideoDecodeH265SessionParametersCreateInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl VideoDecodeH265SessionParametersCreateInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> VideoDecodeH265SessionParametersCreateInfoKHRBuilder<'a> {
        VideoDecodeH265SessionParametersCreateInfoKHRBuilder {
            inner: VideoDecodeH265SessionParametersCreateInfoKHR {
                s_type: StructureType::from_raw(1000187001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> VideoDecodeH265SessionParametersCreateInfoKHRBuilder<'a> {
    #[inline]
    pub fn max_std_vps_count(mut self, value: u32) -> Self {
        self.inner.max_std_vps_count = value;
        self
    }
    #[inline]
    pub fn max_std_sps_count(mut self, value: u32) -> Self {
        self.inner.max_std_sps_count = value;
        self
    }
    #[inline]
    pub fn max_std_pps_count(mut self, value: u32) -> Self {
        self.inner.max_std_pps_count = value;
        self
    }
    #[inline]
    pub fn parameters_add_info(
        mut self,
        value: &'a VideoDecodeH265SessionParametersAddInfoKHR,
    ) -> Self {
        self.inner.p_parameters_add_info = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`VideoDecodeH265SessionParametersCreateInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsVideoDecodeH265SessionParametersCreateInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for VideoDecodeH265SessionParametersCreateInfoKHRBuilder<'a> {
    type Target = VideoDecodeH265SessionParametersCreateInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for VideoDecodeH265SessionParametersCreateInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VideoDecodeH265InlineSessionParametersInfoKHR`] with lifetime-tied pNext safety.
pub struct VideoDecodeH265InlineSessionParametersInfoKHRBuilder<'a> {
    inner: VideoDecodeH265InlineSessionParametersInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl VideoDecodeH265InlineSessionParametersInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> VideoDecodeH265InlineSessionParametersInfoKHRBuilder<'a> {
        VideoDecodeH265InlineSessionParametersInfoKHRBuilder {
            inner: VideoDecodeH265InlineSessionParametersInfoKHR {
                s_type: StructureType::from_raw(1000586002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> VideoDecodeH265InlineSessionParametersInfoKHRBuilder<'a> {
    #[inline]
    pub fn std_vps(mut self, value: *const StdVideoH265VideoParameterSet) -> Self {
        self.inner.p_std_vps = value;
        self
    }
    #[inline]
    pub fn std_sps(mut self, value: *const StdVideoH265SequenceParameterSet) -> Self {
        self.inner.p_std_sps = value;
        self
    }
    #[inline]
    pub fn std_pps(mut self, value: *const StdVideoH265PictureParameterSet) -> Self {
        self.inner.p_std_pps = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`VideoDecodeH265InlineSessionParametersInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsVideoDecodeH265InlineSessionParametersInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for VideoDecodeH265InlineSessionParametersInfoKHRBuilder<'a> {
    type Target = VideoDecodeH265InlineSessionParametersInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for VideoDecodeH265InlineSessionParametersInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VideoDecodeH265PictureInfoKHR`] with lifetime-tied pNext safety.
pub struct VideoDecodeH265PictureInfoKHRBuilder<'a> {
    inner: VideoDecodeH265PictureInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl VideoDecodeH265PictureInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> VideoDecodeH265PictureInfoKHRBuilder<'a> {
        VideoDecodeH265PictureInfoKHRBuilder {
            inner: VideoDecodeH265PictureInfoKHR {
                s_type: StructureType::from_raw(1000187004i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> VideoDecodeH265PictureInfoKHRBuilder<'a> {
    #[inline]
    pub fn std_picture_info(
        mut self,
        value: *const StdVideoDecodeH265PictureInfo,
    ) -> Self {
        self.inner.p_std_picture_info = value;
        self
    }
    #[inline]
    pub fn slice_segment_offsets(mut self, slice: &'a [u32]) -> Self {
        self.inner.slice_segment_count = slice.len() as u32;
        self.inner.p_slice_segment_offsets = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`VideoDecodeH265PictureInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsVideoDecodeH265PictureInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for VideoDecodeH265PictureInfoKHRBuilder<'a> {
    type Target = VideoDecodeH265PictureInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for VideoDecodeH265PictureInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VideoDecodeH265DpbSlotInfoKHR`] with lifetime-tied pNext safety.
pub struct VideoDecodeH265DpbSlotInfoKHRBuilder<'a> {
    inner: VideoDecodeH265DpbSlotInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl VideoDecodeH265DpbSlotInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> VideoDecodeH265DpbSlotInfoKHRBuilder<'a> {
        VideoDecodeH265DpbSlotInfoKHRBuilder {
            inner: VideoDecodeH265DpbSlotInfoKHR {
                s_type: StructureType::from_raw(1000187005i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> VideoDecodeH265DpbSlotInfoKHRBuilder<'a> {
    #[inline]
    pub fn std_reference_info(
        mut self,
        value: *const StdVideoDecodeH265ReferenceInfo,
    ) -> Self {
        self.inner.p_std_reference_info = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`VideoDecodeH265DpbSlotInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsVideoDecodeH265DpbSlotInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for VideoDecodeH265DpbSlotInfoKHRBuilder<'a> {
    type Target = VideoDecodeH265DpbSlotInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for VideoDecodeH265DpbSlotInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceVideoDecodeVP9FeaturesKHR`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceVideoDecodeVP9FeaturesKHRBuilder<'a> {
    inner: PhysicalDeviceVideoDecodeVP9FeaturesKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceVideoDecodeVP9FeaturesKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceVideoDecodeVP9FeaturesKHRBuilder<'a> {
        PhysicalDeviceVideoDecodeVP9FeaturesKHRBuilder {
            inner: PhysicalDeviceVideoDecodeVP9FeaturesKHR {
                s_type: StructureType::from_raw(1000514000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceVideoDecodeVP9FeaturesKHRBuilder<'a> {
    #[inline]
    pub fn video_decode_vp9(mut self, value: bool) -> Self {
        self.inner.video_decode_vp9 = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceVideoDecodeVP9FeaturesKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceVideoDecodeVP9FeaturesKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceVideoDecodeVP9FeaturesKHRBuilder<'a> {
    type Target = PhysicalDeviceVideoDecodeVP9FeaturesKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceVideoDecodeVP9FeaturesKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VideoDecodeVP9ProfileInfoKHR`] with lifetime-tied pNext safety.
pub struct VideoDecodeVP9ProfileInfoKHRBuilder<'a> {
    inner: VideoDecodeVP9ProfileInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl VideoDecodeVP9ProfileInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> VideoDecodeVP9ProfileInfoKHRBuilder<'a> {
        VideoDecodeVP9ProfileInfoKHRBuilder {
            inner: VideoDecodeVP9ProfileInfoKHR {
                s_type: StructureType::from_raw(1000514003i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> VideoDecodeVP9ProfileInfoKHRBuilder<'a> {
    #[inline]
    pub fn std_profile(mut self, value: StdVideoVP9Profile) -> Self {
        self.inner.std_profile = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`VideoDecodeVP9ProfileInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsVideoDecodeVP9ProfileInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for VideoDecodeVP9ProfileInfoKHRBuilder<'a> {
    type Target = VideoDecodeVP9ProfileInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for VideoDecodeVP9ProfileInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VideoDecodeVP9CapabilitiesKHR`] with lifetime-tied pNext safety.
pub struct VideoDecodeVP9CapabilitiesKHRBuilder<'a> {
    inner: VideoDecodeVP9CapabilitiesKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl VideoDecodeVP9CapabilitiesKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> VideoDecodeVP9CapabilitiesKHRBuilder<'a> {
        VideoDecodeVP9CapabilitiesKHRBuilder {
            inner: VideoDecodeVP9CapabilitiesKHR {
                s_type: StructureType::from_raw(1000514001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> VideoDecodeVP9CapabilitiesKHRBuilder<'a> {
    #[inline]
    pub fn max_level(mut self, value: StdVideoVP9Level) -> Self {
        self.inner.max_level = value;
        self
    }
}
impl<'a> core::ops::Deref for VideoDecodeVP9CapabilitiesKHRBuilder<'a> {
    type Target = VideoDecodeVP9CapabilitiesKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for VideoDecodeVP9CapabilitiesKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VideoDecodeVP9PictureInfoKHR`] with lifetime-tied pNext safety.
pub struct VideoDecodeVP9PictureInfoKHRBuilder<'a> {
    inner: VideoDecodeVP9PictureInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl VideoDecodeVP9PictureInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> VideoDecodeVP9PictureInfoKHRBuilder<'a> {
        VideoDecodeVP9PictureInfoKHRBuilder {
            inner: VideoDecodeVP9PictureInfoKHR {
                s_type: StructureType::from_raw(1000514002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> VideoDecodeVP9PictureInfoKHRBuilder<'a> {
    #[inline]
    pub fn std_picture_info(
        mut self,
        value: *const StdVideoDecodeVP9PictureInfo,
    ) -> Self {
        self.inner.p_std_picture_info = value;
        self
    }
    #[inline]
    pub fn reference_name_slot_indices(
        mut self,
        value: [i32; MAX_VIDEO_VP9_REFERENCES_PER_FRAME_KHR as usize],
    ) -> Self {
        self.inner.reference_name_slot_indices = value;
        self
    }
    #[inline]
    pub fn uncompressed_header_offset(mut self, value: u32) -> Self {
        self.inner.uncompressed_header_offset = value;
        self
    }
    #[inline]
    pub fn compressed_header_offset(mut self, value: u32) -> Self {
        self.inner.compressed_header_offset = value;
        self
    }
    #[inline]
    pub fn tiles_offset(mut self, value: u32) -> Self {
        self.inner.tiles_offset = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`VideoDecodeVP9PictureInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsVideoDecodeVP9PictureInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for VideoDecodeVP9PictureInfoKHRBuilder<'a> {
    type Target = VideoDecodeVP9PictureInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for VideoDecodeVP9PictureInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VideoDecodeAV1ProfileInfoKHR`] with lifetime-tied pNext safety.
pub struct VideoDecodeAV1ProfileInfoKHRBuilder<'a> {
    inner: VideoDecodeAV1ProfileInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl VideoDecodeAV1ProfileInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> VideoDecodeAV1ProfileInfoKHRBuilder<'a> {
        VideoDecodeAV1ProfileInfoKHRBuilder {
            inner: VideoDecodeAV1ProfileInfoKHR {
                s_type: StructureType::from_raw(1000512003i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> VideoDecodeAV1ProfileInfoKHRBuilder<'a> {
    #[inline]
    pub fn std_profile(mut self, value: StdVideoAV1Profile) -> Self {
        self.inner.std_profile = value;
        self
    }
    #[inline]
    pub fn film_grain_support(mut self, value: bool) -> Self {
        self.inner.film_grain_support = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`VideoDecodeAV1ProfileInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsVideoDecodeAV1ProfileInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for VideoDecodeAV1ProfileInfoKHRBuilder<'a> {
    type Target = VideoDecodeAV1ProfileInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for VideoDecodeAV1ProfileInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VideoDecodeAV1CapabilitiesKHR`] with lifetime-tied pNext safety.
pub struct VideoDecodeAV1CapabilitiesKHRBuilder<'a> {
    inner: VideoDecodeAV1CapabilitiesKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl VideoDecodeAV1CapabilitiesKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> VideoDecodeAV1CapabilitiesKHRBuilder<'a> {
        VideoDecodeAV1CapabilitiesKHRBuilder {
            inner: VideoDecodeAV1CapabilitiesKHR {
                s_type: StructureType::from_raw(1000512000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> VideoDecodeAV1CapabilitiesKHRBuilder<'a> {
    #[inline]
    pub fn max_level(mut self, value: StdVideoAV1Level) -> Self {
        self.inner.max_level = value;
        self
    }
}
impl<'a> core::ops::Deref for VideoDecodeAV1CapabilitiesKHRBuilder<'a> {
    type Target = VideoDecodeAV1CapabilitiesKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for VideoDecodeAV1CapabilitiesKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VideoDecodeAV1SessionParametersCreateInfoKHR`] with lifetime-tied pNext safety.
pub struct VideoDecodeAV1SessionParametersCreateInfoKHRBuilder<'a> {
    inner: VideoDecodeAV1SessionParametersCreateInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl VideoDecodeAV1SessionParametersCreateInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> VideoDecodeAV1SessionParametersCreateInfoKHRBuilder<'a> {
        VideoDecodeAV1SessionParametersCreateInfoKHRBuilder {
            inner: VideoDecodeAV1SessionParametersCreateInfoKHR {
                s_type: StructureType::from_raw(1000512004i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> VideoDecodeAV1SessionParametersCreateInfoKHRBuilder<'a> {
    #[inline]
    pub fn std_sequence_header(
        mut self,
        value: *const StdVideoAV1SequenceHeader,
    ) -> Self {
        self.inner.p_std_sequence_header = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`VideoDecodeAV1SessionParametersCreateInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsVideoDecodeAV1SessionParametersCreateInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for VideoDecodeAV1SessionParametersCreateInfoKHRBuilder<'a> {
    type Target = VideoDecodeAV1SessionParametersCreateInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for VideoDecodeAV1SessionParametersCreateInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VideoDecodeAV1InlineSessionParametersInfoKHR`] with lifetime-tied pNext safety.
pub struct VideoDecodeAV1InlineSessionParametersInfoKHRBuilder<'a> {
    inner: VideoDecodeAV1InlineSessionParametersInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl VideoDecodeAV1InlineSessionParametersInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> VideoDecodeAV1InlineSessionParametersInfoKHRBuilder<'a> {
        VideoDecodeAV1InlineSessionParametersInfoKHRBuilder {
            inner: VideoDecodeAV1InlineSessionParametersInfoKHR {
                s_type: StructureType::from_raw(1000586003i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> VideoDecodeAV1InlineSessionParametersInfoKHRBuilder<'a> {
    #[inline]
    pub fn std_sequence_header(
        mut self,
        value: *const StdVideoAV1SequenceHeader,
    ) -> Self {
        self.inner.p_std_sequence_header = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`VideoDecodeAV1InlineSessionParametersInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsVideoDecodeAV1InlineSessionParametersInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for VideoDecodeAV1InlineSessionParametersInfoKHRBuilder<'a> {
    type Target = VideoDecodeAV1InlineSessionParametersInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for VideoDecodeAV1InlineSessionParametersInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VideoDecodeAV1PictureInfoKHR`] with lifetime-tied pNext safety.
pub struct VideoDecodeAV1PictureInfoKHRBuilder<'a> {
    inner: VideoDecodeAV1PictureInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl VideoDecodeAV1PictureInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> VideoDecodeAV1PictureInfoKHRBuilder<'a> {
        VideoDecodeAV1PictureInfoKHRBuilder {
            inner: VideoDecodeAV1PictureInfoKHR {
                s_type: StructureType::from_raw(1000512001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> VideoDecodeAV1PictureInfoKHRBuilder<'a> {
    #[inline]
    pub fn std_picture_info(
        mut self,
        value: *const StdVideoDecodeAV1PictureInfo,
    ) -> Self {
        self.inner.p_std_picture_info = value;
        self
    }
    #[inline]
    pub fn reference_name_slot_indices(
        mut self,
        value: [i32; MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR as usize],
    ) -> Self {
        self.inner.reference_name_slot_indices = value;
        self
    }
    #[inline]
    pub fn frame_header_offset(mut self, value: u32) -> Self {
        self.inner.frame_header_offset = value;
        self
    }
    #[inline]
    pub fn tile_offsets(mut self, slice: &'a [u32]) -> Self {
        self.inner.tile_count = slice.len() as u32;
        self.inner.p_tile_offsets = slice.as_ptr();
        self
    }
    #[inline]
    pub fn tile_sizes(mut self, slice: &'a [u32]) -> Self {
        self.inner.tile_count = slice.len() as u32;
        self.inner.p_tile_sizes = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`VideoDecodeAV1PictureInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsVideoDecodeAV1PictureInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for VideoDecodeAV1PictureInfoKHRBuilder<'a> {
    type Target = VideoDecodeAV1PictureInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for VideoDecodeAV1PictureInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VideoDecodeAV1DpbSlotInfoKHR`] with lifetime-tied pNext safety.
pub struct VideoDecodeAV1DpbSlotInfoKHRBuilder<'a> {
    inner: VideoDecodeAV1DpbSlotInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl VideoDecodeAV1DpbSlotInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> VideoDecodeAV1DpbSlotInfoKHRBuilder<'a> {
        VideoDecodeAV1DpbSlotInfoKHRBuilder {
            inner: VideoDecodeAV1DpbSlotInfoKHR {
                s_type: StructureType::from_raw(1000512005i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> VideoDecodeAV1DpbSlotInfoKHRBuilder<'a> {
    #[inline]
    pub fn std_reference_info(
        mut self,
        value: *const StdVideoDecodeAV1ReferenceInfo,
    ) -> Self {
        self.inner.p_std_reference_info = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`VideoDecodeAV1DpbSlotInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsVideoDecodeAV1DpbSlotInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for VideoDecodeAV1DpbSlotInfoKHRBuilder<'a> {
    type Target = VideoDecodeAV1DpbSlotInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for VideoDecodeAV1DpbSlotInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VideoSessionCreateInfoKHR`] with lifetime-tied pNext safety.
pub struct VideoSessionCreateInfoKHRBuilder<'a> {
    inner: VideoSessionCreateInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl VideoSessionCreateInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> VideoSessionCreateInfoKHRBuilder<'a> {
        VideoSessionCreateInfoKHRBuilder {
            inner: VideoSessionCreateInfoKHR {
                s_type: StructureType::from_raw(1000023005i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> VideoSessionCreateInfoKHRBuilder<'a> {
    #[inline]
    pub fn queue_family_index(mut self, value: u32) -> Self {
        self.inner.queue_family_index = value;
        self
    }
    #[inline]
    pub fn flags(mut self, value: VideoSessionCreateFlagsKHR) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn video_profile(mut self, value: &'a VideoProfileInfoKHR) -> Self {
        self.inner.p_video_profile = value;
        self
    }
    #[inline]
    pub fn picture_format(mut self, value: Format) -> Self {
        self.inner.picture_format = value;
        self
    }
    #[inline]
    pub fn max_coded_extent(mut self, value: Extent2D) -> Self {
        self.inner.max_coded_extent = value;
        self
    }
    #[inline]
    pub fn reference_picture_format(mut self, value: Format) -> Self {
        self.inner.reference_picture_format = value;
        self
    }
    #[inline]
    pub fn max_dpb_slots(mut self, value: u32) -> Self {
        self.inner.max_dpb_slots = value;
        self
    }
    #[inline]
    pub fn max_active_reference_pictures(mut self, value: u32) -> Self {
        self.inner.max_active_reference_pictures = value;
        self
    }
    #[inline]
    pub fn std_header_version(mut self, value: &'a ExtensionProperties) -> Self {
        self.inner.p_std_header_version = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`VideoSessionCreateInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsVideoSessionCreateInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for VideoSessionCreateInfoKHRBuilder<'a> {
    type Target = VideoSessionCreateInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for VideoSessionCreateInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VideoSessionParametersCreateInfoKHR`] with lifetime-tied pNext safety.
pub struct VideoSessionParametersCreateInfoKHRBuilder<'a> {
    inner: VideoSessionParametersCreateInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl VideoSessionParametersCreateInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> VideoSessionParametersCreateInfoKHRBuilder<'a> {
        VideoSessionParametersCreateInfoKHRBuilder {
            inner: VideoSessionParametersCreateInfoKHR {
                s_type: StructureType::from_raw(1000023006i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> VideoSessionParametersCreateInfoKHRBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: VideoSessionParametersCreateFlagsKHR) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn video_session_parameters_template(
        mut self,
        value: VideoSessionParametersKHR,
    ) -> Self {
        self.inner.video_session_parameters_template = value;
        self
    }
    #[inline]
    pub fn video_session(mut self, value: VideoSessionKHR) -> Self {
        self.inner.video_session = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`VideoSessionParametersCreateInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsVideoSessionParametersCreateInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for VideoSessionParametersCreateInfoKHRBuilder<'a> {
    type Target = VideoSessionParametersCreateInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for VideoSessionParametersCreateInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VideoSessionParametersUpdateInfoKHR`] with lifetime-tied pNext safety.
pub struct VideoSessionParametersUpdateInfoKHRBuilder<'a> {
    inner: VideoSessionParametersUpdateInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl VideoSessionParametersUpdateInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> VideoSessionParametersUpdateInfoKHRBuilder<'a> {
        VideoSessionParametersUpdateInfoKHRBuilder {
            inner: VideoSessionParametersUpdateInfoKHR {
                s_type: StructureType::from_raw(1000023007i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> VideoSessionParametersUpdateInfoKHRBuilder<'a> {
    #[inline]
    pub fn update_sequence_count(mut self, value: u32) -> Self {
        self.inner.update_sequence_count = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`VideoSessionParametersUpdateInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsVideoSessionParametersUpdateInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for VideoSessionParametersUpdateInfoKHRBuilder<'a> {
    type Target = VideoSessionParametersUpdateInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for VideoSessionParametersUpdateInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VideoEncodeSessionParametersGetInfoKHR`] with lifetime-tied pNext safety.
pub struct VideoEncodeSessionParametersGetInfoKHRBuilder<'a> {
    inner: VideoEncodeSessionParametersGetInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl VideoEncodeSessionParametersGetInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> VideoEncodeSessionParametersGetInfoKHRBuilder<'a> {
        VideoEncodeSessionParametersGetInfoKHRBuilder {
            inner: VideoEncodeSessionParametersGetInfoKHR {
                s_type: StructureType::from_raw(1000299009i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> VideoEncodeSessionParametersGetInfoKHRBuilder<'a> {
    #[inline]
    pub fn video_session_parameters(mut self, value: VideoSessionParametersKHR) -> Self {
        self.inner.video_session_parameters = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`VideoEncodeSessionParametersGetInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsVideoEncodeSessionParametersGetInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for VideoEncodeSessionParametersGetInfoKHRBuilder<'a> {
    type Target = VideoEncodeSessionParametersGetInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for VideoEncodeSessionParametersGetInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VideoEncodeSessionParametersFeedbackInfoKHR`] with lifetime-tied pNext safety.
pub struct VideoEncodeSessionParametersFeedbackInfoKHRBuilder<'a> {
    inner: VideoEncodeSessionParametersFeedbackInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl VideoEncodeSessionParametersFeedbackInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> VideoEncodeSessionParametersFeedbackInfoKHRBuilder<'a> {
        VideoEncodeSessionParametersFeedbackInfoKHRBuilder {
            inner: VideoEncodeSessionParametersFeedbackInfoKHR {
                s_type: StructureType::from_raw(1000299010i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> VideoEncodeSessionParametersFeedbackInfoKHRBuilder<'a> {
    #[inline]
    pub fn has_overrides(mut self, value: bool) -> Self {
        self.inner.has_overrides = value as u32;
        self
    }
}
impl<'a> core::ops::Deref for VideoEncodeSessionParametersFeedbackInfoKHRBuilder<'a> {
    type Target = VideoEncodeSessionParametersFeedbackInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for VideoEncodeSessionParametersFeedbackInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VideoBeginCodingInfoKHR`] with lifetime-tied pNext safety.
pub struct VideoBeginCodingInfoKHRBuilder<'a> {
    inner: VideoBeginCodingInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl VideoBeginCodingInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> VideoBeginCodingInfoKHRBuilder<'a> {
        VideoBeginCodingInfoKHRBuilder {
            inner: VideoBeginCodingInfoKHR {
                s_type: StructureType::from_raw(1000023008i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> VideoBeginCodingInfoKHRBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: VideoBeginCodingFlagsKHR) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn video_session(mut self, value: VideoSessionKHR) -> Self {
        self.inner.video_session = value;
        self
    }
    #[inline]
    pub fn video_session_parameters(mut self, value: VideoSessionParametersKHR) -> Self {
        self.inner.video_session_parameters = value;
        self
    }
    #[inline]
    pub fn reference_slots(mut self, slice: &'a [VideoReferenceSlotInfoKHR]) -> Self {
        self.inner.reference_slot_count = slice.len() as u32;
        self.inner.p_reference_slots = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`VideoBeginCodingInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsVideoBeginCodingInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for VideoBeginCodingInfoKHRBuilder<'a> {
    type Target = VideoBeginCodingInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for VideoBeginCodingInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VideoEndCodingInfoKHR`] with lifetime-tied pNext safety.
pub struct VideoEndCodingInfoKHRBuilder<'a> {
    inner: VideoEndCodingInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl VideoEndCodingInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> VideoEndCodingInfoKHRBuilder<'a> {
        VideoEndCodingInfoKHRBuilder {
            inner: VideoEndCodingInfoKHR {
                s_type: StructureType::from_raw(1000023009i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> VideoEndCodingInfoKHRBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: VideoEndCodingFlagsKHR) -> Self {
        self.inner.flags = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`VideoEndCodingInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsVideoEndCodingInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for VideoEndCodingInfoKHRBuilder<'a> {
    type Target = VideoEndCodingInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for VideoEndCodingInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VideoCodingControlInfoKHR`] with lifetime-tied pNext safety.
pub struct VideoCodingControlInfoKHRBuilder<'a> {
    inner: VideoCodingControlInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl VideoCodingControlInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> VideoCodingControlInfoKHRBuilder<'a> {
        VideoCodingControlInfoKHRBuilder {
            inner: VideoCodingControlInfoKHR {
                s_type: StructureType::from_raw(1000023010i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> VideoCodingControlInfoKHRBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: VideoCodingControlFlagsKHR) -> Self {
        self.inner.flags = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`VideoCodingControlInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsVideoCodingControlInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for VideoCodingControlInfoKHRBuilder<'a> {
    type Target = VideoCodingControlInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for VideoCodingControlInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VideoEncodeUsageInfoKHR`] with lifetime-tied pNext safety.
pub struct VideoEncodeUsageInfoKHRBuilder<'a> {
    inner: VideoEncodeUsageInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl VideoEncodeUsageInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> VideoEncodeUsageInfoKHRBuilder<'a> {
        VideoEncodeUsageInfoKHRBuilder {
            inner: VideoEncodeUsageInfoKHR {
                s_type: StructureType::from_raw(1000299004i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> VideoEncodeUsageInfoKHRBuilder<'a> {
    #[inline]
    pub fn video_usage_hints(mut self, value: VideoEncodeUsageFlagsKHR) -> Self {
        self.inner.video_usage_hints = value;
        self
    }
    #[inline]
    pub fn video_content_hints(mut self, value: VideoEncodeContentFlagsKHR) -> Self {
        self.inner.video_content_hints = value;
        self
    }
    #[inline]
    pub fn tuning_mode(mut self, value: VideoEncodeTuningModeKHR) -> Self {
        self.inner.tuning_mode = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`VideoEncodeUsageInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsVideoEncodeUsageInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for VideoEncodeUsageInfoKHRBuilder<'a> {
    type Target = VideoEncodeUsageInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for VideoEncodeUsageInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VideoEncodeInfoKHR`] with lifetime-tied pNext safety.
pub struct VideoEncodeInfoKHRBuilder<'a> {
    inner: VideoEncodeInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl VideoEncodeInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> VideoEncodeInfoKHRBuilder<'a> {
        VideoEncodeInfoKHRBuilder {
            inner: VideoEncodeInfoKHR {
                s_type: StructureType::from_raw(1000299000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> VideoEncodeInfoKHRBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: VideoEncodeFlagsKHR) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn dst_buffer(mut self, value: Buffer) -> Self {
        self.inner.dst_buffer = value;
        self
    }
    #[inline]
    pub fn dst_buffer_offset(mut self, value: u64) -> Self {
        self.inner.dst_buffer_offset = value;
        self
    }
    #[inline]
    pub fn dst_buffer_range(mut self, value: u64) -> Self {
        self.inner.dst_buffer_range = value;
        self
    }
    #[inline]
    pub fn src_picture_resource(mut self, value: VideoPictureResourceInfoKHR) -> Self {
        self.inner.src_picture_resource = value;
        self
    }
    #[inline]
    pub fn setup_reference_slot(mut self, value: &'a VideoReferenceSlotInfoKHR) -> Self {
        self.inner.p_setup_reference_slot = value;
        self
    }
    #[inline]
    pub fn reference_slots(mut self, slice: &'a [VideoReferenceSlotInfoKHR]) -> Self {
        self.inner.reference_slot_count = slice.len() as u32;
        self.inner.p_reference_slots = slice.as_ptr();
        self
    }
    #[inline]
    pub fn preceding_externally_encoded_bytes(mut self, value: u32) -> Self {
        self.inner.preceding_externally_encoded_bytes = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`VideoEncodeInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsVideoEncodeInfoKHR>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for VideoEncodeInfoKHRBuilder<'a> {
    type Target = VideoEncodeInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for VideoEncodeInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VideoEncodeQuantizationMapInfoKHR`] with lifetime-tied pNext safety.
pub struct VideoEncodeQuantizationMapInfoKHRBuilder<'a> {
    inner: VideoEncodeQuantizationMapInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl VideoEncodeQuantizationMapInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> VideoEncodeQuantizationMapInfoKHRBuilder<'a> {
        VideoEncodeQuantizationMapInfoKHRBuilder {
            inner: VideoEncodeQuantizationMapInfoKHR {
                s_type: StructureType::from_raw(1000553002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> VideoEncodeQuantizationMapInfoKHRBuilder<'a> {
    #[inline]
    pub fn quantization_map(mut self, value: ImageView) -> Self {
        self.inner.quantization_map = value;
        self
    }
    #[inline]
    pub fn quantization_map_extent(mut self, value: Extent2D) -> Self {
        self.inner.quantization_map_extent = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`VideoEncodeQuantizationMapInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsVideoEncodeQuantizationMapInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for VideoEncodeQuantizationMapInfoKHRBuilder<'a> {
    type Target = VideoEncodeQuantizationMapInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for VideoEncodeQuantizationMapInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VideoEncodeQuantizationMapSessionParametersCreateInfoKHR`] with lifetime-tied pNext safety.
pub struct VideoEncodeQuantizationMapSessionParametersCreateInfoKHRBuilder<'a> {
    inner: VideoEncodeQuantizationMapSessionParametersCreateInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl VideoEncodeQuantizationMapSessionParametersCreateInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> VideoEncodeQuantizationMapSessionParametersCreateInfoKHRBuilder<
        'a,
    > {
        VideoEncodeQuantizationMapSessionParametersCreateInfoKHRBuilder {
            inner: VideoEncodeQuantizationMapSessionParametersCreateInfoKHR {
                s_type: StructureType::from_raw(1000553005i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> VideoEncodeQuantizationMapSessionParametersCreateInfoKHRBuilder<'a> {
    #[inline]
    pub fn quantization_map_texel_size(mut self, value: Extent2D) -> Self {
        self.inner.quantization_map_texel_size = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`VideoEncodeQuantizationMapSessionParametersCreateInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsVideoEncodeQuantizationMapSessionParametersCreateInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref
for VideoEncodeQuantizationMapSessionParametersCreateInfoKHRBuilder<'a> {
    type Target = VideoEncodeQuantizationMapSessionParametersCreateInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for VideoEncodeQuantizationMapSessionParametersCreateInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceVideoEncodeQuantizationMapFeaturesKHRBuilder<'a> {
    inner: PhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceVideoEncodeQuantizationMapFeaturesKHRBuilder<
        'a,
    > {
        PhysicalDeviceVideoEncodeQuantizationMapFeaturesKHRBuilder {
            inner: PhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR {
                s_type: StructureType::from_raw(1000553009i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceVideoEncodeQuantizationMapFeaturesKHRBuilder<'a> {
    #[inline]
    pub fn video_encode_quantization_map(mut self, value: bool) -> Self {
        self.inner.video_encode_quantization_map = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDeviceVideoEncodeQuantizationMapFeaturesKHRBuilder<'a> {
    type Target = PhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceVideoEncodeQuantizationMapFeaturesKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`QueryPoolVideoEncodeFeedbackCreateInfoKHR`] with lifetime-tied pNext safety.
pub struct QueryPoolVideoEncodeFeedbackCreateInfoKHRBuilder<'a> {
    inner: QueryPoolVideoEncodeFeedbackCreateInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl QueryPoolVideoEncodeFeedbackCreateInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> QueryPoolVideoEncodeFeedbackCreateInfoKHRBuilder<'a> {
        QueryPoolVideoEncodeFeedbackCreateInfoKHRBuilder {
            inner: QueryPoolVideoEncodeFeedbackCreateInfoKHR {
                s_type: StructureType::from_raw(1000299005i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> QueryPoolVideoEncodeFeedbackCreateInfoKHRBuilder<'a> {
    #[inline]
    pub fn encode_feedback_flags(mut self, value: VideoEncodeFeedbackFlagsKHR) -> Self {
        self.inner.encode_feedback_flags = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`QueryPoolVideoEncodeFeedbackCreateInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsQueryPoolVideoEncodeFeedbackCreateInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for QueryPoolVideoEncodeFeedbackCreateInfoKHRBuilder<'a> {
    type Target = QueryPoolVideoEncodeFeedbackCreateInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for QueryPoolVideoEncodeFeedbackCreateInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VideoEncodeQualityLevelInfoKHR`] with lifetime-tied pNext safety.
pub struct VideoEncodeQualityLevelInfoKHRBuilder<'a> {
    inner: VideoEncodeQualityLevelInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl VideoEncodeQualityLevelInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> VideoEncodeQualityLevelInfoKHRBuilder<'a> {
        VideoEncodeQualityLevelInfoKHRBuilder {
            inner: VideoEncodeQualityLevelInfoKHR {
                s_type: StructureType::from_raw(1000299008i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> VideoEncodeQualityLevelInfoKHRBuilder<'a> {
    #[inline]
    pub fn quality_level(mut self, value: u32) -> Self {
        self.inner.quality_level = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`VideoEncodeQualityLevelInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsVideoEncodeQualityLevelInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for VideoEncodeQualityLevelInfoKHRBuilder<'a> {
    type Target = VideoEncodeQualityLevelInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for VideoEncodeQualityLevelInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceVideoEncodeQualityLevelInfoKHR`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceVideoEncodeQualityLevelInfoKHRBuilder<'a> {
    inner: PhysicalDeviceVideoEncodeQualityLevelInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceVideoEncodeQualityLevelInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceVideoEncodeQualityLevelInfoKHRBuilder<'a> {
        PhysicalDeviceVideoEncodeQualityLevelInfoKHRBuilder {
            inner: PhysicalDeviceVideoEncodeQualityLevelInfoKHR {
                s_type: StructureType::from_raw(1000299006i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceVideoEncodeQualityLevelInfoKHRBuilder<'a> {
    #[inline]
    pub fn video_profile(mut self, value: &'a VideoProfileInfoKHR) -> Self {
        self.inner.p_video_profile = value;
        self
    }
    #[inline]
    pub fn quality_level(mut self, value: u32) -> Self {
        self.inner.quality_level = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceVideoEncodeQualityLevelInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceVideoEncodeQualityLevelInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceVideoEncodeQualityLevelInfoKHRBuilder<'a> {
    type Target = PhysicalDeviceVideoEncodeQualityLevelInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceVideoEncodeQualityLevelInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VideoEncodeQualityLevelPropertiesKHR`] with lifetime-tied pNext safety.
pub struct VideoEncodeQualityLevelPropertiesKHRBuilder<'a> {
    inner: VideoEncodeQualityLevelPropertiesKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl VideoEncodeQualityLevelPropertiesKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> VideoEncodeQualityLevelPropertiesKHRBuilder<'a> {
        VideoEncodeQualityLevelPropertiesKHRBuilder {
            inner: VideoEncodeQualityLevelPropertiesKHR {
                s_type: StructureType::from_raw(1000299007i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> VideoEncodeQualityLevelPropertiesKHRBuilder<'a> {
    #[inline]
    pub fn preferred_rate_control_mode(
        mut self,
        value: VideoEncodeRateControlModeFlagBitsKHR,
    ) -> Self {
        self.inner.preferred_rate_control_mode = value;
        self
    }
    #[inline]
    pub fn preferred_rate_control_layer_count(mut self, value: u32) -> Self {
        self.inner.preferred_rate_control_layer_count = value;
        self
    }
}
impl<'a> core::ops::Deref for VideoEncodeQualityLevelPropertiesKHRBuilder<'a> {
    type Target = VideoEncodeQualityLevelPropertiesKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for VideoEncodeQualityLevelPropertiesKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VideoEncodeRateControlInfoKHR`] with lifetime-tied pNext safety.
pub struct VideoEncodeRateControlInfoKHRBuilder<'a> {
    inner: VideoEncodeRateControlInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl VideoEncodeRateControlInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> VideoEncodeRateControlInfoKHRBuilder<'a> {
        VideoEncodeRateControlInfoKHRBuilder {
            inner: VideoEncodeRateControlInfoKHR {
                s_type: StructureType::from_raw(1000299001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> VideoEncodeRateControlInfoKHRBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: VideoEncodeRateControlFlagsKHR) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn rate_control_mode(
        mut self,
        value: VideoEncodeRateControlModeFlagBitsKHR,
    ) -> Self {
        self.inner.rate_control_mode = value;
        self
    }
    #[inline]
    pub fn layers(mut self, slice: &'a [VideoEncodeRateControlLayerInfoKHR]) -> Self {
        self.inner.layer_count = slice.len() as u32;
        self.inner.p_layers = slice.as_ptr();
        self
    }
    #[inline]
    pub fn virtual_buffer_size_in_ms(mut self, value: u32) -> Self {
        self.inner.virtual_buffer_size_in_ms = value;
        self
    }
    #[inline]
    pub fn initial_virtual_buffer_size_in_ms(mut self, value: u32) -> Self {
        self.inner.initial_virtual_buffer_size_in_ms = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`VideoEncodeRateControlInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsVideoEncodeRateControlInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for VideoEncodeRateControlInfoKHRBuilder<'a> {
    type Target = VideoEncodeRateControlInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for VideoEncodeRateControlInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VideoEncodeRateControlLayerInfoKHR`] with lifetime-tied pNext safety.
pub struct VideoEncodeRateControlLayerInfoKHRBuilder<'a> {
    inner: VideoEncodeRateControlLayerInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl VideoEncodeRateControlLayerInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> VideoEncodeRateControlLayerInfoKHRBuilder<'a> {
        VideoEncodeRateControlLayerInfoKHRBuilder {
            inner: VideoEncodeRateControlLayerInfoKHR {
                s_type: StructureType::from_raw(1000299002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> VideoEncodeRateControlLayerInfoKHRBuilder<'a> {
    #[inline]
    pub fn average_bitrate(mut self, value: u64) -> Self {
        self.inner.average_bitrate = value;
        self
    }
    #[inline]
    pub fn max_bitrate(mut self, value: u64) -> Self {
        self.inner.max_bitrate = value;
        self
    }
    #[inline]
    pub fn frame_rate_numerator(mut self, value: u32) -> Self {
        self.inner.frame_rate_numerator = value;
        self
    }
    #[inline]
    pub fn frame_rate_denominator(mut self, value: u32) -> Self {
        self.inner.frame_rate_denominator = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`VideoEncodeRateControlLayerInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsVideoEncodeRateControlLayerInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for VideoEncodeRateControlLayerInfoKHRBuilder<'a> {
    type Target = VideoEncodeRateControlLayerInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for VideoEncodeRateControlLayerInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VideoEncodeCapabilitiesKHR`] with lifetime-tied pNext safety.
pub struct VideoEncodeCapabilitiesKHRBuilder<'a> {
    inner: VideoEncodeCapabilitiesKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl VideoEncodeCapabilitiesKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> VideoEncodeCapabilitiesKHRBuilder<'a> {
        VideoEncodeCapabilitiesKHRBuilder {
            inner: VideoEncodeCapabilitiesKHR {
                s_type: StructureType::from_raw(1000299003i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> VideoEncodeCapabilitiesKHRBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: VideoEncodeCapabilityFlagsKHR) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn rate_control_modes(
        mut self,
        value: VideoEncodeRateControlModeFlagsKHR,
    ) -> Self {
        self.inner.rate_control_modes = value;
        self
    }
    #[inline]
    pub fn max_rate_control_layers(mut self, value: u32) -> Self {
        self.inner.max_rate_control_layers = value;
        self
    }
    #[inline]
    pub fn max_bitrate(mut self, value: u64) -> Self {
        self.inner.max_bitrate = value;
        self
    }
    #[inline]
    pub fn max_quality_levels(mut self, value: u32) -> Self {
        self.inner.max_quality_levels = value;
        self
    }
    #[inline]
    pub fn encode_input_picture_granularity(mut self, value: Extent2D) -> Self {
        self.inner.encode_input_picture_granularity = value;
        self
    }
    #[inline]
    pub fn supported_encode_feedback_flags(
        mut self,
        value: VideoEncodeFeedbackFlagsKHR,
    ) -> Self {
        self.inner.supported_encode_feedback_flags = value;
        self
    }
}
impl<'a> core::ops::Deref for VideoEncodeCapabilitiesKHRBuilder<'a> {
    type Target = VideoEncodeCapabilitiesKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for VideoEncodeCapabilitiesKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VideoEncodeH264CapabilitiesKHR`] with lifetime-tied pNext safety.
pub struct VideoEncodeH264CapabilitiesKHRBuilder<'a> {
    inner: VideoEncodeH264CapabilitiesKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl VideoEncodeH264CapabilitiesKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> VideoEncodeH264CapabilitiesKHRBuilder<'a> {
        VideoEncodeH264CapabilitiesKHRBuilder {
            inner: VideoEncodeH264CapabilitiesKHR {
                s_type: StructureType::from_raw(1000038000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> VideoEncodeH264CapabilitiesKHRBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: VideoEncodeH264CapabilityFlagsKHR) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn max_level_idc(mut self, value: StdVideoH264LevelIdc) -> Self {
        self.inner.max_level_idc = value;
        self
    }
    #[inline]
    pub fn max_slice_count(mut self, value: u32) -> Self {
        self.inner.max_slice_count = value;
        self
    }
    #[inline]
    pub fn max_p_picture_l0_reference_count(mut self, value: u32) -> Self {
        self.inner.max_p_picture_l0_reference_count = value;
        self
    }
    #[inline]
    pub fn max_b_picture_l0_reference_count(mut self, value: u32) -> Self {
        self.inner.max_b_picture_l0_reference_count = value;
        self
    }
    #[inline]
    pub fn max_l1_reference_count(mut self, value: u32) -> Self {
        self.inner.max_l1_reference_count = value;
        self
    }
    #[inline]
    pub fn max_temporal_layer_count(mut self, value: u32) -> Self {
        self.inner.max_temporal_layer_count = value;
        self
    }
    #[inline]
    pub fn expect_dyadic_temporal_layer_pattern(mut self, value: bool) -> Self {
        self.inner.expect_dyadic_temporal_layer_pattern = value as u32;
        self
    }
    #[inline]
    pub fn min_qp(mut self, value: i32) -> Self {
        self.inner.min_qp = value;
        self
    }
    #[inline]
    pub fn max_qp(mut self, value: i32) -> Self {
        self.inner.max_qp = value;
        self
    }
    #[inline]
    pub fn prefers_gop_remaining_frames(mut self, value: bool) -> Self {
        self.inner.prefers_gop_remaining_frames = value as u32;
        self
    }
    #[inline]
    pub fn requires_gop_remaining_frames(mut self, value: bool) -> Self {
        self.inner.requires_gop_remaining_frames = value as u32;
        self
    }
    #[inline]
    pub fn std_syntax_flags(mut self, value: VideoEncodeH264StdFlagsKHR) -> Self {
        self.inner.std_syntax_flags = value;
        self
    }
}
impl<'a> core::ops::Deref for VideoEncodeH264CapabilitiesKHRBuilder<'a> {
    type Target = VideoEncodeH264CapabilitiesKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for VideoEncodeH264CapabilitiesKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VideoEncodeH264QualityLevelPropertiesKHR`] with lifetime-tied pNext safety.
pub struct VideoEncodeH264QualityLevelPropertiesKHRBuilder<'a> {
    inner: VideoEncodeH264QualityLevelPropertiesKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl VideoEncodeH264QualityLevelPropertiesKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> VideoEncodeH264QualityLevelPropertiesKHRBuilder<'a> {
        VideoEncodeH264QualityLevelPropertiesKHRBuilder {
            inner: VideoEncodeH264QualityLevelPropertiesKHR {
                s_type: StructureType::from_raw(1000038011i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> VideoEncodeH264QualityLevelPropertiesKHRBuilder<'a> {
    #[inline]
    pub fn preferred_rate_control_flags(
        mut self,
        value: VideoEncodeH264RateControlFlagsKHR,
    ) -> Self {
        self.inner.preferred_rate_control_flags = value;
        self
    }
    #[inline]
    pub fn preferred_gop_frame_count(mut self, value: u32) -> Self {
        self.inner.preferred_gop_frame_count = value;
        self
    }
    #[inline]
    pub fn preferred_idr_period(mut self, value: u32) -> Self {
        self.inner.preferred_idr_period = value;
        self
    }
    #[inline]
    pub fn preferred_consecutive_b_frame_count(mut self, value: u32) -> Self {
        self.inner.preferred_consecutive_b_frame_count = value;
        self
    }
    #[inline]
    pub fn preferred_temporal_layer_count(mut self, value: u32) -> Self {
        self.inner.preferred_temporal_layer_count = value;
        self
    }
    #[inline]
    pub fn preferred_constant_qp(mut self, value: VideoEncodeH264QpKHR) -> Self {
        self.inner.preferred_constant_qp = value;
        self
    }
    #[inline]
    pub fn preferred_max_l0_reference_count(mut self, value: u32) -> Self {
        self.inner.preferred_max_l0_reference_count = value;
        self
    }
    #[inline]
    pub fn preferred_max_l1_reference_count(mut self, value: u32) -> Self {
        self.inner.preferred_max_l1_reference_count = value;
        self
    }
    #[inline]
    pub fn preferred_std_entropy_coding_mode_flag(mut self, value: bool) -> Self {
        self.inner.preferred_std_entropy_coding_mode_flag = value as u32;
        self
    }
}
impl<'a> core::ops::Deref for VideoEncodeH264QualityLevelPropertiesKHRBuilder<'a> {
    type Target = VideoEncodeH264QualityLevelPropertiesKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for VideoEncodeH264QualityLevelPropertiesKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VideoEncodeH264SessionCreateInfoKHR`] with lifetime-tied pNext safety.
pub struct VideoEncodeH264SessionCreateInfoKHRBuilder<'a> {
    inner: VideoEncodeH264SessionCreateInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl VideoEncodeH264SessionCreateInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> VideoEncodeH264SessionCreateInfoKHRBuilder<'a> {
        VideoEncodeH264SessionCreateInfoKHRBuilder {
            inner: VideoEncodeH264SessionCreateInfoKHR {
                s_type: StructureType::from_raw(1000038010i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> VideoEncodeH264SessionCreateInfoKHRBuilder<'a> {
    #[inline]
    pub fn use_max_level_idc(mut self, value: bool) -> Self {
        self.inner.use_max_level_idc = value as u32;
        self
    }
    #[inline]
    pub fn max_level_idc(mut self, value: StdVideoH264LevelIdc) -> Self {
        self.inner.max_level_idc = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`VideoEncodeH264SessionCreateInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsVideoEncodeH264SessionCreateInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for VideoEncodeH264SessionCreateInfoKHRBuilder<'a> {
    type Target = VideoEncodeH264SessionCreateInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for VideoEncodeH264SessionCreateInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VideoEncodeH264SessionParametersAddInfoKHR`] with lifetime-tied pNext safety.
pub struct VideoEncodeH264SessionParametersAddInfoKHRBuilder<'a> {
    inner: VideoEncodeH264SessionParametersAddInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl VideoEncodeH264SessionParametersAddInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> VideoEncodeH264SessionParametersAddInfoKHRBuilder<'a> {
        VideoEncodeH264SessionParametersAddInfoKHRBuilder {
            inner: VideoEncodeH264SessionParametersAddInfoKHR {
                s_type: StructureType::from_raw(1000038002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> VideoEncodeH264SessionParametersAddInfoKHRBuilder<'a> {
    #[inline]
    pub fn std_sps_count(mut self, value: u32) -> Self {
        self.inner.std_sps_count = value;
        self
    }
    #[inline]
    pub fn std_sp_ss(mut self, slice: &'a [StdVideoH264SequenceParameterSet]) -> Self {
        self.inner.std_sps_count = slice.len() as u32;
        self.inner.p_std_sp_ss = slice.as_ptr();
        self
    }
    #[inline]
    pub fn std_pps_count(mut self, value: u32) -> Self {
        self.inner.std_pps_count = value;
        self
    }
    #[inline]
    pub fn std_pp_ss(mut self, slice: &'a [StdVideoH264PictureParameterSet]) -> Self {
        self.inner.std_pps_count = slice.len() as u32;
        self.inner.p_std_pp_ss = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`VideoEncodeH264SessionParametersAddInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsVideoEncodeH264SessionParametersAddInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for VideoEncodeH264SessionParametersAddInfoKHRBuilder<'a> {
    type Target = VideoEncodeH264SessionParametersAddInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for VideoEncodeH264SessionParametersAddInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VideoEncodeH264SessionParametersCreateInfoKHR`] with lifetime-tied pNext safety.
pub struct VideoEncodeH264SessionParametersCreateInfoKHRBuilder<'a> {
    inner: VideoEncodeH264SessionParametersCreateInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl VideoEncodeH264SessionParametersCreateInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> VideoEncodeH264SessionParametersCreateInfoKHRBuilder<'a> {
        VideoEncodeH264SessionParametersCreateInfoKHRBuilder {
            inner: VideoEncodeH264SessionParametersCreateInfoKHR {
                s_type: StructureType::from_raw(1000038001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> VideoEncodeH264SessionParametersCreateInfoKHRBuilder<'a> {
    #[inline]
    pub fn max_std_sps_count(mut self, value: u32) -> Self {
        self.inner.max_std_sps_count = value;
        self
    }
    #[inline]
    pub fn max_std_pps_count(mut self, value: u32) -> Self {
        self.inner.max_std_pps_count = value;
        self
    }
    #[inline]
    pub fn parameters_add_info(
        mut self,
        value: &'a VideoEncodeH264SessionParametersAddInfoKHR,
    ) -> Self {
        self.inner.p_parameters_add_info = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`VideoEncodeH264SessionParametersCreateInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsVideoEncodeH264SessionParametersCreateInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for VideoEncodeH264SessionParametersCreateInfoKHRBuilder<'a> {
    type Target = VideoEncodeH264SessionParametersCreateInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for VideoEncodeH264SessionParametersCreateInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VideoEncodeH264SessionParametersGetInfoKHR`] with lifetime-tied pNext safety.
pub struct VideoEncodeH264SessionParametersGetInfoKHRBuilder<'a> {
    inner: VideoEncodeH264SessionParametersGetInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl VideoEncodeH264SessionParametersGetInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> VideoEncodeH264SessionParametersGetInfoKHRBuilder<'a> {
        VideoEncodeH264SessionParametersGetInfoKHRBuilder {
            inner: VideoEncodeH264SessionParametersGetInfoKHR {
                s_type: StructureType::from_raw(1000038012i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> VideoEncodeH264SessionParametersGetInfoKHRBuilder<'a> {
    #[inline]
    pub fn write_std_sps(mut self, value: bool) -> Self {
        self.inner.write_std_sps = value as u32;
        self
    }
    #[inline]
    pub fn write_std_pps(mut self, value: bool) -> Self {
        self.inner.write_std_pps = value as u32;
        self
    }
    #[inline]
    pub fn std_sps_id(mut self, value: u32) -> Self {
        self.inner.std_sps_id = value;
        self
    }
    #[inline]
    pub fn std_pps_id(mut self, value: u32) -> Self {
        self.inner.std_pps_id = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`VideoEncodeH264SessionParametersGetInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsVideoEncodeH264SessionParametersGetInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for VideoEncodeH264SessionParametersGetInfoKHRBuilder<'a> {
    type Target = VideoEncodeH264SessionParametersGetInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for VideoEncodeH264SessionParametersGetInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VideoEncodeH264SessionParametersFeedbackInfoKHR`] with lifetime-tied pNext safety.
pub struct VideoEncodeH264SessionParametersFeedbackInfoKHRBuilder<'a> {
    inner: VideoEncodeH264SessionParametersFeedbackInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl VideoEncodeH264SessionParametersFeedbackInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> VideoEncodeH264SessionParametersFeedbackInfoKHRBuilder<'a> {
        VideoEncodeH264SessionParametersFeedbackInfoKHRBuilder {
            inner: VideoEncodeH264SessionParametersFeedbackInfoKHR {
                s_type: StructureType::from_raw(1000038013i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> VideoEncodeH264SessionParametersFeedbackInfoKHRBuilder<'a> {
    #[inline]
    pub fn has_std_sps_overrides(mut self, value: bool) -> Self {
        self.inner.has_std_sps_overrides = value as u32;
        self
    }
    #[inline]
    pub fn has_std_pps_overrides(mut self, value: bool) -> Self {
        self.inner.has_std_pps_overrides = value as u32;
        self
    }
}
impl<'a> core::ops::Deref
for VideoEncodeH264SessionParametersFeedbackInfoKHRBuilder<'a> {
    type Target = VideoEncodeH264SessionParametersFeedbackInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for VideoEncodeH264SessionParametersFeedbackInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VideoEncodeH264DpbSlotInfoKHR`] with lifetime-tied pNext safety.
pub struct VideoEncodeH264DpbSlotInfoKHRBuilder<'a> {
    inner: VideoEncodeH264DpbSlotInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl VideoEncodeH264DpbSlotInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> VideoEncodeH264DpbSlotInfoKHRBuilder<'a> {
        VideoEncodeH264DpbSlotInfoKHRBuilder {
            inner: VideoEncodeH264DpbSlotInfoKHR {
                s_type: StructureType::from_raw(1000038004i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> VideoEncodeH264DpbSlotInfoKHRBuilder<'a> {
    #[inline]
    pub fn std_reference_info(
        mut self,
        value: *const StdVideoEncodeH264ReferenceInfo,
    ) -> Self {
        self.inner.p_std_reference_info = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`VideoEncodeH264DpbSlotInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsVideoEncodeH264DpbSlotInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for VideoEncodeH264DpbSlotInfoKHRBuilder<'a> {
    type Target = VideoEncodeH264DpbSlotInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for VideoEncodeH264DpbSlotInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VideoEncodeH264PictureInfoKHR`] with lifetime-tied pNext safety.
pub struct VideoEncodeH264PictureInfoKHRBuilder<'a> {
    inner: VideoEncodeH264PictureInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl VideoEncodeH264PictureInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> VideoEncodeH264PictureInfoKHRBuilder<'a> {
        VideoEncodeH264PictureInfoKHRBuilder {
            inner: VideoEncodeH264PictureInfoKHR {
                s_type: StructureType::from_raw(1000038003i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> VideoEncodeH264PictureInfoKHRBuilder<'a> {
    #[inline]
    pub fn nalu_slice_entries(
        mut self,
        slice: &'a [VideoEncodeH264NaluSliceInfoKHR],
    ) -> Self {
        self.inner.nalu_slice_entry_count = slice.len() as u32;
        self.inner.p_nalu_slice_entries = slice.as_ptr();
        self
    }
    #[inline]
    pub fn std_picture_info(
        mut self,
        value: *const StdVideoEncodeH264PictureInfo,
    ) -> Self {
        self.inner.p_std_picture_info = value;
        self
    }
    #[inline]
    pub fn generate_prefix_nalu(mut self, value: bool) -> Self {
        self.inner.generate_prefix_nalu = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`VideoEncodeH264PictureInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsVideoEncodeH264PictureInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for VideoEncodeH264PictureInfoKHRBuilder<'a> {
    type Target = VideoEncodeH264PictureInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for VideoEncodeH264PictureInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VideoEncodeH264ProfileInfoKHR`] with lifetime-tied pNext safety.
pub struct VideoEncodeH264ProfileInfoKHRBuilder<'a> {
    inner: VideoEncodeH264ProfileInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl VideoEncodeH264ProfileInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> VideoEncodeH264ProfileInfoKHRBuilder<'a> {
        VideoEncodeH264ProfileInfoKHRBuilder {
            inner: VideoEncodeH264ProfileInfoKHR {
                s_type: StructureType::from_raw(1000038007i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> VideoEncodeH264ProfileInfoKHRBuilder<'a> {
    #[inline]
    pub fn std_profile_idc(mut self, value: StdVideoH264ProfileIdc) -> Self {
        self.inner.std_profile_idc = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`VideoEncodeH264ProfileInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsVideoEncodeH264ProfileInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for VideoEncodeH264ProfileInfoKHRBuilder<'a> {
    type Target = VideoEncodeH264ProfileInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for VideoEncodeH264ProfileInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VideoEncodeH264NaluSliceInfoKHR`] with lifetime-tied pNext safety.
pub struct VideoEncodeH264NaluSliceInfoKHRBuilder<'a> {
    inner: VideoEncodeH264NaluSliceInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl VideoEncodeH264NaluSliceInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> VideoEncodeH264NaluSliceInfoKHRBuilder<'a> {
        VideoEncodeH264NaluSliceInfoKHRBuilder {
            inner: VideoEncodeH264NaluSliceInfoKHR {
                s_type: StructureType::from_raw(1000038005i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> VideoEncodeH264NaluSliceInfoKHRBuilder<'a> {
    #[inline]
    pub fn constant_qp(mut self, value: i32) -> Self {
        self.inner.constant_qp = value;
        self
    }
    #[inline]
    pub fn std_slice_header(
        mut self,
        value: *const StdVideoEncodeH264SliceHeader,
    ) -> Self {
        self.inner.p_std_slice_header = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`VideoEncodeH264NaluSliceInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsVideoEncodeH264NaluSliceInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for VideoEncodeH264NaluSliceInfoKHRBuilder<'a> {
    type Target = VideoEncodeH264NaluSliceInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for VideoEncodeH264NaluSliceInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VideoEncodeH264RateControlInfoKHR`] with lifetime-tied pNext safety.
pub struct VideoEncodeH264RateControlInfoKHRBuilder<'a> {
    inner: VideoEncodeH264RateControlInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl VideoEncodeH264RateControlInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> VideoEncodeH264RateControlInfoKHRBuilder<'a> {
        VideoEncodeH264RateControlInfoKHRBuilder {
            inner: VideoEncodeH264RateControlInfoKHR {
                s_type: StructureType::from_raw(1000038008i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> VideoEncodeH264RateControlInfoKHRBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: VideoEncodeH264RateControlFlagsKHR) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn gop_frame_count(mut self, value: u32) -> Self {
        self.inner.gop_frame_count = value;
        self
    }
    #[inline]
    pub fn idr_period(mut self, value: u32) -> Self {
        self.inner.idr_period = value;
        self
    }
    #[inline]
    pub fn consecutive_b_frame_count(mut self, value: u32) -> Self {
        self.inner.consecutive_b_frame_count = value;
        self
    }
    #[inline]
    pub fn temporal_layer_count(mut self, value: u32) -> Self {
        self.inner.temporal_layer_count = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`VideoEncodeH264RateControlInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsVideoEncodeH264RateControlInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for VideoEncodeH264RateControlInfoKHRBuilder<'a> {
    type Target = VideoEncodeH264RateControlInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for VideoEncodeH264RateControlInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VideoEncodeH264QpKHR`].
pub struct VideoEncodeH264QpKHRBuilder {
    inner: VideoEncodeH264QpKHR,
}
impl VideoEncodeH264QpKHR {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> VideoEncodeH264QpKHRBuilder {
        VideoEncodeH264QpKHRBuilder {
            inner: VideoEncodeH264QpKHR {
                ..Default::default()
            },
        }
    }
}
impl VideoEncodeH264QpKHRBuilder {
    #[inline]
    pub fn qp_i(mut self, value: i32) -> Self {
        self.inner.qp_i = value;
        self
    }
    #[inline]
    pub fn qp_p(mut self, value: i32) -> Self {
        self.inner.qp_p = value;
        self
    }
    #[inline]
    pub fn qp_b(mut self, value: i32) -> Self {
        self.inner.qp_b = value;
        self
    }
}
impl core::ops::Deref for VideoEncodeH264QpKHRBuilder {
    type Target = VideoEncodeH264QpKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for VideoEncodeH264QpKHRBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VideoEncodeH264FrameSizeKHR`].
pub struct VideoEncodeH264FrameSizeKHRBuilder {
    inner: VideoEncodeH264FrameSizeKHR,
}
impl VideoEncodeH264FrameSizeKHR {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> VideoEncodeH264FrameSizeKHRBuilder {
        VideoEncodeH264FrameSizeKHRBuilder {
            inner: VideoEncodeH264FrameSizeKHR {
                ..Default::default()
            },
        }
    }
}
impl VideoEncodeH264FrameSizeKHRBuilder {
    #[inline]
    pub fn frame_i_size(mut self, value: u32) -> Self {
        self.inner.frame_i_size = value;
        self
    }
    #[inline]
    pub fn frame_p_size(mut self, value: u32) -> Self {
        self.inner.frame_p_size = value;
        self
    }
    #[inline]
    pub fn frame_b_size(mut self, value: u32) -> Self {
        self.inner.frame_b_size = value;
        self
    }
}
impl core::ops::Deref for VideoEncodeH264FrameSizeKHRBuilder {
    type Target = VideoEncodeH264FrameSizeKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for VideoEncodeH264FrameSizeKHRBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VideoEncodeH264GopRemainingFrameInfoKHR`] with lifetime-tied pNext safety.
pub struct VideoEncodeH264GopRemainingFrameInfoKHRBuilder<'a> {
    inner: VideoEncodeH264GopRemainingFrameInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl VideoEncodeH264GopRemainingFrameInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> VideoEncodeH264GopRemainingFrameInfoKHRBuilder<'a> {
        VideoEncodeH264GopRemainingFrameInfoKHRBuilder {
            inner: VideoEncodeH264GopRemainingFrameInfoKHR {
                s_type: StructureType::from_raw(1000038006i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> VideoEncodeH264GopRemainingFrameInfoKHRBuilder<'a> {
    #[inline]
    pub fn use_gop_remaining_frames(mut self, value: bool) -> Self {
        self.inner.use_gop_remaining_frames = value as u32;
        self
    }
    #[inline]
    pub fn gop_remaining_i(mut self, value: u32) -> Self {
        self.inner.gop_remaining_i = value;
        self
    }
    #[inline]
    pub fn gop_remaining_p(mut self, value: u32) -> Self {
        self.inner.gop_remaining_p = value;
        self
    }
    #[inline]
    pub fn gop_remaining_b(mut self, value: u32) -> Self {
        self.inner.gop_remaining_b = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`VideoEncodeH264GopRemainingFrameInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsVideoEncodeH264GopRemainingFrameInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for VideoEncodeH264GopRemainingFrameInfoKHRBuilder<'a> {
    type Target = VideoEncodeH264GopRemainingFrameInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for VideoEncodeH264GopRemainingFrameInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VideoEncodeH264RateControlLayerInfoKHR`] with lifetime-tied pNext safety.
pub struct VideoEncodeH264RateControlLayerInfoKHRBuilder<'a> {
    inner: VideoEncodeH264RateControlLayerInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl VideoEncodeH264RateControlLayerInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> VideoEncodeH264RateControlLayerInfoKHRBuilder<'a> {
        VideoEncodeH264RateControlLayerInfoKHRBuilder {
            inner: VideoEncodeH264RateControlLayerInfoKHR {
                s_type: StructureType::from_raw(1000038009i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> VideoEncodeH264RateControlLayerInfoKHRBuilder<'a> {
    #[inline]
    pub fn use_min_qp(mut self, value: bool) -> Self {
        self.inner.use_min_qp = value as u32;
        self
    }
    #[inline]
    pub fn min_qp(mut self, value: VideoEncodeH264QpKHR) -> Self {
        self.inner.min_qp = value;
        self
    }
    #[inline]
    pub fn use_max_qp(mut self, value: bool) -> Self {
        self.inner.use_max_qp = value as u32;
        self
    }
    #[inline]
    pub fn max_qp(mut self, value: VideoEncodeH264QpKHR) -> Self {
        self.inner.max_qp = value;
        self
    }
    #[inline]
    pub fn use_max_frame_size(mut self, value: bool) -> Self {
        self.inner.use_max_frame_size = value as u32;
        self
    }
    #[inline]
    pub fn max_frame_size(mut self, value: VideoEncodeH264FrameSizeKHR) -> Self {
        self.inner.max_frame_size = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`VideoEncodeH264RateControlLayerInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsVideoEncodeH264RateControlLayerInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for VideoEncodeH264RateControlLayerInfoKHRBuilder<'a> {
    type Target = VideoEncodeH264RateControlLayerInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for VideoEncodeH264RateControlLayerInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VideoEncodeH265CapabilitiesKHR`] with lifetime-tied pNext safety.
pub struct VideoEncodeH265CapabilitiesKHRBuilder<'a> {
    inner: VideoEncodeH265CapabilitiesKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl VideoEncodeH265CapabilitiesKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> VideoEncodeH265CapabilitiesKHRBuilder<'a> {
        VideoEncodeH265CapabilitiesKHRBuilder {
            inner: VideoEncodeH265CapabilitiesKHR {
                s_type: StructureType::from_raw(1000039000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> VideoEncodeH265CapabilitiesKHRBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: VideoEncodeH265CapabilityFlagsKHR) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn max_level_idc(mut self, value: StdVideoH265LevelIdc) -> Self {
        self.inner.max_level_idc = value;
        self
    }
    #[inline]
    pub fn max_slice_segment_count(mut self, value: u32) -> Self {
        self.inner.max_slice_segment_count = value;
        self
    }
    #[inline]
    pub fn max_tiles(mut self, value: Extent2D) -> Self {
        self.inner.max_tiles = value;
        self
    }
    #[inline]
    pub fn ctb_sizes(mut self, value: VideoEncodeH265CtbSizeFlagsKHR) -> Self {
        self.inner.ctb_sizes = value;
        self
    }
    #[inline]
    pub fn transform_block_sizes(
        mut self,
        value: VideoEncodeH265TransformBlockSizeFlagsKHR,
    ) -> Self {
        self.inner.transform_block_sizes = value;
        self
    }
    #[inline]
    pub fn max_p_picture_l0_reference_count(mut self, value: u32) -> Self {
        self.inner.max_p_picture_l0_reference_count = value;
        self
    }
    #[inline]
    pub fn max_b_picture_l0_reference_count(mut self, value: u32) -> Self {
        self.inner.max_b_picture_l0_reference_count = value;
        self
    }
    #[inline]
    pub fn max_l1_reference_count(mut self, value: u32) -> Self {
        self.inner.max_l1_reference_count = value;
        self
    }
    #[inline]
    pub fn max_sub_layer_count(mut self, value: u32) -> Self {
        self.inner.max_sub_layer_count = value;
        self
    }
    #[inline]
    pub fn expect_dyadic_temporal_sub_layer_pattern(mut self, value: bool) -> Self {
        self.inner.expect_dyadic_temporal_sub_layer_pattern = value as u32;
        self
    }
    #[inline]
    pub fn min_qp(mut self, value: i32) -> Self {
        self.inner.min_qp = value;
        self
    }
    #[inline]
    pub fn max_qp(mut self, value: i32) -> Self {
        self.inner.max_qp = value;
        self
    }
    #[inline]
    pub fn prefers_gop_remaining_frames(mut self, value: bool) -> Self {
        self.inner.prefers_gop_remaining_frames = value as u32;
        self
    }
    #[inline]
    pub fn requires_gop_remaining_frames(mut self, value: bool) -> Self {
        self.inner.requires_gop_remaining_frames = value as u32;
        self
    }
    #[inline]
    pub fn std_syntax_flags(mut self, value: VideoEncodeH265StdFlagsKHR) -> Self {
        self.inner.std_syntax_flags = value;
        self
    }
}
impl<'a> core::ops::Deref for VideoEncodeH265CapabilitiesKHRBuilder<'a> {
    type Target = VideoEncodeH265CapabilitiesKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for VideoEncodeH265CapabilitiesKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VideoEncodeH265QualityLevelPropertiesKHR`] with lifetime-tied pNext safety.
pub struct VideoEncodeH265QualityLevelPropertiesKHRBuilder<'a> {
    inner: VideoEncodeH265QualityLevelPropertiesKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl VideoEncodeH265QualityLevelPropertiesKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> VideoEncodeH265QualityLevelPropertiesKHRBuilder<'a> {
        VideoEncodeH265QualityLevelPropertiesKHRBuilder {
            inner: VideoEncodeH265QualityLevelPropertiesKHR {
                s_type: StructureType::from_raw(1000039012i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> VideoEncodeH265QualityLevelPropertiesKHRBuilder<'a> {
    #[inline]
    pub fn preferred_rate_control_flags(
        mut self,
        value: VideoEncodeH265RateControlFlagsKHR,
    ) -> Self {
        self.inner.preferred_rate_control_flags = value;
        self
    }
    #[inline]
    pub fn preferred_gop_frame_count(mut self, value: u32) -> Self {
        self.inner.preferred_gop_frame_count = value;
        self
    }
    #[inline]
    pub fn preferred_idr_period(mut self, value: u32) -> Self {
        self.inner.preferred_idr_period = value;
        self
    }
    #[inline]
    pub fn preferred_consecutive_b_frame_count(mut self, value: u32) -> Self {
        self.inner.preferred_consecutive_b_frame_count = value;
        self
    }
    #[inline]
    pub fn preferred_sub_layer_count(mut self, value: u32) -> Self {
        self.inner.preferred_sub_layer_count = value;
        self
    }
    #[inline]
    pub fn preferred_constant_qp(mut self, value: VideoEncodeH265QpKHR) -> Self {
        self.inner.preferred_constant_qp = value;
        self
    }
    #[inline]
    pub fn preferred_max_l0_reference_count(mut self, value: u32) -> Self {
        self.inner.preferred_max_l0_reference_count = value;
        self
    }
    #[inline]
    pub fn preferred_max_l1_reference_count(mut self, value: u32) -> Self {
        self.inner.preferred_max_l1_reference_count = value;
        self
    }
}
impl<'a> core::ops::Deref for VideoEncodeH265QualityLevelPropertiesKHRBuilder<'a> {
    type Target = VideoEncodeH265QualityLevelPropertiesKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for VideoEncodeH265QualityLevelPropertiesKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VideoEncodeH265SessionCreateInfoKHR`] with lifetime-tied pNext safety.
pub struct VideoEncodeH265SessionCreateInfoKHRBuilder<'a> {
    inner: VideoEncodeH265SessionCreateInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl VideoEncodeH265SessionCreateInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> VideoEncodeH265SessionCreateInfoKHRBuilder<'a> {
        VideoEncodeH265SessionCreateInfoKHRBuilder {
            inner: VideoEncodeH265SessionCreateInfoKHR {
                s_type: StructureType::from_raw(1000039011i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> VideoEncodeH265SessionCreateInfoKHRBuilder<'a> {
    #[inline]
    pub fn use_max_level_idc(mut self, value: bool) -> Self {
        self.inner.use_max_level_idc = value as u32;
        self
    }
    #[inline]
    pub fn max_level_idc(mut self, value: StdVideoH265LevelIdc) -> Self {
        self.inner.max_level_idc = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`VideoEncodeH265SessionCreateInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsVideoEncodeH265SessionCreateInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for VideoEncodeH265SessionCreateInfoKHRBuilder<'a> {
    type Target = VideoEncodeH265SessionCreateInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for VideoEncodeH265SessionCreateInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VideoEncodeH265SessionParametersAddInfoKHR`] with lifetime-tied pNext safety.
pub struct VideoEncodeH265SessionParametersAddInfoKHRBuilder<'a> {
    inner: VideoEncodeH265SessionParametersAddInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl VideoEncodeH265SessionParametersAddInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> VideoEncodeH265SessionParametersAddInfoKHRBuilder<'a> {
        VideoEncodeH265SessionParametersAddInfoKHRBuilder {
            inner: VideoEncodeH265SessionParametersAddInfoKHR {
                s_type: StructureType::from_raw(1000039002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> VideoEncodeH265SessionParametersAddInfoKHRBuilder<'a> {
    #[inline]
    pub fn std_vps_count(mut self, value: u32) -> Self {
        self.inner.std_vps_count = value;
        self
    }
    #[inline]
    pub fn std_vp_ss(mut self, slice: &'a [StdVideoH265VideoParameterSet]) -> Self {
        self.inner.std_vps_count = slice.len() as u32;
        self.inner.p_std_vp_ss = slice.as_ptr();
        self
    }
    #[inline]
    pub fn std_sps_count(mut self, value: u32) -> Self {
        self.inner.std_sps_count = value;
        self
    }
    #[inline]
    pub fn std_sp_ss(mut self, slice: &'a [StdVideoH265SequenceParameterSet]) -> Self {
        self.inner.std_sps_count = slice.len() as u32;
        self.inner.p_std_sp_ss = slice.as_ptr();
        self
    }
    #[inline]
    pub fn std_pps_count(mut self, value: u32) -> Self {
        self.inner.std_pps_count = value;
        self
    }
    #[inline]
    pub fn std_pp_ss(mut self, slice: &'a [StdVideoH265PictureParameterSet]) -> Self {
        self.inner.std_pps_count = slice.len() as u32;
        self.inner.p_std_pp_ss = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`VideoEncodeH265SessionParametersAddInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsVideoEncodeH265SessionParametersAddInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for VideoEncodeH265SessionParametersAddInfoKHRBuilder<'a> {
    type Target = VideoEncodeH265SessionParametersAddInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for VideoEncodeH265SessionParametersAddInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VideoEncodeH265SessionParametersCreateInfoKHR`] with lifetime-tied pNext safety.
pub struct VideoEncodeH265SessionParametersCreateInfoKHRBuilder<'a> {
    inner: VideoEncodeH265SessionParametersCreateInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl VideoEncodeH265SessionParametersCreateInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> VideoEncodeH265SessionParametersCreateInfoKHRBuilder<'a> {
        VideoEncodeH265SessionParametersCreateInfoKHRBuilder {
            inner: VideoEncodeH265SessionParametersCreateInfoKHR {
                s_type: StructureType::from_raw(1000039001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> VideoEncodeH265SessionParametersCreateInfoKHRBuilder<'a> {
    #[inline]
    pub fn max_std_vps_count(mut self, value: u32) -> Self {
        self.inner.max_std_vps_count = value;
        self
    }
    #[inline]
    pub fn max_std_sps_count(mut self, value: u32) -> Self {
        self.inner.max_std_sps_count = value;
        self
    }
    #[inline]
    pub fn max_std_pps_count(mut self, value: u32) -> Self {
        self.inner.max_std_pps_count = value;
        self
    }
    #[inline]
    pub fn parameters_add_info(
        mut self,
        value: &'a VideoEncodeH265SessionParametersAddInfoKHR,
    ) -> Self {
        self.inner.p_parameters_add_info = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`VideoEncodeH265SessionParametersCreateInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsVideoEncodeH265SessionParametersCreateInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for VideoEncodeH265SessionParametersCreateInfoKHRBuilder<'a> {
    type Target = VideoEncodeH265SessionParametersCreateInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for VideoEncodeH265SessionParametersCreateInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VideoEncodeH265SessionParametersGetInfoKHR`] with lifetime-tied pNext safety.
pub struct VideoEncodeH265SessionParametersGetInfoKHRBuilder<'a> {
    inner: VideoEncodeH265SessionParametersGetInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl VideoEncodeH265SessionParametersGetInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> VideoEncodeH265SessionParametersGetInfoKHRBuilder<'a> {
        VideoEncodeH265SessionParametersGetInfoKHRBuilder {
            inner: VideoEncodeH265SessionParametersGetInfoKHR {
                s_type: StructureType::from_raw(1000039013i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> VideoEncodeH265SessionParametersGetInfoKHRBuilder<'a> {
    #[inline]
    pub fn write_std_vps(mut self, value: bool) -> Self {
        self.inner.write_std_vps = value as u32;
        self
    }
    #[inline]
    pub fn write_std_sps(mut self, value: bool) -> Self {
        self.inner.write_std_sps = value as u32;
        self
    }
    #[inline]
    pub fn write_std_pps(mut self, value: bool) -> Self {
        self.inner.write_std_pps = value as u32;
        self
    }
    #[inline]
    pub fn std_vps_id(mut self, value: u32) -> Self {
        self.inner.std_vps_id = value;
        self
    }
    #[inline]
    pub fn std_sps_id(mut self, value: u32) -> Self {
        self.inner.std_sps_id = value;
        self
    }
    #[inline]
    pub fn std_pps_id(mut self, value: u32) -> Self {
        self.inner.std_pps_id = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`VideoEncodeH265SessionParametersGetInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsVideoEncodeH265SessionParametersGetInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for VideoEncodeH265SessionParametersGetInfoKHRBuilder<'a> {
    type Target = VideoEncodeH265SessionParametersGetInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for VideoEncodeH265SessionParametersGetInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VideoEncodeH265SessionParametersFeedbackInfoKHR`] with lifetime-tied pNext safety.
pub struct VideoEncodeH265SessionParametersFeedbackInfoKHRBuilder<'a> {
    inner: VideoEncodeH265SessionParametersFeedbackInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl VideoEncodeH265SessionParametersFeedbackInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> VideoEncodeH265SessionParametersFeedbackInfoKHRBuilder<'a> {
        VideoEncodeH265SessionParametersFeedbackInfoKHRBuilder {
            inner: VideoEncodeH265SessionParametersFeedbackInfoKHR {
                s_type: StructureType::from_raw(1000039014i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> VideoEncodeH265SessionParametersFeedbackInfoKHRBuilder<'a> {
    #[inline]
    pub fn has_std_vps_overrides(mut self, value: bool) -> Self {
        self.inner.has_std_vps_overrides = value as u32;
        self
    }
    #[inline]
    pub fn has_std_sps_overrides(mut self, value: bool) -> Self {
        self.inner.has_std_sps_overrides = value as u32;
        self
    }
    #[inline]
    pub fn has_std_pps_overrides(mut self, value: bool) -> Self {
        self.inner.has_std_pps_overrides = value as u32;
        self
    }
}
impl<'a> core::ops::Deref
for VideoEncodeH265SessionParametersFeedbackInfoKHRBuilder<'a> {
    type Target = VideoEncodeH265SessionParametersFeedbackInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for VideoEncodeH265SessionParametersFeedbackInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VideoEncodeH265PictureInfoKHR`] with lifetime-tied pNext safety.
pub struct VideoEncodeH265PictureInfoKHRBuilder<'a> {
    inner: VideoEncodeH265PictureInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl VideoEncodeH265PictureInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> VideoEncodeH265PictureInfoKHRBuilder<'a> {
        VideoEncodeH265PictureInfoKHRBuilder {
            inner: VideoEncodeH265PictureInfoKHR {
                s_type: StructureType::from_raw(1000039003i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> VideoEncodeH265PictureInfoKHRBuilder<'a> {
    #[inline]
    pub fn nalu_slice_segment_entries(
        mut self,
        slice: &'a [VideoEncodeH265NaluSliceSegmentInfoKHR],
    ) -> Self {
        self.inner.nalu_slice_segment_entry_count = slice.len() as u32;
        self.inner.p_nalu_slice_segment_entries = slice.as_ptr();
        self
    }
    #[inline]
    pub fn std_picture_info(
        mut self,
        value: *const StdVideoEncodeH265PictureInfo,
    ) -> Self {
        self.inner.p_std_picture_info = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`VideoEncodeH265PictureInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsVideoEncodeH265PictureInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for VideoEncodeH265PictureInfoKHRBuilder<'a> {
    type Target = VideoEncodeH265PictureInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for VideoEncodeH265PictureInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VideoEncodeH265NaluSliceSegmentInfoKHR`] with lifetime-tied pNext safety.
pub struct VideoEncodeH265NaluSliceSegmentInfoKHRBuilder<'a> {
    inner: VideoEncodeH265NaluSliceSegmentInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl VideoEncodeH265NaluSliceSegmentInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> VideoEncodeH265NaluSliceSegmentInfoKHRBuilder<'a> {
        VideoEncodeH265NaluSliceSegmentInfoKHRBuilder {
            inner: VideoEncodeH265NaluSliceSegmentInfoKHR {
                s_type: StructureType::from_raw(1000039005i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> VideoEncodeH265NaluSliceSegmentInfoKHRBuilder<'a> {
    #[inline]
    pub fn constant_qp(mut self, value: i32) -> Self {
        self.inner.constant_qp = value;
        self
    }
    #[inline]
    pub fn std_slice_segment_header(
        mut self,
        value: *const StdVideoEncodeH265SliceSegmentHeader,
    ) -> Self {
        self.inner.p_std_slice_segment_header = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`VideoEncodeH265NaluSliceSegmentInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsVideoEncodeH265NaluSliceSegmentInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for VideoEncodeH265NaluSliceSegmentInfoKHRBuilder<'a> {
    type Target = VideoEncodeH265NaluSliceSegmentInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for VideoEncodeH265NaluSliceSegmentInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VideoEncodeH265RateControlInfoKHR`] with lifetime-tied pNext safety.
pub struct VideoEncodeH265RateControlInfoKHRBuilder<'a> {
    inner: VideoEncodeH265RateControlInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl VideoEncodeH265RateControlInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> VideoEncodeH265RateControlInfoKHRBuilder<'a> {
        VideoEncodeH265RateControlInfoKHRBuilder {
            inner: VideoEncodeH265RateControlInfoKHR {
                s_type: StructureType::from_raw(1000039009i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> VideoEncodeH265RateControlInfoKHRBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: VideoEncodeH265RateControlFlagsKHR) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn gop_frame_count(mut self, value: u32) -> Self {
        self.inner.gop_frame_count = value;
        self
    }
    #[inline]
    pub fn idr_period(mut self, value: u32) -> Self {
        self.inner.idr_period = value;
        self
    }
    #[inline]
    pub fn consecutive_b_frame_count(mut self, value: u32) -> Self {
        self.inner.consecutive_b_frame_count = value;
        self
    }
    #[inline]
    pub fn sub_layer_count(mut self, value: u32) -> Self {
        self.inner.sub_layer_count = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`VideoEncodeH265RateControlInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsVideoEncodeH265RateControlInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for VideoEncodeH265RateControlInfoKHRBuilder<'a> {
    type Target = VideoEncodeH265RateControlInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for VideoEncodeH265RateControlInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VideoEncodeH265QpKHR`].
pub struct VideoEncodeH265QpKHRBuilder {
    inner: VideoEncodeH265QpKHR,
}
impl VideoEncodeH265QpKHR {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> VideoEncodeH265QpKHRBuilder {
        VideoEncodeH265QpKHRBuilder {
            inner: VideoEncodeH265QpKHR {
                ..Default::default()
            },
        }
    }
}
impl VideoEncodeH265QpKHRBuilder {
    #[inline]
    pub fn qp_i(mut self, value: i32) -> Self {
        self.inner.qp_i = value;
        self
    }
    #[inline]
    pub fn qp_p(mut self, value: i32) -> Self {
        self.inner.qp_p = value;
        self
    }
    #[inline]
    pub fn qp_b(mut self, value: i32) -> Self {
        self.inner.qp_b = value;
        self
    }
}
impl core::ops::Deref for VideoEncodeH265QpKHRBuilder {
    type Target = VideoEncodeH265QpKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for VideoEncodeH265QpKHRBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VideoEncodeH265FrameSizeKHR`].
pub struct VideoEncodeH265FrameSizeKHRBuilder {
    inner: VideoEncodeH265FrameSizeKHR,
}
impl VideoEncodeH265FrameSizeKHR {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> VideoEncodeH265FrameSizeKHRBuilder {
        VideoEncodeH265FrameSizeKHRBuilder {
            inner: VideoEncodeH265FrameSizeKHR {
                ..Default::default()
            },
        }
    }
}
impl VideoEncodeH265FrameSizeKHRBuilder {
    #[inline]
    pub fn frame_i_size(mut self, value: u32) -> Self {
        self.inner.frame_i_size = value;
        self
    }
    #[inline]
    pub fn frame_p_size(mut self, value: u32) -> Self {
        self.inner.frame_p_size = value;
        self
    }
    #[inline]
    pub fn frame_b_size(mut self, value: u32) -> Self {
        self.inner.frame_b_size = value;
        self
    }
}
impl core::ops::Deref for VideoEncodeH265FrameSizeKHRBuilder {
    type Target = VideoEncodeH265FrameSizeKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for VideoEncodeH265FrameSizeKHRBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VideoEncodeH265GopRemainingFrameInfoKHR`] with lifetime-tied pNext safety.
pub struct VideoEncodeH265GopRemainingFrameInfoKHRBuilder<'a> {
    inner: VideoEncodeH265GopRemainingFrameInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl VideoEncodeH265GopRemainingFrameInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> VideoEncodeH265GopRemainingFrameInfoKHRBuilder<'a> {
        VideoEncodeH265GopRemainingFrameInfoKHRBuilder {
            inner: VideoEncodeH265GopRemainingFrameInfoKHR {
                s_type: StructureType::from_raw(1000039006i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> VideoEncodeH265GopRemainingFrameInfoKHRBuilder<'a> {
    #[inline]
    pub fn use_gop_remaining_frames(mut self, value: bool) -> Self {
        self.inner.use_gop_remaining_frames = value as u32;
        self
    }
    #[inline]
    pub fn gop_remaining_i(mut self, value: u32) -> Self {
        self.inner.gop_remaining_i = value;
        self
    }
    #[inline]
    pub fn gop_remaining_p(mut self, value: u32) -> Self {
        self.inner.gop_remaining_p = value;
        self
    }
    #[inline]
    pub fn gop_remaining_b(mut self, value: u32) -> Self {
        self.inner.gop_remaining_b = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`VideoEncodeH265GopRemainingFrameInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsVideoEncodeH265GopRemainingFrameInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for VideoEncodeH265GopRemainingFrameInfoKHRBuilder<'a> {
    type Target = VideoEncodeH265GopRemainingFrameInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for VideoEncodeH265GopRemainingFrameInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VideoEncodeH265RateControlLayerInfoKHR`] with lifetime-tied pNext safety.
pub struct VideoEncodeH265RateControlLayerInfoKHRBuilder<'a> {
    inner: VideoEncodeH265RateControlLayerInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl VideoEncodeH265RateControlLayerInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> VideoEncodeH265RateControlLayerInfoKHRBuilder<'a> {
        VideoEncodeH265RateControlLayerInfoKHRBuilder {
            inner: VideoEncodeH265RateControlLayerInfoKHR {
                s_type: StructureType::from_raw(1000039010i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> VideoEncodeH265RateControlLayerInfoKHRBuilder<'a> {
    #[inline]
    pub fn use_min_qp(mut self, value: bool) -> Self {
        self.inner.use_min_qp = value as u32;
        self
    }
    #[inline]
    pub fn min_qp(mut self, value: VideoEncodeH265QpKHR) -> Self {
        self.inner.min_qp = value;
        self
    }
    #[inline]
    pub fn use_max_qp(mut self, value: bool) -> Self {
        self.inner.use_max_qp = value as u32;
        self
    }
    #[inline]
    pub fn max_qp(mut self, value: VideoEncodeH265QpKHR) -> Self {
        self.inner.max_qp = value;
        self
    }
    #[inline]
    pub fn use_max_frame_size(mut self, value: bool) -> Self {
        self.inner.use_max_frame_size = value as u32;
        self
    }
    #[inline]
    pub fn max_frame_size(mut self, value: VideoEncodeH265FrameSizeKHR) -> Self {
        self.inner.max_frame_size = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`VideoEncodeH265RateControlLayerInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsVideoEncodeH265RateControlLayerInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for VideoEncodeH265RateControlLayerInfoKHRBuilder<'a> {
    type Target = VideoEncodeH265RateControlLayerInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for VideoEncodeH265RateControlLayerInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VideoEncodeH265ProfileInfoKHR`] with lifetime-tied pNext safety.
pub struct VideoEncodeH265ProfileInfoKHRBuilder<'a> {
    inner: VideoEncodeH265ProfileInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl VideoEncodeH265ProfileInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> VideoEncodeH265ProfileInfoKHRBuilder<'a> {
        VideoEncodeH265ProfileInfoKHRBuilder {
            inner: VideoEncodeH265ProfileInfoKHR {
                s_type: StructureType::from_raw(1000039007i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> VideoEncodeH265ProfileInfoKHRBuilder<'a> {
    #[inline]
    pub fn std_profile_idc(mut self, value: StdVideoH265ProfileIdc) -> Self {
        self.inner.std_profile_idc = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`VideoEncodeH265ProfileInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsVideoEncodeH265ProfileInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for VideoEncodeH265ProfileInfoKHRBuilder<'a> {
    type Target = VideoEncodeH265ProfileInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for VideoEncodeH265ProfileInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VideoEncodeH265DpbSlotInfoKHR`] with lifetime-tied pNext safety.
pub struct VideoEncodeH265DpbSlotInfoKHRBuilder<'a> {
    inner: VideoEncodeH265DpbSlotInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl VideoEncodeH265DpbSlotInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> VideoEncodeH265DpbSlotInfoKHRBuilder<'a> {
        VideoEncodeH265DpbSlotInfoKHRBuilder {
            inner: VideoEncodeH265DpbSlotInfoKHR {
                s_type: StructureType::from_raw(1000039004i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> VideoEncodeH265DpbSlotInfoKHRBuilder<'a> {
    #[inline]
    pub fn std_reference_info(
        mut self,
        value: *const StdVideoEncodeH265ReferenceInfo,
    ) -> Self {
        self.inner.p_std_reference_info = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`VideoEncodeH265DpbSlotInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsVideoEncodeH265DpbSlotInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for VideoEncodeH265DpbSlotInfoKHRBuilder<'a> {
    type Target = VideoEncodeH265DpbSlotInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for VideoEncodeH265DpbSlotInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VideoEncodeAV1CapabilitiesKHR`] with lifetime-tied pNext safety.
pub struct VideoEncodeAV1CapabilitiesKHRBuilder<'a> {
    inner: VideoEncodeAV1CapabilitiesKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl VideoEncodeAV1CapabilitiesKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> VideoEncodeAV1CapabilitiesKHRBuilder<'a> {
        VideoEncodeAV1CapabilitiesKHRBuilder {
            inner: VideoEncodeAV1CapabilitiesKHR {
                s_type: StructureType::from_raw(1000513000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> VideoEncodeAV1CapabilitiesKHRBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: VideoEncodeAV1CapabilityFlagsKHR) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn max_level(mut self, value: StdVideoAV1Level) -> Self {
        self.inner.max_level = value;
        self
    }
    #[inline]
    pub fn coded_picture_alignment(mut self, value: Extent2D) -> Self {
        self.inner.coded_picture_alignment = value;
        self
    }
    #[inline]
    pub fn max_tiles(mut self, value: Extent2D) -> Self {
        self.inner.max_tiles = value;
        self
    }
    #[inline]
    pub fn min_tile_size(mut self, value: Extent2D) -> Self {
        self.inner.min_tile_size = value;
        self
    }
    #[inline]
    pub fn max_tile_size(mut self, value: Extent2D) -> Self {
        self.inner.max_tile_size = value;
        self
    }
    #[inline]
    pub fn superblock_sizes(
        mut self,
        value: VideoEncodeAV1SuperblockSizeFlagsKHR,
    ) -> Self {
        self.inner.superblock_sizes = value;
        self
    }
    #[inline]
    pub fn max_single_reference_count(mut self, value: u32) -> Self {
        self.inner.max_single_reference_count = value;
        self
    }
    #[inline]
    pub fn single_reference_name_mask(mut self, value: u32) -> Self {
        self.inner.single_reference_name_mask = value;
        self
    }
    #[inline]
    pub fn max_unidirectional_compound_reference_count(mut self, value: u32) -> Self {
        self.inner.max_unidirectional_compound_reference_count = value;
        self
    }
    #[inline]
    pub fn max_unidirectional_compound_group1_reference_count(
        mut self,
        value: u32,
    ) -> Self {
        self.inner.max_unidirectional_compound_group1_reference_count = value;
        self
    }
    #[inline]
    pub fn unidirectional_compound_reference_name_mask(mut self, value: u32) -> Self {
        self.inner.unidirectional_compound_reference_name_mask = value;
        self
    }
    #[inline]
    pub fn max_bidirectional_compound_reference_count(mut self, value: u32) -> Self {
        self.inner.max_bidirectional_compound_reference_count = value;
        self
    }
    #[inline]
    pub fn max_bidirectional_compound_group1_reference_count(
        mut self,
        value: u32,
    ) -> Self {
        self.inner.max_bidirectional_compound_group1_reference_count = value;
        self
    }
    #[inline]
    pub fn max_bidirectional_compound_group2_reference_count(
        mut self,
        value: u32,
    ) -> Self {
        self.inner.max_bidirectional_compound_group2_reference_count = value;
        self
    }
    #[inline]
    pub fn bidirectional_compound_reference_name_mask(mut self, value: u32) -> Self {
        self.inner.bidirectional_compound_reference_name_mask = value;
        self
    }
    #[inline]
    pub fn max_temporal_layer_count(mut self, value: u32) -> Self {
        self.inner.max_temporal_layer_count = value;
        self
    }
    #[inline]
    pub fn max_spatial_layer_count(mut self, value: u32) -> Self {
        self.inner.max_spatial_layer_count = value;
        self
    }
    #[inline]
    pub fn max_operating_points(mut self, value: u32) -> Self {
        self.inner.max_operating_points = value;
        self
    }
    #[inline]
    pub fn min_q_index(mut self, value: u32) -> Self {
        self.inner.min_q_index = value;
        self
    }
    #[inline]
    pub fn max_q_index(mut self, value: u32) -> Self {
        self.inner.max_q_index = value;
        self
    }
    #[inline]
    pub fn prefers_gop_remaining_frames(mut self, value: bool) -> Self {
        self.inner.prefers_gop_remaining_frames = value as u32;
        self
    }
    #[inline]
    pub fn requires_gop_remaining_frames(mut self, value: bool) -> Self {
        self.inner.requires_gop_remaining_frames = value as u32;
        self
    }
    #[inline]
    pub fn std_syntax_flags(mut self, value: VideoEncodeAV1StdFlagsKHR) -> Self {
        self.inner.std_syntax_flags = value;
        self
    }
}
impl<'a> core::ops::Deref for VideoEncodeAV1CapabilitiesKHRBuilder<'a> {
    type Target = VideoEncodeAV1CapabilitiesKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for VideoEncodeAV1CapabilitiesKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VideoEncodeAV1QualityLevelPropertiesKHR`] with lifetime-tied pNext safety.
pub struct VideoEncodeAV1QualityLevelPropertiesKHRBuilder<'a> {
    inner: VideoEncodeAV1QualityLevelPropertiesKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl VideoEncodeAV1QualityLevelPropertiesKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> VideoEncodeAV1QualityLevelPropertiesKHRBuilder<'a> {
        VideoEncodeAV1QualityLevelPropertiesKHRBuilder {
            inner: VideoEncodeAV1QualityLevelPropertiesKHR {
                s_type: StructureType::from_raw(1000513008i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> VideoEncodeAV1QualityLevelPropertiesKHRBuilder<'a> {
    #[inline]
    pub fn preferred_rate_control_flags(
        mut self,
        value: VideoEncodeAV1RateControlFlagsKHR,
    ) -> Self {
        self.inner.preferred_rate_control_flags = value;
        self
    }
    #[inline]
    pub fn preferred_gop_frame_count(mut self, value: u32) -> Self {
        self.inner.preferred_gop_frame_count = value;
        self
    }
    #[inline]
    pub fn preferred_key_frame_period(mut self, value: u32) -> Self {
        self.inner.preferred_key_frame_period = value;
        self
    }
    #[inline]
    pub fn preferred_consecutive_bipredictive_frame_count(mut self, value: u32) -> Self {
        self.inner.preferred_consecutive_bipredictive_frame_count = value;
        self
    }
    #[inline]
    pub fn preferred_temporal_layer_count(mut self, value: u32) -> Self {
        self.inner.preferred_temporal_layer_count = value;
        self
    }
    #[inline]
    pub fn preferred_constant_q_index(mut self, value: VideoEncodeAV1QIndexKHR) -> Self {
        self.inner.preferred_constant_q_index = value;
        self
    }
    #[inline]
    pub fn preferred_max_single_reference_count(mut self, value: u32) -> Self {
        self.inner.preferred_max_single_reference_count = value;
        self
    }
    #[inline]
    pub fn preferred_single_reference_name_mask(mut self, value: u32) -> Self {
        self.inner.preferred_single_reference_name_mask = value;
        self
    }
    #[inline]
    pub fn preferred_max_unidirectional_compound_reference_count(
        mut self,
        value: u32,
    ) -> Self {
        self.inner.preferred_max_unidirectional_compound_reference_count = value;
        self
    }
    #[inline]
    pub fn preferred_max_unidirectional_compound_group1_reference_count(
        mut self,
        value: u32,
    ) -> Self {
        self.inner.preferred_max_unidirectional_compound_group1_reference_count = value;
        self
    }
    #[inline]
    pub fn preferred_unidirectional_compound_reference_name_mask(
        mut self,
        value: u32,
    ) -> Self {
        self.inner.preferred_unidirectional_compound_reference_name_mask = value;
        self
    }
    #[inline]
    pub fn preferred_max_bidirectional_compound_reference_count(
        mut self,
        value: u32,
    ) -> Self {
        self.inner.preferred_max_bidirectional_compound_reference_count = value;
        self
    }
    #[inline]
    pub fn preferred_max_bidirectional_compound_group1_reference_count(
        mut self,
        value: u32,
    ) -> Self {
        self.inner.preferred_max_bidirectional_compound_group1_reference_count = value;
        self
    }
    #[inline]
    pub fn preferred_max_bidirectional_compound_group2_reference_count(
        mut self,
        value: u32,
    ) -> Self {
        self.inner.preferred_max_bidirectional_compound_group2_reference_count = value;
        self
    }
    #[inline]
    pub fn preferred_bidirectional_compound_reference_name_mask(
        mut self,
        value: u32,
    ) -> Self {
        self.inner.preferred_bidirectional_compound_reference_name_mask = value;
        self
    }
}
impl<'a> core::ops::Deref for VideoEncodeAV1QualityLevelPropertiesKHRBuilder<'a> {
    type Target = VideoEncodeAV1QualityLevelPropertiesKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for VideoEncodeAV1QualityLevelPropertiesKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceVideoEncodeAV1FeaturesKHR`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceVideoEncodeAV1FeaturesKHRBuilder<'a> {
    inner: PhysicalDeviceVideoEncodeAV1FeaturesKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceVideoEncodeAV1FeaturesKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceVideoEncodeAV1FeaturesKHRBuilder<'a> {
        PhysicalDeviceVideoEncodeAV1FeaturesKHRBuilder {
            inner: PhysicalDeviceVideoEncodeAV1FeaturesKHR {
                s_type: StructureType::from_raw(1000513004i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceVideoEncodeAV1FeaturesKHRBuilder<'a> {
    #[inline]
    pub fn video_encode_av1(mut self, value: bool) -> Self {
        self.inner.video_encode_av1 = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceVideoEncodeAV1FeaturesKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceVideoEncodeAV1FeaturesKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceVideoEncodeAV1FeaturesKHRBuilder<'a> {
    type Target = PhysicalDeviceVideoEncodeAV1FeaturesKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceVideoEncodeAV1FeaturesKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VideoEncodeAV1SessionCreateInfoKHR`] with lifetime-tied pNext safety.
pub struct VideoEncodeAV1SessionCreateInfoKHRBuilder<'a> {
    inner: VideoEncodeAV1SessionCreateInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl VideoEncodeAV1SessionCreateInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> VideoEncodeAV1SessionCreateInfoKHRBuilder<'a> {
        VideoEncodeAV1SessionCreateInfoKHRBuilder {
            inner: VideoEncodeAV1SessionCreateInfoKHR {
                s_type: StructureType::from_raw(1000513009i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> VideoEncodeAV1SessionCreateInfoKHRBuilder<'a> {
    #[inline]
    pub fn use_max_level(mut self, value: bool) -> Self {
        self.inner.use_max_level = value as u32;
        self
    }
    #[inline]
    pub fn max_level(mut self, value: StdVideoAV1Level) -> Self {
        self.inner.max_level = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`VideoEncodeAV1SessionCreateInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsVideoEncodeAV1SessionCreateInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for VideoEncodeAV1SessionCreateInfoKHRBuilder<'a> {
    type Target = VideoEncodeAV1SessionCreateInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for VideoEncodeAV1SessionCreateInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VideoEncodeAV1SessionParametersCreateInfoKHR`] with lifetime-tied pNext safety.
pub struct VideoEncodeAV1SessionParametersCreateInfoKHRBuilder<'a> {
    inner: VideoEncodeAV1SessionParametersCreateInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl VideoEncodeAV1SessionParametersCreateInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> VideoEncodeAV1SessionParametersCreateInfoKHRBuilder<'a> {
        VideoEncodeAV1SessionParametersCreateInfoKHRBuilder {
            inner: VideoEncodeAV1SessionParametersCreateInfoKHR {
                s_type: StructureType::from_raw(1000513001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> VideoEncodeAV1SessionParametersCreateInfoKHRBuilder<'a> {
    #[inline]
    pub fn std_sequence_header(
        mut self,
        value: *const StdVideoAV1SequenceHeader,
    ) -> Self {
        self.inner.p_std_sequence_header = value;
        self
    }
    #[inline]
    pub fn std_decoder_model_info(
        mut self,
        value: *const StdVideoEncodeAV1DecoderModelInfo,
    ) -> Self {
        self.inner.p_std_decoder_model_info = value;
        self
    }
    #[inline]
    pub fn std_operating_point_count(mut self, value: u32) -> Self {
        self.inner.std_operating_point_count = value;
        self
    }
    #[inline]
    pub fn std_operating_points(
        mut self,
        slice: &'a [StdVideoEncodeAV1OperatingPointInfo],
    ) -> Self {
        self.inner.std_operating_point_count = slice.len() as u32;
        self.inner.p_std_operating_points = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`VideoEncodeAV1SessionParametersCreateInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsVideoEncodeAV1SessionParametersCreateInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for VideoEncodeAV1SessionParametersCreateInfoKHRBuilder<'a> {
    type Target = VideoEncodeAV1SessionParametersCreateInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for VideoEncodeAV1SessionParametersCreateInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VideoEncodeAV1DpbSlotInfoKHR`] with lifetime-tied pNext safety.
pub struct VideoEncodeAV1DpbSlotInfoKHRBuilder<'a> {
    inner: VideoEncodeAV1DpbSlotInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl VideoEncodeAV1DpbSlotInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> VideoEncodeAV1DpbSlotInfoKHRBuilder<'a> {
        VideoEncodeAV1DpbSlotInfoKHRBuilder {
            inner: VideoEncodeAV1DpbSlotInfoKHR {
                s_type: StructureType::from_raw(1000513003i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> VideoEncodeAV1DpbSlotInfoKHRBuilder<'a> {
    #[inline]
    pub fn std_reference_info(
        mut self,
        value: *const StdVideoEncodeAV1ReferenceInfo,
    ) -> Self {
        self.inner.p_std_reference_info = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`VideoEncodeAV1DpbSlotInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsVideoEncodeAV1DpbSlotInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for VideoEncodeAV1DpbSlotInfoKHRBuilder<'a> {
    type Target = VideoEncodeAV1DpbSlotInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for VideoEncodeAV1DpbSlotInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VideoEncodeAV1PictureInfoKHR`] with lifetime-tied pNext safety.
pub struct VideoEncodeAV1PictureInfoKHRBuilder<'a> {
    inner: VideoEncodeAV1PictureInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl VideoEncodeAV1PictureInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> VideoEncodeAV1PictureInfoKHRBuilder<'a> {
        VideoEncodeAV1PictureInfoKHRBuilder {
            inner: VideoEncodeAV1PictureInfoKHR {
                s_type: StructureType::from_raw(1000513002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> VideoEncodeAV1PictureInfoKHRBuilder<'a> {
    #[inline]
    pub fn prediction_mode(mut self, value: VideoEncodeAV1PredictionModeKHR) -> Self {
        self.inner.prediction_mode = value;
        self
    }
    #[inline]
    pub fn rate_control_group(
        mut self,
        value: VideoEncodeAV1RateControlGroupKHR,
    ) -> Self {
        self.inner.rate_control_group = value;
        self
    }
    #[inline]
    pub fn constant_q_index(mut self, value: u32) -> Self {
        self.inner.constant_q_index = value;
        self
    }
    #[inline]
    pub fn std_picture_info(
        mut self,
        value: *const StdVideoEncodeAV1PictureInfo,
    ) -> Self {
        self.inner.p_std_picture_info = value;
        self
    }
    #[inline]
    pub fn reference_name_slot_indices(
        mut self,
        value: [i32; MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR as usize],
    ) -> Self {
        self.inner.reference_name_slot_indices = value;
        self
    }
    #[inline]
    pub fn primary_reference_cdf_only(mut self, value: bool) -> Self {
        self.inner.primary_reference_cdf_only = value as u32;
        self
    }
    #[inline]
    pub fn generate_obu_extension_header(mut self, value: bool) -> Self {
        self.inner.generate_obu_extension_header = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`VideoEncodeAV1PictureInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsVideoEncodeAV1PictureInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for VideoEncodeAV1PictureInfoKHRBuilder<'a> {
    type Target = VideoEncodeAV1PictureInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for VideoEncodeAV1PictureInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VideoEncodeAV1ProfileInfoKHR`] with lifetime-tied pNext safety.
pub struct VideoEncodeAV1ProfileInfoKHRBuilder<'a> {
    inner: VideoEncodeAV1ProfileInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl VideoEncodeAV1ProfileInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> VideoEncodeAV1ProfileInfoKHRBuilder<'a> {
        VideoEncodeAV1ProfileInfoKHRBuilder {
            inner: VideoEncodeAV1ProfileInfoKHR {
                s_type: StructureType::from_raw(1000513005i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> VideoEncodeAV1ProfileInfoKHRBuilder<'a> {
    #[inline]
    pub fn std_profile(mut self, value: StdVideoAV1Profile) -> Self {
        self.inner.std_profile = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`VideoEncodeAV1ProfileInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsVideoEncodeAV1ProfileInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for VideoEncodeAV1ProfileInfoKHRBuilder<'a> {
    type Target = VideoEncodeAV1ProfileInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for VideoEncodeAV1ProfileInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VideoEncodeAV1RateControlInfoKHR`] with lifetime-tied pNext safety.
pub struct VideoEncodeAV1RateControlInfoKHRBuilder<'a> {
    inner: VideoEncodeAV1RateControlInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl VideoEncodeAV1RateControlInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> VideoEncodeAV1RateControlInfoKHRBuilder<'a> {
        VideoEncodeAV1RateControlInfoKHRBuilder {
            inner: VideoEncodeAV1RateControlInfoKHR {
                s_type: StructureType::from_raw(1000513006i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> VideoEncodeAV1RateControlInfoKHRBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: VideoEncodeAV1RateControlFlagsKHR) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn gop_frame_count(mut self, value: u32) -> Self {
        self.inner.gop_frame_count = value;
        self
    }
    #[inline]
    pub fn key_frame_period(mut self, value: u32) -> Self {
        self.inner.key_frame_period = value;
        self
    }
    #[inline]
    pub fn consecutive_bipredictive_frame_count(mut self, value: u32) -> Self {
        self.inner.consecutive_bipredictive_frame_count = value;
        self
    }
    #[inline]
    pub fn temporal_layer_count(mut self, value: u32) -> Self {
        self.inner.temporal_layer_count = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`VideoEncodeAV1RateControlInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsVideoEncodeAV1RateControlInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for VideoEncodeAV1RateControlInfoKHRBuilder<'a> {
    type Target = VideoEncodeAV1RateControlInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for VideoEncodeAV1RateControlInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VideoEncodeAV1QIndexKHR`].
pub struct VideoEncodeAV1QIndexKHRBuilder {
    inner: VideoEncodeAV1QIndexKHR,
}
impl VideoEncodeAV1QIndexKHR {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> VideoEncodeAV1QIndexKHRBuilder {
        VideoEncodeAV1QIndexKHRBuilder {
            inner: VideoEncodeAV1QIndexKHR {
                ..Default::default()
            },
        }
    }
}
impl VideoEncodeAV1QIndexKHRBuilder {
    #[inline]
    pub fn intra_q_index(mut self, value: u32) -> Self {
        self.inner.intra_q_index = value;
        self
    }
    #[inline]
    pub fn predictive_q_index(mut self, value: u32) -> Self {
        self.inner.predictive_q_index = value;
        self
    }
    #[inline]
    pub fn bipredictive_q_index(mut self, value: u32) -> Self {
        self.inner.bipredictive_q_index = value;
        self
    }
}
impl core::ops::Deref for VideoEncodeAV1QIndexKHRBuilder {
    type Target = VideoEncodeAV1QIndexKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for VideoEncodeAV1QIndexKHRBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VideoEncodeAV1FrameSizeKHR`].
pub struct VideoEncodeAV1FrameSizeKHRBuilder {
    inner: VideoEncodeAV1FrameSizeKHR,
}
impl VideoEncodeAV1FrameSizeKHR {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> VideoEncodeAV1FrameSizeKHRBuilder {
        VideoEncodeAV1FrameSizeKHRBuilder {
            inner: VideoEncodeAV1FrameSizeKHR {
                ..Default::default()
            },
        }
    }
}
impl VideoEncodeAV1FrameSizeKHRBuilder {
    #[inline]
    pub fn intra_frame_size(mut self, value: u32) -> Self {
        self.inner.intra_frame_size = value;
        self
    }
    #[inline]
    pub fn predictive_frame_size(mut self, value: u32) -> Self {
        self.inner.predictive_frame_size = value;
        self
    }
    #[inline]
    pub fn bipredictive_frame_size(mut self, value: u32) -> Self {
        self.inner.bipredictive_frame_size = value;
        self
    }
}
impl core::ops::Deref for VideoEncodeAV1FrameSizeKHRBuilder {
    type Target = VideoEncodeAV1FrameSizeKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for VideoEncodeAV1FrameSizeKHRBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VideoEncodeAV1GopRemainingFrameInfoKHR`] with lifetime-tied pNext safety.
pub struct VideoEncodeAV1GopRemainingFrameInfoKHRBuilder<'a> {
    inner: VideoEncodeAV1GopRemainingFrameInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl VideoEncodeAV1GopRemainingFrameInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> VideoEncodeAV1GopRemainingFrameInfoKHRBuilder<'a> {
        VideoEncodeAV1GopRemainingFrameInfoKHRBuilder {
            inner: VideoEncodeAV1GopRemainingFrameInfoKHR {
                s_type: StructureType::from_raw(1000513010i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> VideoEncodeAV1GopRemainingFrameInfoKHRBuilder<'a> {
    #[inline]
    pub fn use_gop_remaining_frames(mut self, value: bool) -> Self {
        self.inner.use_gop_remaining_frames = value as u32;
        self
    }
    #[inline]
    pub fn gop_remaining_intra(mut self, value: u32) -> Self {
        self.inner.gop_remaining_intra = value;
        self
    }
    #[inline]
    pub fn gop_remaining_predictive(mut self, value: u32) -> Self {
        self.inner.gop_remaining_predictive = value;
        self
    }
    #[inline]
    pub fn gop_remaining_bipredictive(mut self, value: u32) -> Self {
        self.inner.gop_remaining_bipredictive = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`VideoEncodeAV1GopRemainingFrameInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsVideoEncodeAV1GopRemainingFrameInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for VideoEncodeAV1GopRemainingFrameInfoKHRBuilder<'a> {
    type Target = VideoEncodeAV1GopRemainingFrameInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for VideoEncodeAV1GopRemainingFrameInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VideoEncodeAV1RateControlLayerInfoKHR`] with lifetime-tied pNext safety.
pub struct VideoEncodeAV1RateControlLayerInfoKHRBuilder<'a> {
    inner: VideoEncodeAV1RateControlLayerInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl VideoEncodeAV1RateControlLayerInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> VideoEncodeAV1RateControlLayerInfoKHRBuilder<'a> {
        VideoEncodeAV1RateControlLayerInfoKHRBuilder {
            inner: VideoEncodeAV1RateControlLayerInfoKHR {
                s_type: StructureType::from_raw(1000513007i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> VideoEncodeAV1RateControlLayerInfoKHRBuilder<'a> {
    #[inline]
    pub fn use_min_q_index(mut self, value: bool) -> Self {
        self.inner.use_min_q_index = value as u32;
        self
    }
    #[inline]
    pub fn min_q_index(mut self, value: VideoEncodeAV1QIndexKHR) -> Self {
        self.inner.min_q_index = value;
        self
    }
    #[inline]
    pub fn use_max_q_index(mut self, value: bool) -> Self {
        self.inner.use_max_q_index = value as u32;
        self
    }
    #[inline]
    pub fn max_q_index(mut self, value: VideoEncodeAV1QIndexKHR) -> Self {
        self.inner.max_q_index = value;
        self
    }
    #[inline]
    pub fn use_max_frame_size(mut self, value: bool) -> Self {
        self.inner.use_max_frame_size = value as u32;
        self
    }
    #[inline]
    pub fn max_frame_size(mut self, value: VideoEncodeAV1FrameSizeKHR) -> Self {
        self.inner.max_frame_size = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`VideoEncodeAV1RateControlLayerInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsVideoEncodeAV1RateControlLayerInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for VideoEncodeAV1RateControlLayerInfoKHRBuilder<'a> {
    type Target = VideoEncodeAV1RateControlLayerInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for VideoEncodeAV1RateControlLayerInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceInheritedViewportScissorFeaturesNV`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceInheritedViewportScissorFeaturesNVBuilder<'a> {
    inner: PhysicalDeviceInheritedViewportScissorFeaturesNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceInheritedViewportScissorFeaturesNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceInheritedViewportScissorFeaturesNVBuilder<'a> {
        PhysicalDeviceInheritedViewportScissorFeaturesNVBuilder {
            inner: PhysicalDeviceInheritedViewportScissorFeaturesNV {
                s_type: StructureType::from_raw(1000278000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceInheritedViewportScissorFeaturesNVBuilder<'a> {
    #[inline]
    pub fn inherited_viewport_scissor2_d(mut self, value: bool) -> Self {
        self.inner.inherited_viewport_scissor2_d = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceInheritedViewportScissorFeaturesNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceInheritedViewportScissorFeaturesNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDeviceInheritedViewportScissorFeaturesNVBuilder<'a> {
    type Target = PhysicalDeviceInheritedViewportScissorFeaturesNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceInheritedViewportScissorFeaturesNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`CommandBufferInheritanceViewportScissorInfoNV`] with lifetime-tied pNext safety.
pub struct CommandBufferInheritanceViewportScissorInfoNVBuilder<'a> {
    inner: CommandBufferInheritanceViewportScissorInfoNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl CommandBufferInheritanceViewportScissorInfoNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> CommandBufferInheritanceViewportScissorInfoNVBuilder<'a> {
        CommandBufferInheritanceViewportScissorInfoNVBuilder {
            inner: CommandBufferInheritanceViewportScissorInfoNV {
                s_type: StructureType::from_raw(1000278001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> CommandBufferInheritanceViewportScissorInfoNVBuilder<'a> {
    #[inline]
    pub fn viewport_scissor2_d(mut self, value: bool) -> Self {
        self.inner.viewport_scissor2_d = value as u32;
        self
    }
    #[inline]
    pub fn viewport_depth_count(mut self, value: u32) -> Self {
        self.inner.viewport_depth_count = value;
        self
    }
    #[inline]
    pub fn viewport_depths(mut self, value: &'a Viewport) -> Self {
        self.inner.p_viewport_depths = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`CommandBufferInheritanceViewportScissorInfoNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsCommandBufferInheritanceViewportScissorInfoNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for CommandBufferInheritanceViewportScissorInfoNVBuilder<'a> {
    type Target = CommandBufferInheritanceViewportScissorInfoNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for CommandBufferInheritanceViewportScissorInfoNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXTBuilder<'a> {
    inner: PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXTBuilder<'a> {
        PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXTBuilder {
            inner: PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT {
                s_type: StructureType::from_raw(1000330000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXTBuilder<'a> {
    #[inline]
    pub fn ycbcr2plane444_formats(mut self, value: bool) -> Self {
        self.inner.ycbcr2plane444_formats = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXTBuilder<'a> {
    type Target = PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceProvokingVertexFeaturesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceProvokingVertexFeaturesEXTBuilder<'a> {
    inner: PhysicalDeviceProvokingVertexFeaturesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceProvokingVertexFeaturesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceProvokingVertexFeaturesEXTBuilder<'a> {
        PhysicalDeviceProvokingVertexFeaturesEXTBuilder {
            inner: PhysicalDeviceProvokingVertexFeaturesEXT {
                s_type: StructureType::from_raw(1000254000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceProvokingVertexFeaturesEXTBuilder<'a> {
    #[inline]
    pub fn provoking_vertex_last(mut self, value: bool) -> Self {
        self.inner.provoking_vertex_last = value as u32;
        self
    }
    #[inline]
    pub fn transform_feedback_preserves_provoking_vertex(mut self, value: bool) -> Self {
        self.inner.transform_feedback_preserves_provoking_vertex = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceProvokingVertexFeaturesEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceProvokingVertexFeaturesEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceProvokingVertexFeaturesEXTBuilder<'a> {
    type Target = PhysicalDeviceProvokingVertexFeaturesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceProvokingVertexFeaturesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceProvokingVertexPropertiesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceProvokingVertexPropertiesEXTBuilder<'a> {
    inner: PhysicalDeviceProvokingVertexPropertiesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceProvokingVertexPropertiesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceProvokingVertexPropertiesEXTBuilder<'a> {
        PhysicalDeviceProvokingVertexPropertiesEXTBuilder {
            inner: PhysicalDeviceProvokingVertexPropertiesEXT {
                s_type: StructureType::from_raw(1000254002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceProvokingVertexPropertiesEXTBuilder<'a> {
    #[inline]
    pub fn provoking_vertex_mode_per_pipeline(mut self, value: bool) -> Self {
        self.inner.provoking_vertex_mode_per_pipeline = value as u32;
        self
    }
    #[inline]
    pub fn transform_feedback_preserves_triangle_fan_provoking_vertex(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.transform_feedback_preserves_triangle_fan_provoking_vertex = value
            as u32;
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceProvokingVertexPropertiesEXTBuilder<'a> {
    type Target = PhysicalDeviceProvokingVertexPropertiesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceProvokingVertexPropertiesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PipelineRasterizationProvokingVertexStateCreateInfoEXT`] with lifetime-tied pNext safety.
pub struct PipelineRasterizationProvokingVertexStateCreateInfoEXTBuilder<'a> {
    inner: PipelineRasterizationProvokingVertexStateCreateInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PipelineRasterizationProvokingVertexStateCreateInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PipelineRasterizationProvokingVertexStateCreateInfoEXTBuilder<
        'a,
    > {
        PipelineRasterizationProvokingVertexStateCreateInfoEXTBuilder {
            inner: PipelineRasterizationProvokingVertexStateCreateInfoEXT {
                s_type: StructureType::from_raw(1000254001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PipelineRasterizationProvokingVertexStateCreateInfoEXTBuilder<'a> {
    #[inline]
    pub fn provoking_vertex_mode(mut self, value: ProvokingVertexModeEXT) -> Self {
        self.inner.provoking_vertex_mode = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PipelineRasterizationProvokingVertexStateCreateInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPipelineRasterizationProvokingVertexStateCreateInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref
for PipelineRasterizationProvokingVertexStateCreateInfoEXTBuilder<'a> {
    type Target = PipelineRasterizationProvokingVertexStateCreateInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PipelineRasterizationProvokingVertexStateCreateInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VideoEncodeIntraRefreshCapabilitiesKHR`] with lifetime-tied pNext safety.
pub struct VideoEncodeIntraRefreshCapabilitiesKHRBuilder<'a> {
    inner: VideoEncodeIntraRefreshCapabilitiesKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl VideoEncodeIntraRefreshCapabilitiesKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> VideoEncodeIntraRefreshCapabilitiesKHRBuilder<'a> {
        VideoEncodeIntraRefreshCapabilitiesKHRBuilder {
            inner: VideoEncodeIntraRefreshCapabilitiesKHR {
                s_type: StructureType::from_raw(1000552000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> VideoEncodeIntraRefreshCapabilitiesKHRBuilder<'a> {
    #[inline]
    pub fn intra_refresh_modes(
        mut self,
        value: VideoEncodeIntraRefreshModeFlagsKHR,
    ) -> Self {
        self.inner.intra_refresh_modes = value;
        self
    }
    #[inline]
    pub fn max_intra_refresh_cycle_duration(mut self, value: u32) -> Self {
        self.inner.max_intra_refresh_cycle_duration = value;
        self
    }
    #[inline]
    pub fn max_intra_refresh_active_reference_pictures(mut self, value: u32) -> Self {
        self.inner.max_intra_refresh_active_reference_pictures = value;
        self
    }
    #[inline]
    pub fn partition_independent_intra_refresh_regions(mut self, value: bool) -> Self {
        self.inner.partition_independent_intra_refresh_regions = value as u32;
        self
    }
    #[inline]
    pub fn non_rectangular_intra_refresh_regions(mut self, value: bool) -> Self {
        self.inner.non_rectangular_intra_refresh_regions = value as u32;
        self
    }
}
impl<'a> core::ops::Deref for VideoEncodeIntraRefreshCapabilitiesKHRBuilder<'a> {
    type Target = VideoEncodeIntraRefreshCapabilitiesKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for VideoEncodeIntraRefreshCapabilitiesKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VideoEncodeSessionIntraRefreshCreateInfoKHR`] with lifetime-tied pNext safety.
pub struct VideoEncodeSessionIntraRefreshCreateInfoKHRBuilder<'a> {
    inner: VideoEncodeSessionIntraRefreshCreateInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl VideoEncodeSessionIntraRefreshCreateInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> VideoEncodeSessionIntraRefreshCreateInfoKHRBuilder<'a> {
        VideoEncodeSessionIntraRefreshCreateInfoKHRBuilder {
            inner: VideoEncodeSessionIntraRefreshCreateInfoKHR {
                s_type: StructureType::from_raw(1000552001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> VideoEncodeSessionIntraRefreshCreateInfoKHRBuilder<'a> {
    #[inline]
    pub fn intra_refresh_mode(
        mut self,
        value: VideoEncodeIntraRefreshModeFlagBitsKHR,
    ) -> Self {
        self.inner.intra_refresh_mode = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`VideoEncodeSessionIntraRefreshCreateInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsVideoEncodeSessionIntraRefreshCreateInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for VideoEncodeSessionIntraRefreshCreateInfoKHRBuilder<'a> {
    type Target = VideoEncodeSessionIntraRefreshCreateInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for VideoEncodeSessionIntraRefreshCreateInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VideoEncodeIntraRefreshInfoKHR`] with lifetime-tied pNext safety.
pub struct VideoEncodeIntraRefreshInfoKHRBuilder<'a> {
    inner: VideoEncodeIntraRefreshInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl VideoEncodeIntraRefreshInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> VideoEncodeIntraRefreshInfoKHRBuilder<'a> {
        VideoEncodeIntraRefreshInfoKHRBuilder {
            inner: VideoEncodeIntraRefreshInfoKHR {
                s_type: StructureType::from_raw(1000552002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> VideoEncodeIntraRefreshInfoKHRBuilder<'a> {
    #[inline]
    pub fn intra_refresh_cycle_duration(mut self, value: u32) -> Self {
        self.inner.intra_refresh_cycle_duration = value;
        self
    }
    #[inline]
    pub fn intra_refresh_index(mut self, value: u32) -> Self {
        self.inner.intra_refresh_index = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`VideoEncodeIntraRefreshInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsVideoEncodeIntraRefreshInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for VideoEncodeIntraRefreshInfoKHRBuilder<'a> {
    type Target = VideoEncodeIntraRefreshInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for VideoEncodeIntraRefreshInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VideoReferenceIntraRefreshInfoKHR`] with lifetime-tied pNext safety.
pub struct VideoReferenceIntraRefreshInfoKHRBuilder<'a> {
    inner: VideoReferenceIntraRefreshInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl VideoReferenceIntraRefreshInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> VideoReferenceIntraRefreshInfoKHRBuilder<'a> {
        VideoReferenceIntraRefreshInfoKHRBuilder {
            inner: VideoReferenceIntraRefreshInfoKHR {
                s_type: StructureType::from_raw(1000552003i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> VideoReferenceIntraRefreshInfoKHRBuilder<'a> {
    #[inline]
    pub fn dirty_intra_refresh_regions(mut self, value: u32) -> Self {
        self.inner.dirty_intra_refresh_regions = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`VideoReferenceIntraRefreshInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsVideoReferenceIntraRefreshInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for VideoReferenceIntraRefreshInfoKHRBuilder<'a> {
    type Target = VideoReferenceIntraRefreshInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for VideoReferenceIntraRefreshInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceVideoEncodeIntraRefreshFeaturesKHRBuilder<'a> {
    inner: PhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceVideoEncodeIntraRefreshFeaturesKHRBuilder<'a> {
        PhysicalDeviceVideoEncodeIntraRefreshFeaturesKHRBuilder {
            inner: PhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR {
                s_type: StructureType::from_raw(1000552004i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceVideoEncodeIntraRefreshFeaturesKHRBuilder<'a> {
    #[inline]
    pub fn video_encode_intra_refresh(mut self, value: bool) -> Self {
        self.inner.video_encode_intra_refresh = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDeviceVideoEncodeIntraRefreshFeaturesKHRBuilder<'a> {
    type Target = PhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceVideoEncodeIntraRefreshFeaturesKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`CuModuleCreateInfoNVX`] with lifetime-tied pNext safety.
pub struct CuModuleCreateInfoNVXBuilder<'a> {
    inner: CuModuleCreateInfoNVX,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl CuModuleCreateInfoNVX {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> CuModuleCreateInfoNVXBuilder<'a> {
        CuModuleCreateInfoNVXBuilder {
            inner: CuModuleCreateInfoNVX {
                s_type: StructureType::from_raw(1000029000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> CuModuleCreateInfoNVXBuilder<'a> {
    #[inline]
    pub fn data(mut self, slice: &'a [core::ffi::c_void]) -> Self {
        self.inner.data_size = slice.len();
        self.inner.p_data = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`CuModuleCreateInfoNVX`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsCuModuleCreateInfoNVX>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for CuModuleCreateInfoNVXBuilder<'a> {
    type Target = CuModuleCreateInfoNVX;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for CuModuleCreateInfoNVXBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`CuModuleTexturingModeCreateInfoNVX`] with lifetime-tied pNext safety.
pub struct CuModuleTexturingModeCreateInfoNVXBuilder<'a> {
    inner: CuModuleTexturingModeCreateInfoNVX,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl CuModuleTexturingModeCreateInfoNVX {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> CuModuleTexturingModeCreateInfoNVXBuilder<'a> {
        CuModuleTexturingModeCreateInfoNVXBuilder {
            inner: CuModuleTexturingModeCreateInfoNVX {
                s_type: StructureType::from_raw(1000029004i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> CuModuleTexturingModeCreateInfoNVXBuilder<'a> {
    #[inline]
    pub fn use64bit_texturing(mut self, value: bool) -> Self {
        self.inner.use64bit_texturing = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`CuModuleTexturingModeCreateInfoNVX`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsCuModuleTexturingModeCreateInfoNVX>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for CuModuleTexturingModeCreateInfoNVXBuilder<'a> {
    type Target = CuModuleTexturingModeCreateInfoNVX;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for CuModuleTexturingModeCreateInfoNVXBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`CuFunctionCreateInfoNVX`] with lifetime-tied pNext safety.
pub struct CuFunctionCreateInfoNVXBuilder<'a> {
    inner: CuFunctionCreateInfoNVX,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl CuFunctionCreateInfoNVX {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> CuFunctionCreateInfoNVXBuilder<'a> {
        CuFunctionCreateInfoNVXBuilder {
            inner: CuFunctionCreateInfoNVX {
                s_type: StructureType::from_raw(1000029001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> CuFunctionCreateInfoNVXBuilder<'a> {
    #[inline]
    pub fn module(mut self, value: CuModuleNVX) -> Self {
        self.inner.module = value;
        self
    }
    #[inline]
    pub fn name(mut self, value: &'a core::ffi::CStr) -> Self {
        self.inner.p_name = value.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`CuFunctionCreateInfoNVX`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsCuFunctionCreateInfoNVX>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for CuFunctionCreateInfoNVXBuilder<'a> {
    type Target = CuFunctionCreateInfoNVX;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for CuFunctionCreateInfoNVXBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`CuLaunchInfoNVX`] with lifetime-tied pNext safety.
pub struct CuLaunchInfoNVXBuilder<'a> {
    inner: CuLaunchInfoNVX,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl CuLaunchInfoNVX {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> CuLaunchInfoNVXBuilder<'a> {
        CuLaunchInfoNVXBuilder {
            inner: CuLaunchInfoNVX {
                s_type: StructureType::from_raw(1000029002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> CuLaunchInfoNVXBuilder<'a> {
    #[inline]
    pub fn function(mut self, value: CuFunctionNVX) -> Self {
        self.inner.function = value;
        self
    }
    #[inline]
    pub fn grid_dim_x(mut self, value: u32) -> Self {
        self.inner.grid_dim_x = value;
        self
    }
    #[inline]
    pub fn grid_dim_y(mut self, value: u32) -> Self {
        self.inner.grid_dim_y = value;
        self
    }
    #[inline]
    pub fn grid_dim_z(mut self, value: u32) -> Self {
        self.inner.grid_dim_z = value;
        self
    }
    #[inline]
    pub fn block_dim_x(mut self, value: u32) -> Self {
        self.inner.block_dim_x = value;
        self
    }
    #[inline]
    pub fn block_dim_y(mut self, value: u32) -> Self {
        self.inner.block_dim_y = value;
        self
    }
    #[inline]
    pub fn block_dim_z(mut self, value: u32) -> Self {
        self.inner.block_dim_z = value;
        self
    }
    #[inline]
    pub fn shared_mem_bytes(mut self, value: u32) -> Self {
        self.inner.shared_mem_bytes = value;
        self
    }
    #[inline]
    pub fn param_count(mut self, value: usize) -> Self {
        self.inner.param_count = value;
        self
    }
    #[inline]
    pub fn params(mut self, value: *const *const core::ffi::c_void) -> Self {
        self.inner.p_params = value;
        self
    }
    #[inline]
    pub fn extra_count(mut self, value: usize) -> Self {
        self.inner.extra_count = value;
        self
    }
    #[inline]
    pub fn extras(mut self, value: *const *const core::ffi::c_void) -> Self {
        self.inner.p_extras = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`CuLaunchInfoNVX`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsCuLaunchInfoNVX>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for CuLaunchInfoNVXBuilder<'a> {
    type Target = CuLaunchInfoNVX;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for CuLaunchInfoNVXBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceDescriptorBufferFeaturesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceDescriptorBufferFeaturesEXTBuilder<'a> {
    inner: PhysicalDeviceDescriptorBufferFeaturesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceDescriptorBufferFeaturesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceDescriptorBufferFeaturesEXTBuilder<'a> {
        PhysicalDeviceDescriptorBufferFeaturesEXTBuilder {
            inner: PhysicalDeviceDescriptorBufferFeaturesEXT {
                s_type: StructureType::from_raw(1000316002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceDescriptorBufferFeaturesEXTBuilder<'a> {
    #[inline]
    pub fn descriptor_buffer(mut self, value: bool) -> Self {
        self.inner.descriptor_buffer = value as u32;
        self
    }
    #[inline]
    pub fn descriptor_buffer_capture_replay(mut self, value: bool) -> Self {
        self.inner.descriptor_buffer_capture_replay = value as u32;
        self
    }
    #[inline]
    pub fn descriptor_buffer_image_layout_ignored(mut self, value: bool) -> Self {
        self.inner.descriptor_buffer_image_layout_ignored = value as u32;
        self
    }
    #[inline]
    pub fn descriptor_buffer_push_descriptors(mut self, value: bool) -> Self {
        self.inner.descriptor_buffer_push_descriptors = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceDescriptorBufferFeaturesEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceDescriptorBufferFeaturesEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceDescriptorBufferFeaturesEXTBuilder<'a> {
    type Target = PhysicalDeviceDescriptorBufferFeaturesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceDescriptorBufferFeaturesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceDescriptorBufferPropertiesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceDescriptorBufferPropertiesEXTBuilder<'a> {
    inner: PhysicalDeviceDescriptorBufferPropertiesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceDescriptorBufferPropertiesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceDescriptorBufferPropertiesEXTBuilder<'a> {
        PhysicalDeviceDescriptorBufferPropertiesEXTBuilder {
            inner: PhysicalDeviceDescriptorBufferPropertiesEXT {
                s_type: StructureType::from_raw(1000316000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceDescriptorBufferPropertiesEXTBuilder<'a> {
    #[inline]
    pub fn combined_image_sampler_descriptor_single_array(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.combined_image_sampler_descriptor_single_array = value as u32;
        self
    }
    #[inline]
    pub fn bufferless_push_descriptors(mut self, value: bool) -> Self {
        self.inner.bufferless_push_descriptors = value as u32;
        self
    }
    #[inline]
    pub fn allow_sampler_image_view_post_submit_creation(mut self, value: bool) -> Self {
        self.inner.allow_sampler_image_view_post_submit_creation = value as u32;
        self
    }
    #[inline]
    pub fn descriptor_buffer_offset_alignment(mut self, value: u64) -> Self {
        self.inner.descriptor_buffer_offset_alignment = value;
        self
    }
    #[inline]
    pub fn max_descriptor_buffer_bindings(mut self, value: u32) -> Self {
        self.inner.max_descriptor_buffer_bindings = value;
        self
    }
    #[inline]
    pub fn max_resource_descriptor_buffer_bindings(mut self, value: u32) -> Self {
        self.inner.max_resource_descriptor_buffer_bindings = value;
        self
    }
    #[inline]
    pub fn max_sampler_descriptor_buffer_bindings(mut self, value: u32) -> Self {
        self.inner.max_sampler_descriptor_buffer_bindings = value;
        self
    }
    #[inline]
    pub fn max_embedded_immutable_sampler_bindings(mut self, value: u32) -> Self {
        self.inner.max_embedded_immutable_sampler_bindings = value;
        self
    }
    #[inline]
    pub fn max_embedded_immutable_samplers(mut self, value: u32) -> Self {
        self.inner.max_embedded_immutable_samplers = value;
        self
    }
    #[inline]
    pub fn buffer_capture_replay_descriptor_data_size(mut self, value: usize) -> Self {
        self.inner.buffer_capture_replay_descriptor_data_size = value;
        self
    }
    #[inline]
    pub fn image_capture_replay_descriptor_data_size(mut self, value: usize) -> Self {
        self.inner.image_capture_replay_descriptor_data_size = value;
        self
    }
    #[inline]
    pub fn image_view_capture_replay_descriptor_data_size(
        mut self,
        value: usize,
    ) -> Self {
        self.inner.image_view_capture_replay_descriptor_data_size = value;
        self
    }
    #[inline]
    pub fn sampler_capture_replay_descriptor_data_size(mut self, value: usize) -> Self {
        self.inner.sampler_capture_replay_descriptor_data_size = value;
        self
    }
    #[inline]
    pub fn acceleration_structure_capture_replay_descriptor_data_size(
        mut self,
        value: usize,
    ) -> Self {
        self.inner.acceleration_structure_capture_replay_descriptor_data_size = value;
        self
    }
    #[inline]
    pub fn sampler_descriptor_size(mut self, value: usize) -> Self {
        self.inner.sampler_descriptor_size = value;
        self
    }
    #[inline]
    pub fn combined_image_sampler_descriptor_size(mut self, value: usize) -> Self {
        self.inner.combined_image_sampler_descriptor_size = value;
        self
    }
    #[inline]
    pub fn sampled_image_descriptor_size(mut self, value: usize) -> Self {
        self.inner.sampled_image_descriptor_size = value;
        self
    }
    #[inline]
    pub fn storage_image_descriptor_size(mut self, value: usize) -> Self {
        self.inner.storage_image_descriptor_size = value;
        self
    }
    #[inline]
    pub fn uniform_texel_buffer_descriptor_size(mut self, value: usize) -> Self {
        self.inner.uniform_texel_buffer_descriptor_size = value;
        self
    }
    #[inline]
    pub fn robust_uniform_texel_buffer_descriptor_size(mut self, value: usize) -> Self {
        self.inner.robust_uniform_texel_buffer_descriptor_size = value;
        self
    }
    #[inline]
    pub fn storage_texel_buffer_descriptor_size(mut self, value: usize) -> Self {
        self.inner.storage_texel_buffer_descriptor_size = value;
        self
    }
    #[inline]
    pub fn robust_storage_texel_buffer_descriptor_size(mut self, value: usize) -> Self {
        self.inner.robust_storage_texel_buffer_descriptor_size = value;
        self
    }
    #[inline]
    pub fn uniform_buffer_descriptor_size(mut self, value: usize) -> Self {
        self.inner.uniform_buffer_descriptor_size = value;
        self
    }
    #[inline]
    pub fn robust_uniform_buffer_descriptor_size(mut self, value: usize) -> Self {
        self.inner.robust_uniform_buffer_descriptor_size = value;
        self
    }
    #[inline]
    pub fn storage_buffer_descriptor_size(mut self, value: usize) -> Self {
        self.inner.storage_buffer_descriptor_size = value;
        self
    }
    #[inline]
    pub fn robust_storage_buffer_descriptor_size(mut self, value: usize) -> Self {
        self.inner.robust_storage_buffer_descriptor_size = value;
        self
    }
    #[inline]
    pub fn input_attachment_descriptor_size(mut self, value: usize) -> Self {
        self.inner.input_attachment_descriptor_size = value;
        self
    }
    #[inline]
    pub fn acceleration_structure_descriptor_size(mut self, value: usize) -> Self {
        self.inner.acceleration_structure_descriptor_size = value;
        self
    }
    #[inline]
    pub fn max_sampler_descriptor_buffer_range(mut self, value: u64) -> Self {
        self.inner.max_sampler_descriptor_buffer_range = value;
        self
    }
    #[inline]
    pub fn max_resource_descriptor_buffer_range(mut self, value: u64) -> Self {
        self.inner.max_resource_descriptor_buffer_range = value;
        self
    }
    #[inline]
    pub fn sampler_descriptor_buffer_address_space_size(mut self, value: u64) -> Self {
        self.inner.sampler_descriptor_buffer_address_space_size = value;
        self
    }
    #[inline]
    pub fn resource_descriptor_buffer_address_space_size(mut self, value: u64) -> Self {
        self.inner.resource_descriptor_buffer_address_space_size = value;
        self
    }
    #[inline]
    pub fn descriptor_buffer_address_space_size(mut self, value: u64) -> Self {
        self.inner.descriptor_buffer_address_space_size = value;
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceDescriptorBufferPropertiesEXTBuilder<'a> {
    type Target = PhysicalDeviceDescriptorBufferPropertiesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceDescriptorBufferPropertiesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceDescriptorBufferDensityMapPropertiesEXTBuilder<'a> {
    inner: PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceDescriptorBufferDensityMapPropertiesEXTBuilder<
        'a,
    > {
        PhysicalDeviceDescriptorBufferDensityMapPropertiesEXTBuilder {
            inner: PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT {
                s_type: StructureType::from_raw(1000316001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceDescriptorBufferDensityMapPropertiesEXTBuilder<'a> {
    #[inline]
    pub fn combined_image_sampler_density_map_descriptor_size(
        mut self,
        value: usize,
    ) -> Self {
        self.inner.combined_image_sampler_density_map_descriptor_size = value;
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDeviceDescriptorBufferDensityMapPropertiesEXTBuilder<'a> {
    type Target = PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceDescriptorBufferDensityMapPropertiesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DescriptorAddressInfoEXT`] with lifetime-tied pNext safety.
pub struct DescriptorAddressInfoEXTBuilder<'a> {
    inner: DescriptorAddressInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DescriptorAddressInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> DescriptorAddressInfoEXTBuilder<'a> {
        DescriptorAddressInfoEXTBuilder {
            inner: DescriptorAddressInfoEXT {
                s_type: StructureType::from_raw(1000316003i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DescriptorAddressInfoEXTBuilder<'a> {
    #[inline]
    pub fn address(mut self, value: u64) -> Self {
        self.inner.address = value;
        self
    }
    #[inline]
    pub fn range(mut self, value: u64) -> Self {
        self.inner.range = value;
        self
    }
    #[inline]
    pub fn format(mut self, value: Format) -> Self {
        self.inner.format = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`DescriptorAddressInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsDescriptorAddressInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for DescriptorAddressInfoEXTBuilder<'a> {
    type Target = DescriptorAddressInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for DescriptorAddressInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DescriptorBufferBindingInfoEXT`] with lifetime-tied pNext safety.
pub struct DescriptorBufferBindingInfoEXTBuilder<'a> {
    inner: DescriptorBufferBindingInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DescriptorBufferBindingInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> DescriptorBufferBindingInfoEXTBuilder<'a> {
        DescriptorBufferBindingInfoEXTBuilder {
            inner: DescriptorBufferBindingInfoEXT {
                s_type: StructureType::from_raw(1000316011i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DescriptorBufferBindingInfoEXTBuilder<'a> {
    #[inline]
    pub fn address(mut self, value: u64) -> Self {
        self.inner.address = value;
        self
    }
    #[inline]
    pub fn usage(mut self, value: BufferUsageFlags) -> Self {
        self.inner.usage = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`DescriptorBufferBindingInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsDescriptorBufferBindingInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for DescriptorBufferBindingInfoEXTBuilder<'a> {
    type Target = DescriptorBufferBindingInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for DescriptorBufferBindingInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DescriptorBufferBindingPushDescriptorBufferHandleEXT`] with lifetime-tied pNext safety.
pub struct DescriptorBufferBindingPushDescriptorBufferHandleEXTBuilder<'a> {
    inner: DescriptorBufferBindingPushDescriptorBufferHandleEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DescriptorBufferBindingPushDescriptorBufferHandleEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> DescriptorBufferBindingPushDescriptorBufferHandleEXTBuilder<
        'a,
    > {
        DescriptorBufferBindingPushDescriptorBufferHandleEXTBuilder {
            inner: DescriptorBufferBindingPushDescriptorBufferHandleEXT {
                s_type: StructureType::from_raw(1000316012i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DescriptorBufferBindingPushDescriptorBufferHandleEXTBuilder<'a> {
    #[inline]
    pub fn buffer(mut self, value: Buffer) -> Self {
        self.inner.buffer = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`DescriptorBufferBindingPushDescriptorBufferHandleEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsDescriptorBufferBindingPushDescriptorBufferHandleEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref
for DescriptorBufferBindingPushDescriptorBufferHandleEXTBuilder<'a> {
    type Target = DescriptorBufferBindingPushDescriptorBufferHandleEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for DescriptorBufferBindingPushDescriptorBufferHandleEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DescriptorGetInfoEXT`] with lifetime-tied pNext safety.
pub struct DescriptorGetInfoEXTBuilder<'a> {
    inner: DescriptorGetInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DescriptorGetInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> DescriptorGetInfoEXTBuilder<'a> {
        DescriptorGetInfoEXTBuilder {
            inner: DescriptorGetInfoEXT {
                s_type: StructureType::from_raw(1000316004i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DescriptorGetInfoEXTBuilder<'a> {
    #[inline]
    pub fn r#type(mut self, value: DescriptorType) -> Self {
        self.inner.r#type = value;
        self
    }
    #[inline]
    pub fn data(mut self, value: DescriptorDataEXT) -> Self {
        self.inner.data = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`DescriptorGetInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsDescriptorGetInfoEXT>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for DescriptorGetInfoEXTBuilder<'a> {
    type Target = DescriptorGetInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for DescriptorGetInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`BufferCaptureDescriptorDataInfoEXT`] with lifetime-tied pNext safety.
pub struct BufferCaptureDescriptorDataInfoEXTBuilder<'a> {
    inner: BufferCaptureDescriptorDataInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl BufferCaptureDescriptorDataInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> BufferCaptureDescriptorDataInfoEXTBuilder<'a> {
        BufferCaptureDescriptorDataInfoEXTBuilder {
            inner: BufferCaptureDescriptorDataInfoEXT {
                s_type: StructureType::from_raw(1000316005i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> BufferCaptureDescriptorDataInfoEXTBuilder<'a> {
    #[inline]
    pub fn buffer(mut self, value: Buffer) -> Self {
        self.inner.buffer = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`BufferCaptureDescriptorDataInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsBufferCaptureDescriptorDataInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for BufferCaptureDescriptorDataInfoEXTBuilder<'a> {
    type Target = BufferCaptureDescriptorDataInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for BufferCaptureDescriptorDataInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ImageCaptureDescriptorDataInfoEXT`] with lifetime-tied pNext safety.
pub struct ImageCaptureDescriptorDataInfoEXTBuilder<'a> {
    inner: ImageCaptureDescriptorDataInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ImageCaptureDescriptorDataInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ImageCaptureDescriptorDataInfoEXTBuilder<'a> {
        ImageCaptureDescriptorDataInfoEXTBuilder {
            inner: ImageCaptureDescriptorDataInfoEXT {
                s_type: StructureType::from_raw(1000316006i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ImageCaptureDescriptorDataInfoEXTBuilder<'a> {
    #[inline]
    pub fn image(mut self, value: Image) -> Self {
        self.inner.image = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`ImageCaptureDescriptorDataInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsImageCaptureDescriptorDataInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for ImageCaptureDescriptorDataInfoEXTBuilder<'a> {
    type Target = ImageCaptureDescriptorDataInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ImageCaptureDescriptorDataInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ImageViewCaptureDescriptorDataInfoEXT`] with lifetime-tied pNext safety.
pub struct ImageViewCaptureDescriptorDataInfoEXTBuilder<'a> {
    inner: ImageViewCaptureDescriptorDataInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ImageViewCaptureDescriptorDataInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ImageViewCaptureDescriptorDataInfoEXTBuilder<'a> {
        ImageViewCaptureDescriptorDataInfoEXTBuilder {
            inner: ImageViewCaptureDescriptorDataInfoEXT {
                s_type: StructureType::from_raw(1000316007i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ImageViewCaptureDescriptorDataInfoEXTBuilder<'a> {
    #[inline]
    pub fn image_view(mut self, value: ImageView) -> Self {
        self.inner.image_view = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`ImageViewCaptureDescriptorDataInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsImageViewCaptureDescriptorDataInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for ImageViewCaptureDescriptorDataInfoEXTBuilder<'a> {
    type Target = ImageViewCaptureDescriptorDataInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ImageViewCaptureDescriptorDataInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`SamplerCaptureDescriptorDataInfoEXT`] with lifetime-tied pNext safety.
pub struct SamplerCaptureDescriptorDataInfoEXTBuilder<'a> {
    inner: SamplerCaptureDescriptorDataInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl SamplerCaptureDescriptorDataInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> SamplerCaptureDescriptorDataInfoEXTBuilder<'a> {
        SamplerCaptureDescriptorDataInfoEXTBuilder {
            inner: SamplerCaptureDescriptorDataInfoEXT {
                s_type: StructureType::from_raw(1000316008i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> SamplerCaptureDescriptorDataInfoEXTBuilder<'a> {
    #[inline]
    pub fn sampler(mut self, value: Sampler) -> Self {
        self.inner.sampler = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`SamplerCaptureDescriptorDataInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsSamplerCaptureDescriptorDataInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for SamplerCaptureDescriptorDataInfoEXTBuilder<'a> {
    type Target = SamplerCaptureDescriptorDataInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for SamplerCaptureDescriptorDataInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`AccelerationStructureCaptureDescriptorDataInfoEXT`] with lifetime-tied pNext safety.
pub struct AccelerationStructureCaptureDescriptorDataInfoEXTBuilder<'a> {
    inner: AccelerationStructureCaptureDescriptorDataInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl AccelerationStructureCaptureDescriptorDataInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> AccelerationStructureCaptureDescriptorDataInfoEXTBuilder<
        'a,
    > {
        AccelerationStructureCaptureDescriptorDataInfoEXTBuilder {
            inner: AccelerationStructureCaptureDescriptorDataInfoEXT {
                s_type: StructureType::from_raw(1000316009i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> AccelerationStructureCaptureDescriptorDataInfoEXTBuilder<'a> {
    #[inline]
    pub fn acceleration_structure(mut self, value: AccelerationStructureKHR) -> Self {
        self.inner.acceleration_structure = value;
        self
    }
    #[inline]
    pub fn acceleration_structure_nv(mut self, value: AccelerationStructureNV) -> Self {
        self.inner.acceleration_structure_nv = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`AccelerationStructureCaptureDescriptorDataInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsAccelerationStructureCaptureDescriptorDataInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref
for AccelerationStructureCaptureDescriptorDataInfoEXTBuilder<'a> {
    type Target = AccelerationStructureCaptureDescriptorDataInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for AccelerationStructureCaptureDescriptorDataInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`OpaqueCaptureDescriptorDataCreateInfoEXT`] with lifetime-tied pNext safety.
pub struct OpaqueCaptureDescriptorDataCreateInfoEXTBuilder<'a> {
    inner: OpaqueCaptureDescriptorDataCreateInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl OpaqueCaptureDescriptorDataCreateInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> OpaqueCaptureDescriptorDataCreateInfoEXTBuilder<'a> {
        OpaqueCaptureDescriptorDataCreateInfoEXTBuilder {
            inner: OpaqueCaptureDescriptorDataCreateInfoEXT {
                s_type: StructureType::from_raw(1000316010i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> OpaqueCaptureDescriptorDataCreateInfoEXTBuilder<'a> {
    #[inline]
    pub fn opaque_capture_descriptor_data(
        mut self,
        value: *const core::ffi::c_void,
    ) -> Self {
        self.inner.opaque_capture_descriptor_data = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`OpaqueCaptureDescriptorDataCreateInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsOpaqueCaptureDescriptorDataCreateInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for OpaqueCaptureDescriptorDataCreateInfoEXTBuilder<'a> {
    type Target = OpaqueCaptureDescriptorDataCreateInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for OpaqueCaptureDescriptorDataCreateInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceShaderIntegerDotProductFeatures`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceShaderIntegerDotProductFeaturesBuilder<'a> {
    inner: PhysicalDeviceShaderIntegerDotProductFeatures,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceShaderIntegerDotProductFeatures {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceShaderIntegerDotProductFeaturesBuilder<'a> {
        PhysicalDeviceShaderIntegerDotProductFeaturesBuilder {
            inner: PhysicalDeviceShaderIntegerDotProductFeatures {
                s_type: StructureType::from_raw(1000280000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceShaderIntegerDotProductFeaturesBuilder<'a> {
    #[inline]
    pub fn shader_integer_dot_product(mut self, value: bool) -> Self {
        self.inner.shader_integer_dot_product = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceShaderIntegerDotProductFeatures`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceShaderIntegerDotProductFeatures>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceShaderIntegerDotProductFeaturesBuilder<'a> {
    type Target = PhysicalDeviceShaderIntegerDotProductFeatures;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceShaderIntegerDotProductFeaturesBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceShaderIntegerDotProductProperties`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceShaderIntegerDotProductPropertiesBuilder<'a> {
    inner: PhysicalDeviceShaderIntegerDotProductProperties,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceShaderIntegerDotProductProperties {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceShaderIntegerDotProductPropertiesBuilder<'a> {
        PhysicalDeviceShaderIntegerDotProductPropertiesBuilder {
            inner: PhysicalDeviceShaderIntegerDotProductProperties {
                s_type: StructureType::from_raw(1000280001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceShaderIntegerDotProductPropertiesBuilder<'a> {
    #[inline]
    pub fn integer_dot_product8_bit_unsigned_accelerated(mut self, value: bool) -> Self {
        self.inner.integer_dot_product8_bit_unsigned_accelerated = value as u32;
        self
    }
    #[inline]
    pub fn integer_dot_product8_bit_signed_accelerated(mut self, value: bool) -> Self {
        self.inner.integer_dot_product8_bit_signed_accelerated = value as u32;
        self
    }
    #[inline]
    pub fn integer_dot_product8_bit_mixed_signedness_accelerated(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.integer_dot_product8_bit_mixed_signedness_accelerated = value as u32;
        self
    }
    #[inline]
    pub fn integer_dot_product4x8_bit_packed_unsigned_accelerated(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.integer_dot_product4x8_bit_packed_unsigned_accelerated = value as u32;
        self
    }
    #[inline]
    pub fn integer_dot_product4x8_bit_packed_signed_accelerated(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.integer_dot_product4x8_bit_packed_signed_accelerated = value as u32;
        self
    }
    #[inline]
    pub fn integer_dot_product4x8_bit_packed_mixed_signedness_accelerated(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.integer_dot_product4x8_bit_packed_mixed_signedness_accelerated = value
            as u32;
        self
    }
    #[inline]
    pub fn integer_dot_product16_bit_unsigned_accelerated(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.integer_dot_product16_bit_unsigned_accelerated = value as u32;
        self
    }
    #[inline]
    pub fn integer_dot_product16_bit_signed_accelerated(mut self, value: bool) -> Self {
        self.inner.integer_dot_product16_bit_signed_accelerated = value as u32;
        self
    }
    #[inline]
    pub fn integer_dot_product16_bit_mixed_signedness_accelerated(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.integer_dot_product16_bit_mixed_signedness_accelerated = value as u32;
        self
    }
    #[inline]
    pub fn integer_dot_product32_bit_unsigned_accelerated(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.integer_dot_product32_bit_unsigned_accelerated = value as u32;
        self
    }
    #[inline]
    pub fn integer_dot_product32_bit_signed_accelerated(mut self, value: bool) -> Self {
        self.inner.integer_dot_product32_bit_signed_accelerated = value as u32;
        self
    }
    #[inline]
    pub fn integer_dot_product32_bit_mixed_signedness_accelerated(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.integer_dot_product32_bit_mixed_signedness_accelerated = value as u32;
        self
    }
    #[inline]
    pub fn integer_dot_product64_bit_unsigned_accelerated(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.integer_dot_product64_bit_unsigned_accelerated = value as u32;
        self
    }
    #[inline]
    pub fn integer_dot_product64_bit_signed_accelerated(mut self, value: bool) -> Self {
        self.inner.integer_dot_product64_bit_signed_accelerated = value as u32;
        self
    }
    #[inline]
    pub fn integer_dot_product64_bit_mixed_signedness_accelerated(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.integer_dot_product64_bit_mixed_signedness_accelerated = value as u32;
        self
    }
    #[inline]
    pub fn integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated(
        mut self,
        value: bool,
    ) -> Self {
        self
            .inner
            .integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated = value
            as u32;
        self
    }
    #[inline]
    pub fn integer_dot_product_accumulating_saturating8_bit_signed_accelerated(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.integer_dot_product_accumulating_saturating8_bit_signed_accelerated = value
            as u32;
        self
    }
    #[inline]
    pub fn integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated(
        mut self,
        value: bool,
    ) -> Self {
        self
            .inner
            .integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated = value
            as u32;
        self
    }
    #[inline]
    pub fn integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated(
        mut self,
        value: bool,
    ) -> Self {
        self
            .inner
            .integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated = value
            as u32;
        self
    }
    #[inline]
    pub fn integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated(
        mut self,
        value: bool,
    ) -> Self {
        self
            .inner
            .integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated = value
            as u32;
        self
    }
    #[inline]
    pub fn integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated(
        mut self,
        value: bool,
    ) -> Self {
        self
            .inner
            .integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated = value
            as u32;
        self
    }
    #[inline]
    pub fn integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated(
        mut self,
        value: bool,
    ) -> Self {
        self
            .inner
            .integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated = value
            as u32;
        self
    }
    #[inline]
    pub fn integer_dot_product_accumulating_saturating16_bit_signed_accelerated(
        mut self,
        value: bool,
    ) -> Self {
        self
            .inner
            .integer_dot_product_accumulating_saturating16_bit_signed_accelerated = value
            as u32;
        self
    }
    #[inline]
    pub fn integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated(
        mut self,
        value: bool,
    ) -> Self {
        self
            .inner
            .integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated = value
            as u32;
        self
    }
    #[inline]
    pub fn integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated(
        mut self,
        value: bool,
    ) -> Self {
        self
            .inner
            .integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated = value
            as u32;
        self
    }
    #[inline]
    pub fn integer_dot_product_accumulating_saturating32_bit_signed_accelerated(
        mut self,
        value: bool,
    ) -> Self {
        self
            .inner
            .integer_dot_product_accumulating_saturating32_bit_signed_accelerated = value
            as u32;
        self
    }
    #[inline]
    pub fn integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated(
        mut self,
        value: bool,
    ) -> Self {
        self
            .inner
            .integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated = value
            as u32;
        self
    }
    #[inline]
    pub fn integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated(
        mut self,
        value: bool,
    ) -> Self {
        self
            .inner
            .integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated = value
            as u32;
        self
    }
    #[inline]
    pub fn integer_dot_product_accumulating_saturating64_bit_signed_accelerated(
        mut self,
        value: bool,
    ) -> Self {
        self
            .inner
            .integer_dot_product_accumulating_saturating64_bit_signed_accelerated = value
            as u32;
        self
    }
    #[inline]
    pub fn integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated(
        mut self,
        value: bool,
    ) -> Self {
        self
            .inner
            .integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated = value
            as u32;
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDeviceShaderIntegerDotProductPropertiesBuilder<'a> {
    type Target = PhysicalDeviceShaderIntegerDotProductProperties;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceShaderIntegerDotProductPropertiesBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceDrmPropertiesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceDrmPropertiesEXTBuilder<'a> {
    inner: PhysicalDeviceDrmPropertiesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceDrmPropertiesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceDrmPropertiesEXTBuilder<'a> {
        PhysicalDeviceDrmPropertiesEXTBuilder {
            inner: PhysicalDeviceDrmPropertiesEXT {
                s_type: StructureType::from_raw(1000353000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceDrmPropertiesEXTBuilder<'a> {
    #[inline]
    pub fn has_primary(mut self, value: bool) -> Self {
        self.inner.has_primary = value as u32;
        self
    }
    #[inline]
    pub fn has_render(mut self, value: bool) -> Self {
        self.inner.has_render = value as u32;
        self
    }
    #[inline]
    pub fn primary_major(mut self, value: i64) -> Self {
        self.inner.primary_major = value;
        self
    }
    #[inline]
    pub fn primary_minor(mut self, value: i64) -> Self {
        self.inner.primary_minor = value;
        self
    }
    #[inline]
    pub fn render_major(mut self, value: i64) -> Self {
        self.inner.render_major = value;
        self
    }
    #[inline]
    pub fn render_minor(mut self, value: i64) -> Self {
        self.inner.render_minor = value;
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceDrmPropertiesEXTBuilder<'a> {
    type Target = PhysicalDeviceDrmPropertiesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceDrmPropertiesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceFragmentShaderBarycentricFeaturesKHR`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceFragmentShaderBarycentricFeaturesKHRBuilder<'a> {
    inner: PhysicalDeviceFragmentShaderBarycentricFeaturesKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceFragmentShaderBarycentricFeaturesKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceFragmentShaderBarycentricFeaturesKHRBuilder<
        'a,
    > {
        PhysicalDeviceFragmentShaderBarycentricFeaturesKHRBuilder {
            inner: PhysicalDeviceFragmentShaderBarycentricFeaturesKHR {
                s_type: StructureType::from_raw(1000203000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceFragmentShaderBarycentricFeaturesKHRBuilder<'a> {
    #[inline]
    pub fn fragment_shader_barycentric(mut self, value: bool) -> Self {
        self.inner.fragment_shader_barycentric = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceFragmentShaderBarycentricFeaturesKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceFragmentShaderBarycentricFeaturesKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDeviceFragmentShaderBarycentricFeaturesKHRBuilder<'a> {
    type Target = PhysicalDeviceFragmentShaderBarycentricFeaturesKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceFragmentShaderBarycentricFeaturesKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceFragmentShaderBarycentricPropertiesKHR`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceFragmentShaderBarycentricPropertiesKHRBuilder<'a> {
    inner: PhysicalDeviceFragmentShaderBarycentricPropertiesKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceFragmentShaderBarycentricPropertiesKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceFragmentShaderBarycentricPropertiesKHRBuilder<
        'a,
    > {
        PhysicalDeviceFragmentShaderBarycentricPropertiesKHRBuilder {
            inner: PhysicalDeviceFragmentShaderBarycentricPropertiesKHR {
                s_type: StructureType::from_raw(1000322000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceFragmentShaderBarycentricPropertiesKHRBuilder<'a> {
    #[inline]
    pub fn tri_strip_vertex_order_independent_of_provoking_vertex(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.tri_strip_vertex_order_independent_of_provoking_vertex = value as u32;
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDeviceFragmentShaderBarycentricPropertiesKHRBuilder<'a> {
    type Target = PhysicalDeviceFragmentShaderBarycentricPropertiesKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceFragmentShaderBarycentricPropertiesKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceShaderFmaFeaturesKHR`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceShaderFmaFeaturesKHRBuilder<'a> {
    inner: PhysicalDeviceShaderFmaFeaturesKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceShaderFmaFeaturesKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceShaderFmaFeaturesKHRBuilder<'a> {
        PhysicalDeviceShaderFmaFeaturesKHRBuilder {
            inner: PhysicalDeviceShaderFmaFeaturesKHR {
                s_type: StructureType::from_raw(1000579000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceShaderFmaFeaturesKHRBuilder<'a> {
    #[inline]
    pub fn shader_fma_float16(mut self, value: bool) -> Self {
        self.inner.shader_fma_float16 = value as u32;
        self
    }
    #[inline]
    pub fn shader_fma_float32(mut self, value: bool) -> Self {
        self.inner.shader_fma_float32 = value as u32;
        self
    }
    #[inline]
    pub fn shader_fma_float64(mut self, value: bool) -> Self {
        self.inner.shader_fma_float64 = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceShaderFmaFeaturesKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceShaderFmaFeaturesKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceShaderFmaFeaturesKHRBuilder<'a> {
    type Target = PhysicalDeviceShaderFmaFeaturesKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceShaderFmaFeaturesKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceRayTracingMotionBlurFeaturesNV`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceRayTracingMotionBlurFeaturesNVBuilder<'a> {
    inner: PhysicalDeviceRayTracingMotionBlurFeaturesNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceRayTracingMotionBlurFeaturesNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceRayTracingMotionBlurFeaturesNVBuilder<'a> {
        PhysicalDeviceRayTracingMotionBlurFeaturesNVBuilder {
            inner: PhysicalDeviceRayTracingMotionBlurFeaturesNV {
                s_type: StructureType::from_raw(1000327001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceRayTracingMotionBlurFeaturesNVBuilder<'a> {
    #[inline]
    pub fn ray_tracing_motion_blur(mut self, value: bool) -> Self {
        self.inner.ray_tracing_motion_blur = value as u32;
        self
    }
    #[inline]
    pub fn ray_tracing_motion_blur_pipeline_trace_rays_indirect(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.ray_tracing_motion_blur_pipeline_trace_rays_indirect = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceRayTracingMotionBlurFeaturesNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceRayTracingMotionBlurFeaturesNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceRayTracingMotionBlurFeaturesNVBuilder<'a> {
    type Target = PhysicalDeviceRayTracingMotionBlurFeaturesNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceRayTracingMotionBlurFeaturesNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceRayTracingValidationFeaturesNV`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceRayTracingValidationFeaturesNVBuilder<'a> {
    inner: PhysicalDeviceRayTracingValidationFeaturesNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceRayTracingValidationFeaturesNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceRayTracingValidationFeaturesNVBuilder<'a> {
        PhysicalDeviceRayTracingValidationFeaturesNVBuilder {
            inner: PhysicalDeviceRayTracingValidationFeaturesNV {
                s_type: StructureType::from_raw(1000568000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceRayTracingValidationFeaturesNVBuilder<'a> {
    #[inline]
    pub fn ray_tracing_validation(mut self, value: bool) -> Self {
        self.inner.ray_tracing_validation = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceRayTracingValidationFeaturesNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceRayTracingValidationFeaturesNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceRayTracingValidationFeaturesNVBuilder<'a> {
    type Target = PhysicalDeviceRayTracingValidationFeaturesNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceRayTracingValidationFeaturesNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceRayTracingLinearSweptSpheresFeaturesNVBuilder<'a> {
    inner: PhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceRayTracingLinearSweptSpheresFeaturesNVBuilder<
        'a,
    > {
        PhysicalDeviceRayTracingLinearSweptSpheresFeaturesNVBuilder {
            inner: PhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV {
                s_type: StructureType::from_raw(1000429008i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceRayTracingLinearSweptSpheresFeaturesNVBuilder<'a> {
    #[inline]
    pub fn spheres(mut self, value: bool) -> Self {
        self.inner.spheres = value as u32;
        self
    }
    #[inline]
    pub fn linear_swept_spheres(mut self, value: bool) -> Self {
        self.inner.linear_swept_spheres = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDeviceRayTracingLinearSweptSpheresFeaturesNVBuilder<'a> {
    type Target = PhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceRayTracingLinearSweptSpheresFeaturesNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`AccelerationStructureGeometryMotionTrianglesDataNV`] with lifetime-tied pNext safety.
pub struct AccelerationStructureGeometryMotionTrianglesDataNVBuilder<'a> {
    inner: AccelerationStructureGeometryMotionTrianglesDataNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl AccelerationStructureGeometryMotionTrianglesDataNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> AccelerationStructureGeometryMotionTrianglesDataNVBuilder<
        'a,
    > {
        AccelerationStructureGeometryMotionTrianglesDataNVBuilder {
            inner: AccelerationStructureGeometryMotionTrianglesDataNV {
                s_type: StructureType::from_raw(1000327000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> AccelerationStructureGeometryMotionTrianglesDataNVBuilder<'a> {
    #[inline]
    pub fn vertex_data(mut self, value: DeviceOrHostAddressConstKHR) -> Self {
        self.inner.vertex_data = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`AccelerationStructureGeometryMotionTrianglesDataNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsAccelerationStructureGeometryMotionTrianglesDataNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref
for AccelerationStructureGeometryMotionTrianglesDataNVBuilder<'a> {
    type Target = AccelerationStructureGeometryMotionTrianglesDataNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for AccelerationStructureGeometryMotionTrianglesDataNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`AccelerationStructureMotionInfoNV`] with lifetime-tied pNext safety.
pub struct AccelerationStructureMotionInfoNVBuilder<'a> {
    inner: AccelerationStructureMotionInfoNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl AccelerationStructureMotionInfoNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> AccelerationStructureMotionInfoNVBuilder<'a> {
        AccelerationStructureMotionInfoNVBuilder {
            inner: AccelerationStructureMotionInfoNV {
                s_type: StructureType::from_raw(1000327002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> AccelerationStructureMotionInfoNVBuilder<'a> {
    #[inline]
    pub fn max_instances(mut self, value: u32) -> Self {
        self.inner.max_instances = value;
        self
    }
    #[inline]
    pub fn flags(mut self, value: AccelerationStructureMotionInfoFlagsNV) -> Self {
        self.inner.flags = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`AccelerationStructureMotionInfoNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsAccelerationStructureMotionInfoNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for AccelerationStructureMotionInfoNVBuilder<'a> {
    type Target = AccelerationStructureMotionInfoNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for AccelerationStructureMotionInfoNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`SRTDataNV`].
pub struct SRTDataNVBuilder {
    inner: SRTDataNV,
}
impl SRTDataNV {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> SRTDataNVBuilder {
        SRTDataNVBuilder {
            inner: SRTDataNV { ..Default::default() },
        }
    }
}
impl SRTDataNVBuilder {
    #[inline]
    pub fn sx(mut self, value: f32) -> Self {
        self.inner.sx = value;
        self
    }
    #[inline]
    pub fn a(mut self, value: f32) -> Self {
        self.inner.a = value;
        self
    }
    #[inline]
    pub fn b(mut self, value: f32) -> Self {
        self.inner.b = value;
        self
    }
    #[inline]
    pub fn pvx(mut self, value: f32) -> Self {
        self.inner.pvx = value;
        self
    }
    #[inline]
    pub fn sy(mut self, value: f32) -> Self {
        self.inner.sy = value;
        self
    }
    #[inline]
    pub fn c(mut self, value: f32) -> Self {
        self.inner.c = value;
        self
    }
    #[inline]
    pub fn pvy(mut self, value: f32) -> Self {
        self.inner.pvy = value;
        self
    }
    #[inline]
    pub fn sz(mut self, value: f32) -> Self {
        self.inner.sz = value;
        self
    }
    #[inline]
    pub fn pvz(mut self, value: f32) -> Self {
        self.inner.pvz = value;
        self
    }
    #[inline]
    pub fn qx(mut self, value: f32) -> Self {
        self.inner.qx = value;
        self
    }
    #[inline]
    pub fn qy(mut self, value: f32) -> Self {
        self.inner.qy = value;
        self
    }
    #[inline]
    pub fn qz(mut self, value: f32) -> Self {
        self.inner.qz = value;
        self
    }
    #[inline]
    pub fn qw(mut self, value: f32) -> Self {
        self.inner.qw = value;
        self
    }
    #[inline]
    pub fn tx(mut self, value: f32) -> Self {
        self.inner.tx = value;
        self
    }
    #[inline]
    pub fn ty(mut self, value: f32) -> Self {
        self.inner.ty = value;
        self
    }
    #[inline]
    pub fn tz(mut self, value: f32) -> Self {
        self.inner.tz = value;
        self
    }
}
impl core::ops::Deref for SRTDataNVBuilder {
    type Target = SRTDataNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for SRTDataNVBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`AccelerationStructureMotionInstanceNV`].
pub struct AccelerationStructureMotionInstanceNVBuilder {
    inner: AccelerationStructureMotionInstanceNV,
}
impl AccelerationStructureMotionInstanceNV {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> AccelerationStructureMotionInstanceNVBuilder {
        AccelerationStructureMotionInstanceNVBuilder {
            inner: AccelerationStructureMotionInstanceNV {
                ..Default::default()
            },
        }
    }
}
impl AccelerationStructureMotionInstanceNVBuilder {
    #[inline]
    pub fn r#type(mut self, value: AccelerationStructureMotionInstanceTypeNV) -> Self {
        self.inner.r#type = value;
        self
    }
    #[inline]
    pub fn flags(mut self, value: AccelerationStructureMotionInstanceFlagsNV) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn data(mut self, value: AccelerationStructureMotionInstanceDataNV) -> Self {
        self.inner.data = value;
        self
    }
}
impl core::ops::Deref for AccelerationStructureMotionInstanceNVBuilder {
    type Target = AccelerationStructureMotionInstanceNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for AccelerationStructureMotionInstanceNVBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`MemoryGetRemoteAddressInfoNV`] with lifetime-tied pNext safety.
pub struct MemoryGetRemoteAddressInfoNVBuilder<'a> {
    inner: MemoryGetRemoteAddressInfoNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl MemoryGetRemoteAddressInfoNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> MemoryGetRemoteAddressInfoNVBuilder<'a> {
        MemoryGetRemoteAddressInfoNVBuilder {
            inner: MemoryGetRemoteAddressInfoNV {
                s_type: StructureType::from_raw(1000371000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> MemoryGetRemoteAddressInfoNVBuilder<'a> {
    #[inline]
    pub fn memory(mut self, value: DeviceMemory) -> Self {
        self.inner.memory = value;
        self
    }
    #[inline]
    pub fn handle_type(mut self, value: ExternalMemoryHandleTypeFlagBits) -> Self {
        self.inner.handle_type = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`MemoryGetRemoteAddressInfoNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsMemoryGetRemoteAddressInfoNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for MemoryGetRemoteAddressInfoNVBuilder<'a> {
    type Target = MemoryGetRemoteAddressInfoNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for MemoryGetRemoteAddressInfoNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ImportMemoryBufferCollectionFUCHSIA`] with lifetime-tied pNext safety.
pub struct ImportMemoryBufferCollectionFUCHSIABuilder<'a> {
    inner: ImportMemoryBufferCollectionFUCHSIA,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ImportMemoryBufferCollectionFUCHSIA {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ImportMemoryBufferCollectionFUCHSIABuilder<'a> {
        ImportMemoryBufferCollectionFUCHSIABuilder {
            inner: ImportMemoryBufferCollectionFUCHSIA {
                s_type: StructureType::from_raw(1000366001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ImportMemoryBufferCollectionFUCHSIABuilder<'a> {
    #[inline]
    pub fn collection(mut self, value: BufferCollectionFUCHSIA) -> Self {
        self.inner.collection = value;
        self
    }
    #[inline]
    pub fn index(mut self, value: u32) -> Self {
        self.inner.index = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`ImportMemoryBufferCollectionFUCHSIA`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsImportMemoryBufferCollectionFUCHSIA>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for ImportMemoryBufferCollectionFUCHSIABuilder<'a> {
    type Target = ImportMemoryBufferCollectionFUCHSIA;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ImportMemoryBufferCollectionFUCHSIABuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`BufferCollectionImageCreateInfoFUCHSIA`] with lifetime-tied pNext safety.
pub struct BufferCollectionImageCreateInfoFUCHSIABuilder<'a> {
    inner: BufferCollectionImageCreateInfoFUCHSIA,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl BufferCollectionImageCreateInfoFUCHSIA {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> BufferCollectionImageCreateInfoFUCHSIABuilder<'a> {
        BufferCollectionImageCreateInfoFUCHSIABuilder {
            inner: BufferCollectionImageCreateInfoFUCHSIA {
                s_type: StructureType::from_raw(1000366002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> BufferCollectionImageCreateInfoFUCHSIABuilder<'a> {
    #[inline]
    pub fn collection(mut self, value: BufferCollectionFUCHSIA) -> Self {
        self.inner.collection = value;
        self
    }
    #[inline]
    pub fn index(mut self, value: u32) -> Self {
        self.inner.index = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`BufferCollectionImageCreateInfoFUCHSIA`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsBufferCollectionImageCreateInfoFUCHSIA>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for BufferCollectionImageCreateInfoFUCHSIABuilder<'a> {
    type Target = BufferCollectionImageCreateInfoFUCHSIA;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for BufferCollectionImageCreateInfoFUCHSIABuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`BufferCollectionBufferCreateInfoFUCHSIA`] with lifetime-tied pNext safety.
pub struct BufferCollectionBufferCreateInfoFUCHSIABuilder<'a> {
    inner: BufferCollectionBufferCreateInfoFUCHSIA,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl BufferCollectionBufferCreateInfoFUCHSIA {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> BufferCollectionBufferCreateInfoFUCHSIABuilder<'a> {
        BufferCollectionBufferCreateInfoFUCHSIABuilder {
            inner: BufferCollectionBufferCreateInfoFUCHSIA {
                s_type: StructureType::from_raw(1000366005i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> BufferCollectionBufferCreateInfoFUCHSIABuilder<'a> {
    #[inline]
    pub fn collection(mut self, value: BufferCollectionFUCHSIA) -> Self {
        self.inner.collection = value;
        self
    }
    #[inline]
    pub fn index(mut self, value: u32) -> Self {
        self.inner.index = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`BufferCollectionBufferCreateInfoFUCHSIA`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsBufferCollectionBufferCreateInfoFUCHSIA>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for BufferCollectionBufferCreateInfoFUCHSIABuilder<'a> {
    type Target = BufferCollectionBufferCreateInfoFUCHSIA;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for BufferCollectionBufferCreateInfoFUCHSIABuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`BufferCollectionCreateInfoFUCHSIA`] with lifetime-tied pNext safety.
pub struct BufferCollectionCreateInfoFUCHSIABuilder<'a> {
    inner: BufferCollectionCreateInfoFUCHSIA,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl BufferCollectionCreateInfoFUCHSIA {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> BufferCollectionCreateInfoFUCHSIABuilder<'a> {
        BufferCollectionCreateInfoFUCHSIABuilder {
            inner: BufferCollectionCreateInfoFUCHSIA {
                s_type: StructureType::from_raw(1000366000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> BufferCollectionCreateInfoFUCHSIABuilder<'a> {
    #[inline]
    pub fn collection_token(mut self, value: u32) -> Self {
        self.inner.collection_token = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`BufferCollectionCreateInfoFUCHSIA`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsBufferCollectionCreateInfoFUCHSIA>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for BufferCollectionCreateInfoFUCHSIABuilder<'a> {
    type Target = BufferCollectionCreateInfoFUCHSIA;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for BufferCollectionCreateInfoFUCHSIABuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`BufferCollectionPropertiesFUCHSIA`] with lifetime-tied pNext safety.
pub struct BufferCollectionPropertiesFUCHSIABuilder<'a> {
    inner: BufferCollectionPropertiesFUCHSIA,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl BufferCollectionPropertiesFUCHSIA {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> BufferCollectionPropertiesFUCHSIABuilder<'a> {
        BufferCollectionPropertiesFUCHSIABuilder {
            inner: BufferCollectionPropertiesFUCHSIA {
                s_type: StructureType::from_raw(1000366003i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> BufferCollectionPropertiesFUCHSIABuilder<'a> {
    #[inline]
    pub fn memory_type_bits(mut self, value: u32) -> Self {
        self.inner.memory_type_bits = value;
        self
    }
    #[inline]
    pub fn buffer_count(mut self, value: u32) -> Self {
        self.inner.buffer_count = value;
        self
    }
    #[inline]
    pub fn create_info_index(mut self, value: u32) -> Self {
        self.inner.create_info_index = value;
        self
    }
    #[inline]
    pub fn sysmem_pixel_format(mut self, value: u64) -> Self {
        self.inner.sysmem_pixel_format = value;
        self
    }
    #[inline]
    pub fn format_features(mut self, value: FormatFeatureFlags) -> Self {
        self.inner.format_features = value;
        self
    }
    #[inline]
    pub fn sysmem_color_space_index(mut self, value: SysmemColorSpaceFUCHSIA) -> Self {
        self.inner.sysmem_color_space_index = value;
        self
    }
    #[inline]
    pub fn sampler_ycbcr_conversion_components(
        mut self,
        value: ComponentMapping,
    ) -> Self {
        self.inner.sampler_ycbcr_conversion_components = value;
        self
    }
    #[inline]
    pub fn suggested_ycbcr_model(mut self, value: SamplerYcbcrModelConversion) -> Self {
        self.inner.suggested_ycbcr_model = value;
        self
    }
    #[inline]
    pub fn suggested_ycbcr_range(mut self, value: SamplerYcbcrRange) -> Self {
        self.inner.suggested_ycbcr_range = value;
        self
    }
    #[inline]
    pub fn suggested_x_chroma_offset(mut self, value: ChromaLocation) -> Self {
        self.inner.suggested_x_chroma_offset = value;
        self
    }
    #[inline]
    pub fn suggested_y_chroma_offset(mut self, value: ChromaLocation) -> Self {
        self.inner.suggested_y_chroma_offset = value;
        self
    }
}
impl<'a> core::ops::Deref for BufferCollectionPropertiesFUCHSIABuilder<'a> {
    type Target = BufferCollectionPropertiesFUCHSIA;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for BufferCollectionPropertiesFUCHSIABuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`BufferConstraintsInfoFUCHSIA`] with lifetime-tied pNext safety.
pub struct BufferConstraintsInfoFUCHSIABuilder<'a> {
    inner: BufferConstraintsInfoFUCHSIA,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl BufferConstraintsInfoFUCHSIA {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> BufferConstraintsInfoFUCHSIABuilder<'a> {
        BufferConstraintsInfoFUCHSIABuilder {
            inner: BufferConstraintsInfoFUCHSIA {
                s_type: StructureType::from_raw(1000366004i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> BufferConstraintsInfoFUCHSIABuilder<'a> {
    #[inline]
    pub fn create_info(mut self, value: BufferCreateInfo) -> Self {
        self.inner.create_info = value;
        self
    }
    #[inline]
    pub fn required_format_features(mut self, value: FormatFeatureFlags) -> Self {
        self.inner.required_format_features = value;
        self
    }
    #[inline]
    pub fn buffer_collection_constraints(
        mut self,
        value: BufferCollectionConstraintsInfoFUCHSIA,
    ) -> Self {
        self.inner.buffer_collection_constraints = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`BufferConstraintsInfoFUCHSIA`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsBufferConstraintsInfoFUCHSIA>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for BufferConstraintsInfoFUCHSIABuilder<'a> {
    type Target = BufferConstraintsInfoFUCHSIA;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for BufferConstraintsInfoFUCHSIABuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`SysmemColorSpaceFUCHSIA`] with lifetime-tied pNext safety.
pub struct SysmemColorSpaceFUCHSIABuilder<'a> {
    inner: SysmemColorSpaceFUCHSIA,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl SysmemColorSpaceFUCHSIA {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> SysmemColorSpaceFUCHSIABuilder<'a> {
        SysmemColorSpaceFUCHSIABuilder {
            inner: SysmemColorSpaceFUCHSIA {
                s_type: StructureType::from_raw(1000366008i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> SysmemColorSpaceFUCHSIABuilder<'a> {
    #[inline]
    pub fn color_space(mut self, value: u32) -> Self {
        self.inner.color_space = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`SysmemColorSpaceFUCHSIA`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsSysmemColorSpaceFUCHSIA>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for SysmemColorSpaceFUCHSIABuilder<'a> {
    type Target = SysmemColorSpaceFUCHSIA;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for SysmemColorSpaceFUCHSIABuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ImageFormatConstraintsInfoFUCHSIA`] with lifetime-tied pNext safety.
pub struct ImageFormatConstraintsInfoFUCHSIABuilder<'a> {
    inner: ImageFormatConstraintsInfoFUCHSIA,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ImageFormatConstraintsInfoFUCHSIA {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ImageFormatConstraintsInfoFUCHSIABuilder<'a> {
        ImageFormatConstraintsInfoFUCHSIABuilder {
            inner: ImageFormatConstraintsInfoFUCHSIA {
                s_type: StructureType::from_raw(1000366007i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ImageFormatConstraintsInfoFUCHSIABuilder<'a> {
    #[inline]
    pub fn image_create_info(mut self, value: ImageCreateInfo) -> Self {
        self.inner.image_create_info = value;
        self
    }
    #[inline]
    pub fn required_format_features(mut self, value: FormatFeatureFlags) -> Self {
        self.inner.required_format_features = value;
        self
    }
    #[inline]
    pub fn flags(mut self, value: ImageFormatConstraintsFlagsFUCHSIA) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn sysmem_pixel_format(mut self, value: u64) -> Self {
        self.inner.sysmem_pixel_format = value;
        self
    }
    #[inline]
    pub fn color_spaces(mut self, slice: &'a [SysmemColorSpaceFUCHSIA]) -> Self {
        self.inner.color_space_count = slice.len() as u32;
        self.inner.p_color_spaces = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`ImageFormatConstraintsInfoFUCHSIA`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsImageFormatConstraintsInfoFUCHSIA>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for ImageFormatConstraintsInfoFUCHSIABuilder<'a> {
    type Target = ImageFormatConstraintsInfoFUCHSIA;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ImageFormatConstraintsInfoFUCHSIABuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ImageConstraintsInfoFUCHSIA`] with lifetime-tied pNext safety.
pub struct ImageConstraintsInfoFUCHSIABuilder<'a> {
    inner: ImageConstraintsInfoFUCHSIA,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ImageConstraintsInfoFUCHSIA {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ImageConstraintsInfoFUCHSIABuilder<'a> {
        ImageConstraintsInfoFUCHSIABuilder {
            inner: ImageConstraintsInfoFUCHSIA {
                s_type: StructureType::from_raw(1000366006i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ImageConstraintsInfoFUCHSIABuilder<'a> {
    #[inline]
    pub fn format_constraints(
        mut self,
        slice: &'a [ImageFormatConstraintsInfoFUCHSIA],
    ) -> Self {
        self.inner.format_constraints_count = slice.len() as u32;
        self.inner.p_format_constraints = slice.as_ptr();
        self
    }
    #[inline]
    pub fn buffer_collection_constraints(
        mut self,
        value: BufferCollectionConstraintsInfoFUCHSIA,
    ) -> Self {
        self.inner.buffer_collection_constraints = value;
        self
    }
    #[inline]
    pub fn flags(mut self, value: ImageConstraintsInfoFlagsFUCHSIA) -> Self {
        self.inner.flags = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`ImageConstraintsInfoFUCHSIA`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsImageConstraintsInfoFUCHSIA>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for ImageConstraintsInfoFUCHSIABuilder<'a> {
    type Target = ImageConstraintsInfoFUCHSIA;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ImageConstraintsInfoFUCHSIABuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`BufferCollectionConstraintsInfoFUCHSIA`] with lifetime-tied pNext safety.
pub struct BufferCollectionConstraintsInfoFUCHSIABuilder<'a> {
    inner: BufferCollectionConstraintsInfoFUCHSIA,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl BufferCollectionConstraintsInfoFUCHSIA {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> BufferCollectionConstraintsInfoFUCHSIABuilder<'a> {
        BufferCollectionConstraintsInfoFUCHSIABuilder {
            inner: BufferCollectionConstraintsInfoFUCHSIA {
                s_type: StructureType::from_raw(1000366009i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> BufferCollectionConstraintsInfoFUCHSIABuilder<'a> {
    #[inline]
    pub fn min_buffer_count(mut self, value: u32) -> Self {
        self.inner.min_buffer_count = value;
        self
    }
    #[inline]
    pub fn max_buffer_count(mut self, value: u32) -> Self {
        self.inner.max_buffer_count = value;
        self
    }
    #[inline]
    pub fn min_buffer_count_for_camping(mut self, value: u32) -> Self {
        self.inner.min_buffer_count_for_camping = value;
        self
    }
    #[inline]
    pub fn min_buffer_count_for_dedicated_slack(mut self, value: u32) -> Self {
        self.inner.min_buffer_count_for_dedicated_slack = value;
        self
    }
    #[inline]
    pub fn min_buffer_count_for_shared_slack(mut self, value: u32) -> Self {
        self.inner.min_buffer_count_for_shared_slack = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`BufferCollectionConstraintsInfoFUCHSIA`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsBufferCollectionConstraintsInfoFUCHSIA>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for BufferCollectionConstraintsInfoFUCHSIABuilder<'a> {
    type Target = BufferCollectionConstraintsInfoFUCHSIA;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for BufferCollectionConstraintsInfoFUCHSIABuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`CudaModuleCreateInfoNV`] with lifetime-tied pNext safety.
pub struct CudaModuleCreateInfoNVBuilder<'a> {
    inner: CudaModuleCreateInfoNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl CudaModuleCreateInfoNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> CudaModuleCreateInfoNVBuilder<'a> {
        CudaModuleCreateInfoNVBuilder {
            inner: CudaModuleCreateInfoNV {
                s_type: StructureType::from_raw(1000307000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> CudaModuleCreateInfoNVBuilder<'a> {
    #[inline]
    pub fn data(mut self, slice: &'a [core::ffi::c_void]) -> Self {
        self.inner.data_size = slice.len();
        self.inner.p_data = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`CudaModuleCreateInfoNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsCudaModuleCreateInfoNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for CudaModuleCreateInfoNVBuilder<'a> {
    type Target = CudaModuleCreateInfoNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for CudaModuleCreateInfoNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`CudaFunctionCreateInfoNV`] with lifetime-tied pNext safety.
pub struct CudaFunctionCreateInfoNVBuilder<'a> {
    inner: CudaFunctionCreateInfoNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl CudaFunctionCreateInfoNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> CudaFunctionCreateInfoNVBuilder<'a> {
        CudaFunctionCreateInfoNVBuilder {
            inner: CudaFunctionCreateInfoNV {
                s_type: StructureType::from_raw(1000307001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> CudaFunctionCreateInfoNVBuilder<'a> {
    #[inline]
    pub fn module(mut self, value: CudaModuleNV) -> Self {
        self.inner.module = value;
        self
    }
    #[inline]
    pub fn name(mut self, value: &'a core::ffi::CStr) -> Self {
        self.inner.p_name = value.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`CudaFunctionCreateInfoNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsCudaFunctionCreateInfoNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for CudaFunctionCreateInfoNVBuilder<'a> {
    type Target = CudaFunctionCreateInfoNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for CudaFunctionCreateInfoNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`CudaLaunchInfoNV`] with lifetime-tied pNext safety.
pub struct CudaLaunchInfoNVBuilder<'a> {
    inner: CudaLaunchInfoNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl CudaLaunchInfoNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> CudaLaunchInfoNVBuilder<'a> {
        CudaLaunchInfoNVBuilder {
            inner: CudaLaunchInfoNV {
                s_type: StructureType::from_raw(1000307002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> CudaLaunchInfoNVBuilder<'a> {
    #[inline]
    pub fn function(mut self, value: CudaFunctionNV) -> Self {
        self.inner.function = value;
        self
    }
    #[inline]
    pub fn grid_dim_x(mut self, value: u32) -> Self {
        self.inner.grid_dim_x = value;
        self
    }
    #[inline]
    pub fn grid_dim_y(mut self, value: u32) -> Self {
        self.inner.grid_dim_y = value;
        self
    }
    #[inline]
    pub fn grid_dim_z(mut self, value: u32) -> Self {
        self.inner.grid_dim_z = value;
        self
    }
    #[inline]
    pub fn block_dim_x(mut self, value: u32) -> Self {
        self.inner.block_dim_x = value;
        self
    }
    #[inline]
    pub fn block_dim_y(mut self, value: u32) -> Self {
        self.inner.block_dim_y = value;
        self
    }
    #[inline]
    pub fn block_dim_z(mut self, value: u32) -> Self {
        self.inner.block_dim_z = value;
        self
    }
    #[inline]
    pub fn shared_mem_bytes(mut self, value: u32) -> Self {
        self.inner.shared_mem_bytes = value;
        self
    }
    #[inline]
    pub fn param_count(mut self, value: usize) -> Self {
        self.inner.param_count = value;
        self
    }
    #[inline]
    pub fn params(mut self, value: *const *const core::ffi::c_void) -> Self {
        self.inner.p_params = value;
        self
    }
    #[inline]
    pub fn extra_count(mut self, value: usize) -> Self {
        self.inner.extra_count = value;
        self
    }
    #[inline]
    pub fn extras(mut self, value: *const *const core::ffi::c_void) -> Self {
        self.inner.p_extras = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`CudaLaunchInfoNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsCudaLaunchInfoNV>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for CudaLaunchInfoNVBuilder<'a> {
    type Target = CudaLaunchInfoNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for CudaLaunchInfoNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceRGBA10X6FormatsFeaturesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceRGBA10X6FormatsFeaturesEXTBuilder<'a> {
    inner: PhysicalDeviceRGBA10X6FormatsFeaturesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceRGBA10X6FormatsFeaturesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceRGBA10X6FormatsFeaturesEXTBuilder<'a> {
        PhysicalDeviceRGBA10X6FormatsFeaturesEXTBuilder {
            inner: PhysicalDeviceRGBA10X6FormatsFeaturesEXT {
                s_type: StructureType::from_raw(1000344000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceRGBA10X6FormatsFeaturesEXTBuilder<'a> {
    #[inline]
    pub fn format_rgba10x6_without_y_cb_cr_sampler(mut self, value: bool) -> Self {
        self.inner.format_rgba10x6_without_y_cb_cr_sampler = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceRGBA10X6FormatsFeaturesEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceRGBA10X6FormatsFeaturesEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceRGBA10X6FormatsFeaturesEXTBuilder<'a> {
    type Target = PhysicalDeviceRGBA10X6FormatsFeaturesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceRGBA10X6FormatsFeaturesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`FormatProperties3`] with lifetime-tied pNext safety.
pub struct FormatProperties3Builder<'a> {
    inner: FormatProperties3,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl FormatProperties3 {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> FormatProperties3Builder<'a> {
        FormatProperties3Builder {
            inner: FormatProperties3 {
                s_type: StructureType::from_raw(1000360000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> FormatProperties3Builder<'a> {
    #[inline]
    pub fn linear_tiling_features(mut self, value: FormatFeatureFlags2) -> Self {
        self.inner.linear_tiling_features = value;
        self
    }
    #[inline]
    pub fn optimal_tiling_features(mut self, value: FormatFeatureFlags2) -> Self {
        self.inner.optimal_tiling_features = value;
        self
    }
    #[inline]
    pub fn buffer_features(mut self, value: FormatFeatureFlags2) -> Self {
        self.inner.buffer_features = value;
        self
    }
}
impl<'a> core::ops::Deref for FormatProperties3Builder<'a> {
    type Target = FormatProperties3;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for FormatProperties3Builder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DrmFormatModifierPropertiesList2EXT`] with lifetime-tied pNext safety.
pub struct DrmFormatModifierPropertiesList2EXTBuilder<'a> {
    inner: DrmFormatModifierPropertiesList2EXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DrmFormatModifierPropertiesList2EXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> DrmFormatModifierPropertiesList2EXTBuilder<'a> {
        DrmFormatModifierPropertiesList2EXTBuilder {
            inner: DrmFormatModifierPropertiesList2EXT {
                s_type: StructureType::from_raw(1000158006i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DrmFormatModifierPropertiesList2EXTBuilder<'a> {
    #[inline]
    pub fn drm_format_modifier_count(mut self, value: u32) -> Self {
        self.inner.drm_format_modifier_count = value;
        self
    }
    #[inline]
    pub fn drm_format_modifier_properties(
        mut self,
        slice: &'a mut [DrmFormatModifierProperties2EXT],
    ) -> Self {
        self.inner.drm_format_modifier_count = slice.len() as u32;
        self.inner.p_drm_format_modifier_properties = slice.as_mut_ptr();
        self
    }
}
impl<'a> core::ops::Deref for DrmFormatModifierPropertiesList2EXTBuilder<'a> {
    type Target = DrmFormatModifierPropertiesList2EXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for DrmFormatModifierPropertiesList2EXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DrmFormatModifierProperties2EXT`].
pub struct DrmFormatModifierProperties2EXTBuilder {
    inner: DrmFormatModifierProperties2EXT,
}
impl DrmFormatModifierProperties2EXT {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> DrmFormatModifierProperties2EXTBuilder {
        DrmFormatModifierProperties2EXTBuilder {
            inner: DrmFormatModifierProperties2EXT {
                ..Default::default()
            },
        }
    }
}
impl DrmFormatModifierProperties2EXTBuilder {
    #[inline]
    pub fn drm_format_modifier(mut self, value: u64) -> Self {
        self.inner.drm_format_modifier = value;
        self
    }
    #[inline]
    pub fn drm_format_modifier_plane_count(mut self, value: u32) -> Self {
        self.inner.drm_format_modifier_plane_count = value;
        self
    }
    #[inline]
    pub fn drm_format_modifier_tiling_features(
        mut self,
        value: FormatFeatureFlags2,
    ) -> Self {
        self.inner.drm_format_modifier_tiling_features = value;
        self
    }
}
impl core::ops::Deref for DrmFormatModifierProperties2EXTBuilder {
    type Target = DrmFormatModifierProperties2EXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for DrmFormatModifierProperties2EXTBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`AndroidHardwareBufferFormatProperties2ANDROID`] with lifetime-tied pNext safety.
pub struct AndroidHardwareBufferFormatProperties2ANDROIDBuilder<'a> {
    inner: AndroidHardwareBufferFormatProperties2ANDROID,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl AndroidHardwareBufferFormatProperties2ANDROID {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> AndroidHardwareBufferFormatProperties2ANDROIDBuilder<'a> {
        AndroidHardwareBufferFormatProperties2ANDROIDBuilder {
            inner: AndroidHardwareBufferFormatProperties2ANDROID {
                s_type: StructureType::from_raw(1000129006i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> AndroidHardwareBufferFormatProperties2ANDROIDBuilder<'a> {
    #[inline]
    pub fn format(mut self, value: Format) -> Self {
        self.inner.format = value;
        self
    }
    #[inline]
    pub fn external_format(mut self, value: u64) -> Self {
        self.inner.external_format = value;
        self
    }
    #[inline]
    pub fn format_features(mut self, value: FormatFeatureFlags2) -> Self {
        self.inner.format_features = value;
        self
    }
    #[inline]
    pub fn sampler_ycbcr_conversion_components(
        mut self,
        value: ComponentMapping,
    ) -> Self {
        self.inner.sampler_ycbcr_conversion_components = value;
        self
    }
    #[inline]
    pub fn suggested_ycbcr_model(mut self, value: SamplerYcbcrModelConversion) -> Self {
        self.inner.suggested_ycbcr_model = value;
        self
    }
    #[inline]
    pub fn suggested_ycbcr_range(mut self, value: SamplerYcbcrRange) -> Self {
        self.inner.suggested_ycbcr_range = value;
        self
    }
    #[inline]
    pub fn suggested_x_chroma_offset(mut self, value: ChromaLocation) -> Self {
        self.inner.suggested_x_chroma_offset = value;
        self
    }
    #[inline]
    pub fn suggested_y_chroma_offset(mut self, value: ChromaLocation) -> Self {
        self.inner.suggested_y_chroma_offset = value;
        self
    }
}
impl<'a> core::ops::Deref for AndroidHardwareBufferFormatProperties2ANDROIDBuilder<'a> {
    type Target = AndroidHardwareBufferFormatProperties2ANDROID;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for AndroidHardwareBufferFormatProperties2ANDROIDBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PipelineRenderingCreateInfo`] with lifetime-tied pNext safety.
pub struct PipelineRenderingCreateInfoBuilder<'a> {
    inner: PipelineRenderingCreateInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PipelineRenderingCreateInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PipelineRenderingCreateInfoBuilder<'a> {
        PipelineRenderingCreateInfoBuilder {
            inner: PipelineRenderingCreateInfo {
                s_type: StructureType::from_raw(1000044002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PipelineRenderingCreateInfoBuilder<'a> {
    #[inline]
    pub fn view_mask(mut self, value: u32) -> Self {
        self.inner.view_mask = value;
        self
    }
    #[inline]
    pub fn color_attachment_formats(mut self, slice: &'a [Format]) -> Self {
        self.inner.color_attachment_count = slice.len() as u32;
        self.inner.p_color_attachment_formats = slice.as_ptr();
        self
    }
    #[inline]
    pub fn depth_attachment_format(mut self, value: Format) -> Self {
        self.inner.depth_attachment_format = value;
        self
    }
    #[inline]
    pub fn stencil_attachment_format(mut self, value: Format) -> Self {
        self.inner.stencil_attachment_format = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PipelineRenderingCreateInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPipelineRenderingCreateInfo>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for PipelineRenderingCreateInfoBuilder<'a> {
    type Target = PipelineRenderingCreateInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PipelineRenderingCreateInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`RenderingInfo`] with lifetime-tied pNext safety.
pub struct RenderingInfoBuilder<'a> {
    inner: RenderingInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl RenderingInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> RenderingInfoBuilder<'a> {
        RenderingInfoBuilder {
            inner: RenderingInfo {
                s_type: StructureType::from_raw(1000044000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> RenderingInfoBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: RenderingFlags) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn render_area(mut self, value: Rect2D) -> Self {
        self.inner.render_area = value;
        self
    }
    #[inline]
    pub fn layer_count(mut self, value: u32) -> Self {
        self.inner.layer_count = value;
        self
    }
    #[inline]
    pub fn view_mask(mut self, value: u32) -> Self {
        self.inner.view_mask = value;
        self
    }
    #[inline]
    pub fn color_attachments(mut self, slice: &'a [RenderingAttachmentInfo]) -> Self {
        self.inner.color_attachment_count = slice.len() as u32;
        self.inner.p_color_attachments = slice.as_ptr();
        self
    }
    #[inline]
    pub fn depth_attachment(mut self, value: &'a RenderingAttachmentInfo) -> Self {
        self.inner.p_depth_attachment = value;
        self
    }
    #[inline]
    pub fn stencil_attachment(mut self, value: &'a RenderingAttachmentInfo) -> Self {
        self.inner.p_stencil_attachment = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`RenderingInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsRenderingInfo>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for RenderingInfoBuilder<'a> {
    type Target = RenderingInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for RenderingInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`RenderingEndInfoKHR`] with lifetime-tied pNext safety.
pub struct RenderingEndInfoKHRBuilder<'a> {
    inner: RenderingEndInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl RenderingEndInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> RenderingEndInfoKHRBuilder<'a> {
        RenderingEndInfoKHRBuilder {
            inner: RenderingEndInfoKHR {
                s_type: StructureType::from_raw(1000619003i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> RenderingEndInfoKHRBuilder<'a> {
    ///Prepend a struct to the pNext chain. See [`RenderingEndInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsRenderingEndInfoKHR>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for RenderingEndInfoKHRBuilder<'a> {
    type Target = RenderingEndInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for RenderingEndInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`RenderingAttachmentInfo`] with lifetime-tied pNext safety.
pub struct RenderingAttachmentInfoBuilder<'a> {
    inner: RenderingAttachmentInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl RenderingAttachmentInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> RenderingAttachmentInfoBuilder<'a> {
        RenderingAttachmentInfoBuilder {
            inner: RenderingAttachmentInfo {
                s_type: StructureType::from_raw(1000044001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> RenderingAttachmentInfoBuilder<'a> {
    #[inline]
    pub fn image_view(mut self, value: ImageView) -> Self {
        self.inner.image_view = value;
        self
    }
    #[inline]
    pub fn image_layout(mut self, value: ImageLayout) -> Self {
        self.inner.image_layout = value;
        self
    }
    #[inline]
    pub fn resolve_mode(mut self, value: ResolveModeFlagBits) -> Self {
        self.inner.resolve_mode = value;
        self
    }
    #[inline]
    pub fn resolve_image_view(mut self, value: ImageView) -> Self {
        self.inner.resolve_image_view = value;
        self
    }
    #[inline]
    pub fn resolve_image_layout(mut self, value: ImageLayout) -> Self {
        self.inner.resolve_image_layout = value;
        self
    }
    #[inline]
    pub fn load_op(mut self, value: AttachmentLoadOp) -> Self {
        self.inner.load_op = value;
        self
    }
    #[inline]
    pub fn store_op(mut self, value: AttachmentStoreOp) -> Self {
        self.inner.store_op = value;
        self
    }
    #[inline]
    pub fn clear_value(mut self, value: ClearValue) -> Self {
        self.inner.clear_value = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`RenderingAttachmentInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsRenderingAttachmentInfo>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for RenderingAttachmentInfoBuilder<'a> {
    type Target = RenderingAttachmentInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for RenderingAttachmentInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`RenderingFragmentShadingRateAttachmentInfoKHR`] with lifetime-tied pNext safety.
pub struct RenderingFragmentShadingRateAttachmentInfoKHRBuilder<'a> {
    inner: RenderingFragmentShadingRateAttachmentInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl RenderingFragmentShadingRateAttachmentInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> RenderingFragmentShadingRateAttachmentInfoKHRBuilder<'a> {
        RenderingFragmentShadingRateAttachmentInfoKHRBuilder {
            inner: RenderingFragmentShadingRateAttachmentInfoKHR {
                s_type: StructureType::from_raw(1000044006i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> RenderingFragmentShadingRateAttachmentInfoKHRBuilder<'a> {
    #[inline]
    pub fn image_view(mut self, value: ImageView) -> Self {
        self.inner.image_view = value;
        self
    }
    #[inline]
    pub fn image_layout(mut self, value: ImageLayout) -> Self {
        self.inner.image_layout = value;
        self
    }
    #[inline]
    pub fn shading_rate_attachment_texel_size(mut self, value: Extent2D) -> Self {
        self.inner.shading_rate_attachment_texel_size = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`RenderingFragmentShadingRateAttachmentInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsRenderingFragmentShadingRateAttachmentInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for RenderingFragmentShadingRateAttachmentInfoKHRBuilder<'a> {
    type Target = RenderingFragmentShadingRateAttachmentInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for RenderingFragmentShadingRateAttachmentInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`RenderingFragmentDensityMapAttachmentInfoEXT`] with lifetime-tied pNext safety.
pub struct RenderingFragmentDensityMapAttachmentInfoEXTBuilder<'a> {
    inner: RenderingFragmentDensityMapAttachmentInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl RenderingFragmentDensityMapAttachmentInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> RenderingFragmentDensityMapAttachmentInfoEXTBuilder<'a> {
        RenderingFragmentDensityMapAttachmentInfoEXTBuilder {
            inner: RenderingFragmentDensityMapAttachmentInfoEXT {
                s_type: StructureType::from_raw(1000044007i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> RenderingFragmentDensityMapAttachmentInfoEXTBuilder<'a> {
    #[inline]
    pub fn image_view(mut self, value: ImageView) -> Self {
        self.inner.image_view = value;
        self
    }
    #[inline]
    pub fn image_layout(mut self, value: ImageLayout) -> Self {
        self.inner.image_layout = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`RenderingFragmentDensityMapAttachmentInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsRenderingFragmentDensityMapAttachmentInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for RenderingFragmentDensityMapAttachmentInfoEXTBuilder<'a> {
    type Target = RenderingFragmentDensityMapAttachmentInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for RenderingFragmentDensityMapAttachmentInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceDynamicRenderingFeatures`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceDynamicRenderingFeaturesBuilder<'a> {
    inner: PhysicalDeviceDynamicRenderingFeatures,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceDynamicRenderingFeatures {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceDynamicRenderingFeaturesBuilder<'a> {
        PhysicalDeviceDynamicRenderingFeaturesBuilder {
            inner: PhysicalDeviceDynamicRenderingFeatures {
                s_type: StructureType::from_raw(1000044003i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceDynamicRenderingFeaturesBuilder<'a> {
    #[inline]
    pub fn dynamic_rendering(mut self, value: bool) -> Self {
        self.inner.dynamic_rendering = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceDynamicRenderingFeatures`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceDynamicRenderingFeatures>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceDynamicRenderingFeaturesBuilder<'a> {
    type Target = PhysicalDeviceDynamicRenderingFeatures;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceDynamicRenderingFeaturesBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`CommandBufferInheritanceRenderingInfo`] with lifetime-tied pNext safety.
pub struct CommandBufferInheritanceRenderingInfoBuilder<'a> {
    inner: CommandBufferInheritanceRenderingInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl CommandBufferInheritanceRenderingInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> CommandBufferInheritanceRenderingInfoBuilder<'a> {
        CommandBufferInheritanceRenderingInfoBuilder {
            inner: CommandBufferInheritanceRenderingInfo {
                s_type: StructureType::from_raw(1000044004i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> CommandBufferInheritanceRenderingInfoBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: RenderingFlags) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn view_mask(mut self, value: u32) -> Self {
        self.inner.view_mask = value;
        self
    }
    #[inline]
    pub fn color_attachment_formats(mut self, slice: &'a [Format]) -> Self {
        self.inner.color_attachment_count = slice.len() as u32;
        self.inner.p_color_attachment_formats = slice.as_ptr();
        self
    }
    #[inline]
    pub fn depth_attachment_format(mut self, value: Format) -> Self {
        self.inner.depth_attachment_format = value;
        self
    }
    #[inline]
    pub fn stencil_attachment_format(mut self, value: Format) -> Self {
        self.inner.stencil_attachment_format = value;
        self
    }
    #[inline]
    pub fn rasterization_samples(mut self, value: SampleCountFlagBits) -> Self {
        self.inner.rasterization_samples = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`CommandBufferInheritanceRenderingInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsCommandBufferInheritanceRenderingInfo>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for CommandBufferInheritanceRenderingInfoBuilder<'a> {
    type Target = CommandBufferInheritanceRenderingInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for CommandBufferInheritanceRenderingInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`AttachmentSampleCountInfoAMD`] with lifetime-tied pNext safety.
pub struct AttachmentSampleCountInfoAMDBuilder<'a> {
    inner: AttachmentSampleCountInfoAMD,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl AttachmentSampleCountInfoAMD {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> AttachmentSampleCountInfoAMDBuilder<'a> {
        AttachmentSampleCountInfoAMDBuilder {
            inner: AttachmentSampleCountInfoAMD {
                s_type: StructureType::from_raw(1000044008i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> AttachmentSampleCountInfoAMDBuilder<'a> {
    #[inline]
    pub fn color_attachment_samples(mut self, slice: &'a [SampleCountFlagBits]) -> Self {
        self.inner.color_attachment_count = slice.len() as u32;
        self.inner.p_color_attachment_samples = slice.as_ptr();
        self
    }
    #[inline]
    pub fn depth_stencil_attachment_samples(
        mut self,
        value: SampleCountFlagBits,
    ) -> Self {
        self.inner.depth_stencil_attachment_samples = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`AttachmentSampleCountInfoAMD`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsAttachmentSampleCountInfoAMD>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for AttachmentSampleCountInfoAMDBuilder<'a> {
    type Target = AttachmentSampleCountInfoAMD;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for AttachmentSampleCountInfoAMDBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`MultiviewPerViewAttributesInfoNVX`] with lifetime-tied pNext safety.
pub struct MultiviewPerViewAttributesInfoNVXBuilder<'a> {
    inner: MultiviewPerViewAttributesInfoNVX,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl MultiviewPerViewAttributesInfoNVX {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> MultiviewPerViewAttributesInfoNVXBuilder<'a> {
        MultiviewPerViewAttributesInfoNVXBuilder {
            inner: MultiviewPerViewAttributesInfoNVX {
                s_type: StructureType::from_raw(1000044009i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> MultiviewPerViewAttributesInfoNVXBuilder<'a> {
    #[inline]
    pub fn per_view_attributes(mut self, value: bool) -> Self {
        self.inner.per_view_attributes = value as u32;
        self
    }
    #[inline]
    pub fn per_view_attributes_position_x_only(mut self, value: bool) -> Self {
        self.inner.per_view_attributes_position_x_only = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`MultiviewPerViewAttributesInfoNVX`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsMultiviewPerViewAttributesInfoNVX>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for MultiviewPerViewAttributesInfoNVXBuilder<'a> {
    type Target = MultiviewPerViewAttributesInfoNVX;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for MultiviewPerViewAttributesInfoNVXBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceImageViewMinLodFeaturesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceImageViewMinLodFeaturesEXTBuilder<'a> {
    inner: PhysicalDeviceImageViewMinLodFeaturesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceImageViewMinLodFeaturesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceImageViewMinLodFeaturesEXTBuilder<'a> {
        PhysicalDeviceImageViewMinLodFeaturesEXTBuilder {
            inner: PhysicalDeviceImageViewMinLodFeaturesEXT {
                s_type: StructureType::from_raw(1000391000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceImageViewMinLodFeaturesEXTBuilder<'a> {
    #[inline]
    pub fn min_lod(mut self, value: bool) -> Self {
        self.inner.min_lod = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceImageViewMinLodFeaturesEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceImageViewMinLodFeaturesEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceImageViewMinLodFeaturesEXTBuilder<'a> {
    type Target = PhysicalDeviceImageViewMinLodFeaturesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceImageViewMinLodFeaturesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ImageViewMinLodCreateInfoEXT`] with lifetime-tied pNext safety.
pub struct ImageViewMinLodCreateInfoEXTBuilder<'a> {
    inner: ImageViewMinLodCreateInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ImageViewMinLodCreateInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ImageViewMinLodCreateInfoEXTBuilder<'a> {
        ImageViewMinLodCreateInfoEXTBuilder {
            inner: ImageViewMinLodCreateInfoEXT {
                s_type: StructureType::from_raw(1000391001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ImageViewMinLodCreateInfoEXTBuilder<'a> {
    #[inline]
    pub fn min_lod(mut self, value: f32) -> Self {
        self.inner.min_lod = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`ImageViewMinLodCreateInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsImageViewMinLodCreateInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for ImageViewMinLodCreateInfoEXTBuilder<'a> {
    type Target = ImageViewMinLodCreateInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ImageViewMinLodCreateInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXTBuilder<'a> {
    inner: PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXTBuilder<
        'a,
    > {
        PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXTBuilder {
            inner: PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT {
                s_type: StructureType::from_raw(1000342000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXTBuilder<'a> {
    #[inline]
    pub fn rasterization_order_color_attachment_access(mut self, value: bool) -> Self {
        self.inner.rasterization_order_color_attachment_access = value as u32;
        self
    }
    #[inline]
    pub fn rasterization_order_depth_attachment_access(mut self, value: bool) -> Self {
        self.inner.rasterization_order_depth_attachment_access = value as u32;
        self
    }
    #[inline]
    pub fn rasterization_order_stencil_attachment_access(mut self, value: bool) -> Self {
        self.inner.rasterization_order_stencil_attachment_access = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<
        T: ExtendsPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT,
    >(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXTBuilder<'a> {
    type Target = PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceLinearColorAttachmentFeaturesNV`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceLinearColorAttachmentFeaturesNVBuilder<'a> {
    inner: PhysicalDeviceLinearColorAttachmentFeaturesNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceLinearColorAttachmentFeaturesNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceLinearColorAttachmentFeaturesNVBuilder<'a> {
        PhysicalDeviceLinearColorAttachmentFeaturesNVBuilder {
            inner: PhysicalDeviceLinearColorAttachmentFeaturesNV {
                s_type: StructureType::from_raw(1000430000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceLinearColorAttachmentFeaturesNVBuilder<'a> {
    #[inline]
    pub fn linear_color_attachment(mut self, value: bool) -> Self {
        self.inner.linear_color_attachment = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceLinearColorAttachmentFeaturesNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceLinearColorAttachmentFeaturesNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceLinearColorAttachmentFeaturesNVBuilder<'a> {
    type Target = PhysicalDeviceLinearColorAttachmentFeaturesNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceLinearColorAttachmentFeaturesNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceGraphicsPipelineLibraryFeaturesEXTBuilder<'a> {
    inner: PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceGraphicsPipelineLibraryFeaturesEXTBuilder<'a> {
        PhysicalDeviceGraphicsPipelineLibraryFeaturesEXTBuilder {
            inner: PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT {
                s_type: StructureType::from_raw(1000320000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceGraphicsPipelineLibraryFeaturesEXTBuilder<'a> {
    #[inline]
    pub fn graphics_pipeline_library(mut self, value: bool) -> Self {
        self.inner.graphics_pipeline_library = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDeviceGraphicsPipelineLibraryFeaturesEXTBuilder<'a> {
    type Target = PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceGraphicsPipelineLibraryFeaturesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDevicePipelineBinaryFeaturesKHR`] with lifetime-tied pNext safety.
pub struct PhysicalDevicePipelineBinaryFeaturesKHRBuilder<'a> {
    inner: PhysicalDevicePipelineBinaryFeaturesKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDevicePipelineBinaryFeaturesKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDevicePipelineBinaryFeaturesKHRBuilder<'a> {
        PhysicalDevicePipelineBinaryFeaturesKHRBuilder {
            inner: PhysicalDevicePipelineBinaryFeaturesKHR {
                s_type: StructureType::from_raw(1000483000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDevicePipelineBinaryFeaturesKHRBuilder<'a> {
    #[inline]
    pub fn pipeline_binaries(mut self, value: bool) -> Self {
        self.inner.pipeline_binaries = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDevicePipelineBinaryFeaturesKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDevicePipelineBinaryFeaturesKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDevicePipelineBinaryFeaturesKHRBuilder<'a> {
    type Target = PhysicalDevicePipelineBinaryFeaturesKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDevicePipelineBinaryFeaturesKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DevicePipelineBinaryInternalCacheControlKHR`] with lifetime-tied pNext safety.
pub struct DevicePipelineBinaryInternalCacheControlKHRBuilder<'a> {
    inner: DevicePipelineBinaryInternalCacheControlKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DevicePipelineBinaryInternalCacheControlKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> DevicePipelineBinaryInternalCacheControlKHRBuilder<'a> {
        DevicePipelineBinaryInternalCacheControlKHRBuilder {
            inner: DevicePipelineBinaryInternalCacheControlKHR {
                s_type: StructureType::from_raw(1000483008i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DevicePipelineBinaryInternalCacheControlKHRBuilder<'a> {
    #[inline]
    pub fn disable_internal_cache(mut self, value: bool) -> Self {
        self.inner.disable_internal_cache = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`DevicePipelineBinaryInternalCacheControlKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsDevicePipelineBinaryInternalCacheControlKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for DevicePipelineBinaryInternalCacheControlKHRBuilder<'a> {
    type Target = DevicePipelineBinaryInternalCacheControlKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for DevicePipelineBinaryInternalCacheControlKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDevicePipelineBinaryPropertiesKHR`] with lifetime-tied pNext safety.
pub struct PhysicalDevicePipelineBinaryPropertiesKHRBuilder<'a> {
    inner: PhysicalDevicePipelineBinaryPropertiesKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDevicePipelineBinaryPropertiesKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDevicePipelineBinaryPropertiesKHRBuilder<'a> {
        PhysicalDevicePipelineBinaryPropertiesKHRBuilder {
            inner: PhysicalDevicePipelineBinaryPropertiesKHR {
                s_type: StructureType::from_raw(1000483004i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDevicePipelineBinaryPropertiesKHRBuilder<'a> {
    #[inline]
    pub fn pipeline_binary_internal_cache(mut self, value: bool) -> Self {
        self.inner.pipeline_binary_internal_cache = value as u32;
        self
    }
    #[inline]
    pub fn pipeline_binary_internal_cache_control(mut self, value: bool) -> Self {
        self.inner.pipeline_binary_internal_cache_control = value as u32;
        self
    }
    #[inline]
    pub fn pipeline_binary_prefers_internal_cache(mut self, value: bool) -> Self {
        self.inner.pipeline_binary_prefers_internal_cache = value as u32;
        self
    }
    #[inline]
    pub fn pipeline_binary_precompiled_internal_cache(mut self, value: bool) -> Self {
        self.inner.pipeline_binary_precompiled_internal_cache = value as u32;
        self
    }
    #[inline]
    pub fn pipeline_binary_compressed_data(mut self, value: bool) -> Self {
        self.inner.pipeline_binary_compressed_data = value as u32;
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDevicePipelineBinaryPropertiesKHRBuilder<'a> {
    type Target = PhysicalDevicePipelineBinaryPropertiesKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDevicePipelineBinaryPropertiesKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceGraphicsPipelineLibraryPropertiesEXTBuilder<'a> {
    inner: PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceGraphicsPipelineLibraryPropertiesEXTBuilder<
        'a,
    > {
        PhysicalDeviceGraphicsPipelineLibraryPropertiesEXTBuilder {
            inner: PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT {
                s_type: StructureType::from_raw(1000320001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceGraphicsPipelineLibraryPropertiesEXTBuilder<'a> {
    #[inline]
    pub fn graphics_pipeline_library_fast_linking(mut self, value: bool) -> Self {
        self.inner.graphics_pipeline_library_fast_linking = value as u32;
        self
    }
    #[inline]
    pub fn graphics_pipeline_library_independent_interpolation_decoration(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.graphics_pipeline_library_independent_interpolation_decoration = value
            as u32;
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDeviceGraphicsPipelineLibraryPropertiesEXTBuilder<'a> {
    type Target = PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceGraphicsPipelineLibraryPropertiesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`GraphicsPipelineLibraryCreateInfoEXT`] with lifetime-tied pNext safety.
pub struct GraphicsPipelineLibraryCreateInfoEXTBuilder<'a> {
    inner: GraphicsPipelineLibraryCreateInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl GraphicsPipelineLibraryCreateInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> GraphicsPipelineLibraryCreateInfoEXTBuilder<'a> {
        GraphicsPipelineLibraryCreateInfoEXTBuilder {
            inner: GraphicsPipelineLibraryCreateInfoEXT {
                s_type: StructureType::from_raw(1000320002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> GraphicsPipelineLibraryCreateInfoEXTBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: GraphicsPipelineLibraryFlagsEXT) -> Self {
        self.inner.flags = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`GraphicsPipelineLibraryCreateInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsGraphicsPipelineLibraryCreateInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for GraphicsPipelineLibraryCreateInfoEXTBuilder<'a> {
    type Target = GraphicsPipelineLibraryCreateInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for GraphicsPipelineLibraryCreateInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceDescriptorSetHostMappingFeaturesVALVEBuilder<'a> {
    inner: PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceDescriptorSetHostMappingFeaturesVALVEBuilder<
        'a,
    > {
        PhysicalDeviceDescriptorSetHostMappingFeaturesVALVEBuilder {
            inner: PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE {
                s_type: StructureType::from_raw(1000420000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceDescriptorSetHostMappingFeaturesVALVEBuilder<'a> {
    #[inline]
    pub fn descriptor_set_host_mapping(mut self, value: bool) -> Self {
        self.inner.descriptor_set_host_mapping = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDeviceDescriptorSetHostMappingFeaturesVALVEBuilder<'a> {
    type Target = PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceDescriptorSetHostMappingFeaturesVALVEBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DescriptorSetBindingReferenceVALVE`] with lifetime-tied pNext safety.
pub struct DescriptorSetBindingReferenceVALVEBuilder<'a> {
    inner: DescriptorSetBindingReferenceVALVE,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DescriptorSetBindingReferenceVALVE {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> DescriptorSetBindingReferenceVALVEBuilder<'a> {
        DescriptorSetBindingReferenceVALVEBuilder {
            inner: DescriptorSetBindingReferenceVALVE {
                s_type: StructureType::from_raw(1000420001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DescriptorSetBindingReferenceVALVEBuilder<'a> {
    #[inline]
    pub fn descriptor_set_layout(mut self, value: DescriptorSetLayout) -> Self {
        self.inner.descriptor_set_layout = value;
        self
    }
    #[inline]
    pub fn binding(mut self, value: u32) -> Self {
        self.inner.binding = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`DescriptorSetBindingReferenceVALVE`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsDescriptorSetBindingReferenceVALVE>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for DescriptorSetBindingReferenceVALVEBuilder<'a> {
    type Target = DescriptorSetBindingReferenceVALVE;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for DescriptorSetBindingReferenceVALVEBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DescriptorSetLayoutHostMappingInfoVALVE`] with lifetime-tied pNext safety.
pub struct DescriptorSetLayoutHostMappingInfoVALVEBuilder<'a> {
    inner: DescriptorSetLayoutHostMappingInfoVALVE,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DescriptorSetLayoutHostMappingInfoVALVE {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> DescriptorSetLayoutHostMappingInfoVALVEBuilder<'a> {
        DescriptorSetLayoutHostMappingInfoVALVEBuilder {
            inner: DescriptorSetLayoutHostMappingInfoVALVE {
                s_type: StructureType::from_raw(1000420002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DescriptorSetLayoutHostMappingInfoVALVEBuilder<'a> {
    #[inline]
    pub fn descriptor_offset(mut self, value: usize) -> Self {
        self.inner.descriptor_offset = value;
        self
    }
    #[inline]
    pub fn descriptor_size(mut self, value: u32) -> Self {
        self.inner.descriptor_size = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`DescriptorSetLayoutHostMappingInfoVALVE`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsDescriptorSetLayoutHostMappingInfoVALVE>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for DescriptorSetLayoutHostMappingInfoVALVEBuilder<'a> {
    type Target = DescriptorSetLayoutHostMappingInfoVALVE;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for DescriptorSetLayoutHostMappingInfoVALVEBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceNestedCommandBufferFeaturesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceNestedCommandBufferFeaturesEXTBuilder<'a> {
    inner: PhysicalDeviceNestedCommandBufferFeaturesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceNestedCommandBufferFeaturesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceNestedCommandBufferFeaturesEXTBuilder<'a> {
        PhysicalDeviceNestedCommandBufferFeaturesEXTBuilder {
            inner: PhysicalDeviceNestedCommandBufferFeaturesEXT {
                s_type: StructureType::from_raw(1000451000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceNestedCommandBufferFeaturesEXTBuilder<'a> {
    #[inline]
    pub fn nested_command_buffer(mut self, value: bool) -> Self {
        self.inner.nested_command_buffer = value as u32;
        self
    }
    #[inline]
    pub fn nested_command_buffer_rendering(mut self, value: bool) -> Self {
        self.inner.nested_command_buffer_rendering = value as u32;
        self
    }
    #[inline]
    pub fn nested_command_buffer_simultaneous_use(mut self, value: bool) -> Self {
        self.inner.nested_command_buffer_simultaneous_use = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceNestedCommandBufferFeaturesEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceNestedCommandBufferFeaturesEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceNestedCommandBufferFeaturesEXTBuilder<'a> {
    type Target = PhysicalDeviceNestedCommandBufferFeaturesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceNestedCommandBufferFeaturesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceNestedCommandBufferPropertiesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceNestedCommandBufferPropertiesEXTBuilder<'a> {
    inner: PhysicalDeviceNestedCommandBufferPropertiesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceNestedCommandBufferPropertiesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceNestedCommandBufferPropertiesEXTBuilder<'a> {
        PhysicalDeviceNestedCommandBufferPropertiesEXTBuilder {
            inner: PhysicalDeviceNestedCommandBufferPropertiesEXT {
                s_type: StructureType::from_raw(1000451001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceNestedCommandBufferPropertiesEXTBuilder<'a> {
    #[inline]
    pub fn max_command_buffer_nesting_level(mut self, value: u32) -> Self {
        self.inner.max_command_buffer_nesting_level = value;
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceNestedCommandBufferPropertiesEXTBuilder<'a> {
    type Target = PhysicalDeviceNestedCommandBufferPropertiesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceNestedCommandBufferPropertiesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceShaderModuleIdentifierFeaturesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceShaderModuleIdentifierFeaturesEXTBuilder<'a> {
    inner: PhysicalDeviceShaderModuleIdentifierFeaturesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceShaderModuleIdentifierFeaturesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceShaderModuleIdentifierFeaturesEXTBuilder<'a> {
        PhysicalDeviceShaderModuleIdentifierFeaturesEXTBuilder {
            inner: PhysicalDeviceShaderModuleIdentifierFeaturesEXT {
                s_type: StructureType::from_raw(1000462000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceShaderModuleIdentifierFeaturesEXTBuilder<'a> {
    #[inline]
    pub fn shader_module_identifier(mut self, value: bool) -> Self {
        self.inner.shader_module_identifier = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceShaderModuleIdentifierFeaturesEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceShaderModuleIdentifierFeaturesEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDeviceShaderModuleIdentifierFeaturesEXTBuilder<'a> {
    type Target = PhysicalDeviceShaderModuleIdentifierFeaturesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceShaderModuleIdentifierFeaturesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceShaderModuleIdentifierPropertiesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceShaderModuleIdentifierPropertiesEXTBuilder<'a> {
    inner: PhysicalDeviceShaderModuleIdentifierPropertiesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceShaderModuleIdentifierPropertiesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceShaderModuleIdentifierPropertiesEXTBuilder<
        'a,
    > {
        PhysicalDeviceShaderModuleIdentifierPropertiesEXTBuilder {
            inner: PhysicalDeviceShaderModuleIdentifierPropertiesEXT {
                s_type: StructureType::from_raw(1000462001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceShaderModuleIdentifierPropertiesEXTBuilder<'a> {
    #[inline]
    pub fn shader_module_identifier_algorithm_uuid(
        mut self,
        value: [u8; UUID_SIZE as usize],
    ) -> Self {
        self.inner.shader_module_identifier_algorithm_uuid = value;
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDeviceShaderModuleIdentifierPropertiesEXTBuilder<'a> {
    type Target = PhysicalDeviceShaderModuleIdentifierPropertiesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceShaderModuleIdentifierPropertiesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PipelineShaderStageModuleIdentifierCreateInfoEXT`] with lifetime-tied pNext safety.
pub struct PipelineShaderStageModuleIdentifierCreateInfoEXTBuilder<'a> {
    inner: PipelineShaderStageModuleIdentifierCreateInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PipelineShaderStageModuleIdentifierCreateInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PipelineShaderStageModuleIdentifierCreateInfoEXTBuilder<'a> {
        PipelineShaderStageModuleIdentifierCreateInfoEXTBuilder {
            inner: PipelineShaderStageModuleIdentifierCreateInfoEXT {
                s_type: StructureType::from_raw(1000462002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PipelineShaderStageModuleIdentifierCreateInfoEXTBuilder<'a> {
    #[inline]
    pub fn identifier(mut self, slice: &'a [u8]) -> Self {
        self.inner.identifier_size = slice.len() as u32;
        self.inner.p_identifier = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`PipelineShaderStageModuleIdentifierCreateInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPipelineShaderStageModuleIdentifierCreateInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref
for PipelineShaderStageModuleIdentifierCreateInfoEXTBuilder<'a> {
    type Target = PipelineShaderStageModuleIdentifierCreateInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PipelineShaderStageModuleIdentifierCreateInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ShaderModuleIdentifierEXT`] with lifetime-tied pNext safety.
pub struct ShaderModuleIdentifierEXTBuilder<'a> {
    inner: ShaderModuleIdentifierEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ShaderModuleIdentifierEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ShaderModuleIdentifierEXTBuilder<'a> {
        ShaderModuleIdentifierEXTBuilder {
            inner: ShaderModuleIdentifierEXT {
                s_type: StructureType::from_raw(1000462003i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ShaderModuleIdentifierEXTBuilder<'a> {
    #[inline]
    pub fn identifier_size(mut self, value: u32) -> Self {
        self.inner.identifier_size = value;
        self
    }
    #[inline]
    pub fn identifier(
        mut self,
        value: [u8; MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT as usize],
    ) -> Self {
        self.inner.identifier = value;
        self
    }
}
impl<'a> core::ops::Deref for ShaderModuleIdentifierEXTBuilder<'a> {
    type Target = ShaderModuleIdentifierEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ShaderModuleIdentifierEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ImageCompressionControlEXT`] with lifetime-tied pNext safety.
pub struct ImageCompressionControlEXTBuilder<'a> {
    inner: ImageCompressionControlEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ImageCompressionControlEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ImageCompressionControlEXTBuilder<'a> {
        ImageCompressionControlEXTBuilder {
            inner: ImageCompressionControlEXT {
                s_type: StructureType::from_raw(1000338001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ImageCompressionControlEXTBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: ImageCompressionFlagsEXT) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn fixed_rate_flags(
        mut self,
        slice: &'a mut [ImageCompressionFixedRateFlagsEXT],
    ) -> Self {
        self.inner.compression_control_plane_count = slice.len() as u32;
        self.inner.p_fixed_rate_flags = slice.as_mut_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`ImageCompressionControlEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsImageCompressionControlEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for ImageCompressionControlEXTBuilder<'a> {
    type Target = ImageCompressionControlEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ImageCompressionControlEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceImageCompressionControlFeaturesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceImageCompressionControlFeaturesEXTBuilder<'a> {
    inner: PhysicalDeviceImageCompressionControlFeaturesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceImageCompressionControlFeaturesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceImageCompressionControlFeaturesEXTBuilder<'a> {
        PhysicalDeviceImageCompressionControlFeaturesEXTBuilder {
            inner: PhysicalDeviceImageCompressionControlFeaturesEXT {
                s_type: StructureType::from_raw(1000338000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceImageCompressionControlFeaturesEXTBuilder<'a> {
    #[inline]
    pub fn image_compression_control(mut self, value: bool) -> Self {
        self.inner.image_compression_control = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceImageCompressionControlFeaturesEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceImageCompressionControlFeaturesEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDeviceImageCompressionControlFeaturesEXTBuilder<'a> {
    type Target = PhysicalDeviceImageCompressionControlFeaturesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceImageCompressionControlFeaturesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ImageCompressionPropertiesEXT`] with lifetime-tied pNext safety.
pub struct ImageCompressionPropertiesEXTBuilder<'a> {
    inner: ImageCompressionPropertiesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ImageCompressionPropertiesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ImageCompressionPropertiesEXTBuilder<'a> {
        ImageCompressionPropertiesEXTBuilder {
            inner: ImageCompressionPropertiesEXT {
                s_type: StructureType::from_raw(1000338004i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ImageCompressionPropertiesEXTBuilder<'a> {
    #[inline]
    pub fn image_compression_flags(mut self, value: ImageCompressionFlagsEXT) -> Self {
        self.inner.image_compression_flags = value;
        self
    }
    #[inline]
    pub fn image_compression_fixed_rate_flags(
        mut self,
        value: ImageCompressionFixedRateFlagsEXT,
    ) -> Self {
        self.inner.image_compression_fixed_rate_flags = value;
        self
    }
}
impl<'a> core::ops::Deref for ImageCompressionPropertiesEXTBuilder<'a> {
    type Target = ImageCompressionPropertiesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ImageCompressionPropertiesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceImageCompressionControlSwapchainFeaturesEXTBuilder<'a> {
    inner: PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceImageCompressionControlSwapchainFeaturesEXTBuilder<
        'a,
    > {
        PhysicalDeviceImageCompressionControlSwapchainFeaturesEXTBuilder {
            inner: PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT {
                s_type: StructureType::from_raw(1000437000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceImageCompressionControlSwapchainFeaturesEXTBuilder<'a> {
    #[inline]
    pub fn image_compression_control_swapchain(mut self, value: bool) -> Self {
        self.inner.image_compression_control_swapchain = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<
        T: ExtendsPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT,
    >(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDeviceImageCompressionControlSwapchainFeaturesEXTBuilder<'a> {
    type Target = PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceImageCompressionControlSwapchainFeaturesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ImageSubresource2`] with lifetime-tied pNext safety.
pub struct ImageSubresource2Builder<'a> {
    inner: ImageSubresource2,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ImageSubresource2 {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ImageSubresource2Builder<'a> {
        ImageSubresource2Builder {
            inner: ImageSubresource2 {
                s_type: StructureType::from_raw(1000338003i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ImageSubresource2Builder<'a> {
    #[inline]
    pub fn image_subresource(mut self, value: ImageSubresource) -> Self {
        self.inner.image_subresource = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`ImageSubresource2`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsImageSubresource2>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for ImageSubresource2Builder<'a> {
    type Target = ImageSubresource2;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ImageSubresource2Builder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`SubresourceLayout2`] with lifetime-tied pNext safety.
pub struct SubresourceLayout2Builder<'a> {
    inner: SubresourceLayout2,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl SubresourceLayout2 {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> SubresourceLayout2Builder<'a> {
        SubresourceLayout2Builder {
            inner: SubresourceLayout2 {
                s_type: StructureType::from_raw(1000338002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> SubresourceLayout2Builder<'a> {
    #[inline]
    pub fn subresource_layout(mut self, value: SubresourceLayout) -> Self {
        self.inner.subresource_layout = value;
        self
    }
}
impl<'a> core::ops::Deref for SubresourceLayout2Builder<'a> {
    type Target = SubresourceLayout2;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for SubresourceLayout2Builder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`RenderPassCreationControlEXT`] with lifetime-tied pNext safety.
pub struct RenderPassCreationControlEXTBuilder<'a> {
    inner: RenderPassCreationControlEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl RenderPassCreationControlEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> RenderPassCreationControlEXTBuilder<'a> {
        RenderPassCreationControlEXTBuilder {
            inner: RenderPassCreationControlEXT {
                s_type: StructureType::from_raw(1000458001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> RenderPassCreationControlEXTBuilder<'a> {
    #[inline]
    pub fn disallow_merging(mut self, value: bool) -> Self {
        self.inner.disallow_merging = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`RenderPassCreationControlEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsRenderPassCreationControlEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for RenderPassCreationControlEXTBuilder<'a> {
    type Target = RenderPassCreationControlEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for RenderPassCreationControlEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`RenderPassCreationFeedbackInfoEXT`].
pub struct RenderPassCreationFeedbackInfoEXTBuilder {
    inner: RenderPassCreationFeedbackInfoEXT,
}
impl RenderPassCreationFeedbackInfoEXT {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> RenderPassCreationFeedbackInfoEXTBuilder {
        RenderPassCreationFeedbackInfoEXTBuilder {
            inner: RenderPassCreationFeedbackInfoEXT {
                ..Default::default()
            },
        }
    }
}
impl RenderPassCreationFeedbackInfoEXTBuilder {
    #[inline]
    pub fn post_merge_subpass_count(mut self, value: u32) -> Self {
        self.inner.post_merge_subpass_count = value;
        self
    }
}
impl core::ops::Deref for RenderPassCreationFeedbackInfoEXTBuilder {
    type Target = RenderPassCreationFeedbackInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for RenderPassCreationFeedbackInfoEXTBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`RenderPassCreationFeedbackCreateInfoEXT`] with lifetime-tied pNext safety.
pub struct RenderPassCreationFeedbackCreateInfoEXTBuilder<'a> {
    inner: RenderPassCreationFeedbackCreateInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl RenderPassCreationFeedbackCreateInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> RenderPassCreationFeedbackCreateInfoEXTBuilder<'a> {
        RenderPassCreationFeedbackCreateInfoEXTBuilder {
            inner: RenderPassCreationFeedbackCreateInfoEXT {
                s_type: StructureType::from_raw(1000458002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> RenderPassCreationFeedbackCreateInfoEXTBuilder<'a> {
    #[inline]
    pub fn render_pass_feedback(
        mut self,
        value: *mut RenderPassCreationFeedbackInfoEXT,
    ) -> Self {
        self.inner.p_render_pass_feedback = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`RenderPassCreationFeedbackCreateInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsRenderPassCreationFeedbackCreateInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for RenderPassCreationFeedbackCreateInfoEXTBuilder<'a> {
    type Target = RenderPassCreationFeedbackCreateInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for RenderPassCreationFeedbackCreateInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`RenderPassSubpassFeedbackInfoEXT`].
pub struct RenderPassSubpassFeedbackInfoEXTBuilder {
    inner: RenderPassSubpassFeedbackInfoEXT,
}
impl RenderPassSubpassFeedbackInfoEXT {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> RenderPassSubpassFeedbackInfoEXTBuilder {
        RenderPassSubpassFeedbackInfoEXTBuilder {
            inner: RenderPassSubpassFeedbackInfoEXT {
                ..Default::default()
            },
        }
    }
}
impl RenderPassSubpassFeedbackInfoEXTBuilder {
    #[inline]
    pub fn subpass_merge_status(mut self, value: SubpassMergeStatusEXT) -> Self {
        self.inner.subpass_merge_status = value;
        self
    }
    #[inline]
    pub fn description(
        mut self,
        value: crate::StringArray<{ MAX_DESCRIPTION_SIZE as usize }>,
    ) -> Self {
        self.inner.description = value;
        self
    }
    #[inline]
    pub fn post_merge_index(mut self, value: u32) -> Self {
        self.inner.post_merge_index = value;
        self
    }
}
impl core::ops::Deref for RenderPassSubpassFeedbackInfoEXTBuilder {
    type Target = RenderPassSubpassFeedbackInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for RenderPassSubpassFeedbackInfoEXTBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`RenderPassSubpassFeedbackCreateInfoEXT`] with lifetime-tied pNext safety.
pub struct RenderPassSubpassFeedbackCreateInfoEXTBuilder<'a> {
    inner: RenderPassSubpassFeedbackCreateInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl RenderPassSubpassFeedbackCreateInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> RenderPassSubpassFeedbackCreateInfoEXTBuilder<'a> {
        RenderPassSubpassFeedbackCreateInfoEXTBuilder {
            inner: RenderPassSubpassFeedbackCreateInfoEXT {
                s_type: StructureType::from_raw(1000458003i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> RenderPassSubpassFeedbackCreateInfoEXTBuilder<'a> {
    #[inline]
    pub fn subpass_feedback(
        mut self,
        value: *mut RenderPassSubpassFeedbackInfoEXT,
    ) -> Self {
        self.inner.p_subpass_feedback = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`RenderPassSubpassFeedbackCreateInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsRenderPassSubpassFeedbackCreateInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for RenderPassSubpassFeedbackCreateInfoEXTBuilder<'a> {
    type Target = RenderPassSubpassFeedbackCreateInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for RenderPassSubpassFeedbackCreateInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceSubpassMergeFeedbackFeaturesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceSubpassMergeFeedbackFeaturesEXTBuilder<'a> {
    inner: PhysicalDeviceSubpassMergeFeedbackFeaturesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceSubpassMergeFeedbackFeaturesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceSubpassMergeFeedbackFeaturesEXTBuilder<'a> {
        PhysicalDeviceSubpassMergeFeedbackFeaturesEXTBuilder {
            inner: PhysicalDeviceSubpassMergeFeedbackFeaturesEXT {
                s_type: StructureType::from_raw(1000458000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceSubpassMergeFeedbackFeaturesEXTBuilder<'a> {
    #[inline]
    pub fn subpass_merge_feedback(mut self, value: bool) -> Self {
        self.inner.subpass_merge_feedback = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceSubpassMergeFeedbackFeaturesEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceSubpassMergeFeedbackFeaturesEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceSubpassMergeFeedbackFeaturesEXTBuilder<'a> {
    type Target = PhysicalDeviceSubpassMergeFeedbackFeaturesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceSubpassMergeFeedbackFeaturesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`MicromapBuildInfoEXT`] with lifetime-tied pNext safety.
pub struct MicromapBuildInfoEXTBuilder<'a> {
    inner: MicromapBuildInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl MicromapBuildInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> MicromapBuildInfoEXTBuilder<'a> {
        MicromapBuildInfoEXTBuilder {
            inner: MicromapBuildInfoEXT {
                s_type: StructureType::from_raw(1000396000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> MicromapBuildInfoEXTBuilder<'a> {
    #[inline]
    pub fn r#type(mut self, value: MicromapTypeEXT) -> Self {
        self.inner.r#type = value;
        self
    }
    #[inline]
    pub fn flags(mut self, value: BuildMicromapFlagsEXT) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn mode(mut self, value: BuildMicromapModeEXT) -> Self {
        self.inner.mode = value;
        self
    }
    #[inline]
    pub fn dst_micromap(mut self, value: MicromapEXT) -> Self {
        self.inner.dst_micromap = value;
        self
    }
    #[inline]
    pub fn usage_counts_count(mut self, value: u32) -> Self {
        self.inner.usage_counts_count = value;
        self
    }
    #[inline]
    pub fn usage_counts(mut self, slice: &'a [MicromapUsageEXT]) -> Self {
        self.inner.usage_counts_count = slice.len() as u32;
        self.inner.p_usage_counts = slice.as_ptr();
        self
    }
    #[inline]
    pub fn pp_usage_counts(mut self, value: *const *const MicromapUsageEXT) -> Self {
        self.inner.pp_usage_counts = value;
        self
    }
    #[inline]
    pub fn data(mut self, value: DeviceOrHostAddressConstKHR) -> Self {
        self.inner.data = value;
        self
    }
    #[inline]
    pub fn scratch_data(mut self, value: DeviceOrHostAddressKHR) -> Self {
        self.inner.scratch_data = value;
        self
    }
    #[inline]
    pub fn triangle_array(mut self, value: DeviceOrHostAddressConstKHR) -> Self {
        self.inner.triangle_array = value;
        self
    }
    #[inline]
    pub fn triangle_array_stride(mut self, value: u64) -> Self {
        self.inner.triangle_array_stride = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`MicromapBuildInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsMicromapBuildInfoEXT>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for MicromapBuildInfoEXTBuilder<'a> {
    type Target = MicromapBuildInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for MicromapBuildInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`MicromapCreateInfoEXT`] with lifetime-tied pNext safety.
pub struct MicromapCreateInfoEXTBuilder<'a> {
    inner: MicromapCreateInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl MicromapCreateInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> MicromapCreateInfoEXTBuilder<'a> {
        MicromapCreateInfoEXTBuilder {
            inner: MicromapCreateInfoEXT {
                s_type: StructureType::from_raw(1000396007i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> MicromapCreateInfoEXTBuilder<'a> {
    #[inline]
    pub fn create_flags(mut self, value: MicromapCreateFlagsEXT) -> Self {
        self.inner.create_flags = value;
        self
    }
    #[inline]
    pub fn buffer(mut self, value: Buffer) -> Self {
        self.inner.buffer = value;
        self
    }
    #[inline]
    pub fn offset(mut self, value: u64) -> Self {
        self.inner.offset = value;
        self
    }
    #[inline]
    pub fn size(mut self, value: u64) -> Self {
        self.inner.size = value;
        self
    }
    #[inline]
    pub fn r#type(mut self, value: MicromapTypeEXT) -> Self {
        self.inner.r#type = value;
        self
    }
    #[inline]
    pub fn device_address(mut self, value: u64) -> Self {
        self.inner.device_address = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`MicromapCreateInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsMicromapCreateInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for MicromapCreateInfoEXTBuilder<'a> {
    type Target = MicromapCreateInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for MicromapCreateInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`MicromapVersionInfoEXT`] with lifetime-tied pNext safety.
pub struct MicromapVersionInfoEXTBuilder<'a> {
    inner: MicromapVersionInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl MicromapVersionInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> MicromapVersionInfoEXTBuilder<'a> {
        MicromapVersionInfoEXTBuilder {
            inner: MicromapVersionInfoEXT {
                s_type: StructureType::from_raw(1000396001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> MicromapVersionInfoEXTBuilder<'a> {
    #[inline]
    pub fn version_data(mut self, value: *const u8) -> Self {
        self.inner.p_version_data = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`MicromapVersionInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsMicromapVersionInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for MicromapVersionInfoEXTBuilder<'a> {
    type Target = MicromapVersionInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for MicromapVersionInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`CopyMicromapInfoEXT`] with lifetime-tied pNext safety.
pub struct CopyMicromapInfoEXTBuilder<'a> {
    inner: CopyMicromapInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl CopyMicromapInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> CopyMicromapInfoEXTBuilder<'a> {
        CopyMicromapInfoEXTBuilder {
            inner: CopyMicromapInfoEXT {
                s_type: StructureType::from_raw(1000396002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> CopyMicromapInfoEXTBuilder<'a> {
    #[inline]
    pub fn src(mut self, value: MicromapEXT) -> Self {
        self.inner.src = value;
        self
    }
    #[inline]
    pub fn dst(mut self, value: MicromapEXT) -> Self {
        self.inner.dst = value;
        self
    }
    #[inline]
    pub fn mode(mut self, value: CopyMicromapModeEXT) -> Self {
        self.inner.mode = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`CopyMicromapInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsCopyMicromapInfoEXT>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for CopyMicromapInfoEXTBuilder<'a> {
    type Target = CopyMicromapInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for CopyMicromapInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`CopyMicromapToMemoryInfoEXT`] with lifetime-tied pNext safety.
pub struct CopyMicromapToMemoryInfoEXTBuilder<'a> {
    inner: CopyMicromapToMemoryInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl CopyMicromapToMemoryInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> CopyMicromapToMemoryInfoEXTBuilder<'a> {
        CopyMicromapToMemoryInfoEXTBuilder {
            inner: CopyMicromapToMemoryInfoEXT {
                s_type: StructureType::from_raw(1000396003i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> CopyMicromapToMemoryInfoEXTBuilder<'a> {
    #[inline]
    pub fn src(mut self, value: MicromapEXT) -> Self {
        self.inner.src = value;
        self
    }
    #[inline]
    pub fn dst(mut self, value: DeviceOrHostAddressKHR) -> Self {
        self.inner.dst = value;
        self
    }
    #[inline]
    pub fn mode(mut self, value: CopyMicromapModeEXT) -> Self {
        self.inner.mode = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`CopyMicromapToMemoryInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsCopyMicromapToMemoryInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for CopyMicromapToMemoryInfoEXTBuilder<'a> {
    type Target = CopyMicromapToMemoryInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for CopyMicromapToMemoryInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`CopyMemoryToMicromapInfoEXT`] with lifetime-tied pNext safety.
pub struct CopyMemoryToMicromapInfoEXTBuilder<'a> {
    inner: CopyMemoryToMicromapInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl CopyMemoryToMicromapInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> CopyMemoryToMicromapInfoEXTBuilder<'a> {
        CopyMemoryToMicromapInfoEXTBuilder {
            inner: CopyMemoryToMicromapInfoEXT {
                s_type: StructureType::from_raw(1000396004i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> CopyMemoryToMicromapInfoEXTBuilder<'a> {
    #[inline]
    pub fn src(mut self, value: DeviceOrHostAddressConstKHR) -> Self {
        self.inner.src = value;
        self
    }
    #[inline]
    pub fn dst(mut self, value: MicromapEXT) -> Self {
        self.inner.dst = value;
        self
    }
    #[inline]
    pub fn mode(mut self, value: CopyMicromapModeEXT) -> Self {
        self.inner.mode = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`CopyMemoryToMicromapInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsCopyMemoryToMicromapInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for CopyMemoryToMicromapInfoEXTBuilder<'a> {
    type Target = CopyMemoryToMicromapInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for CopyMemoryToMicromapInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`MicromapBuildSizesInfoEXT`] with lifetime-tied pNext safety.
pub struct MicromapBuildSizesInfoEXTBuilder<'a> {
    inner: MicromapBuildSizesInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl MicromapBuildSizesInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> MicromapBuildSizesInfoEXTBuilder<'a> {
        MicromapBuildSizesInfoEXTBuilder {
            inner: MicromapBuildSizesInfoEXT {
                s_type: StructureType::from_raw(1000396008i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> MicromapBuildSizesInfoEXTBuilder<'a> {
    #[inline]
    pub fn micromap_size(mut self, value: u64) -> Self {
        self.inner.micromap_size = value;
        self
    }
    #[inline]
    pub fn build_scratch_size(mut self, value: u64) -> Self {
        self.inner.build_scratch_size = value;
        self
    }
    #[inline]
    pub fn discardable(mut self, value: bool) -> Self {
        self.inner.discardable = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`MicromapBuildSizesInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsMicromapBuildSizesInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for MicromapBuildSizesInfoEXTBuilder<'a> {
    type Target = MicromapBuildSizesInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for MicromapBuildSizesInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`MicromapUsageEXT`].
pub struct MicromapUsageEXTBuilder {
    inner: MicromapUsageEXT,
}
impl MicromapUsageEXT {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> MicromapUsageEXTBuilder {
        MicromapUsageEXTBuilder {
            inner: MicromapUsageEXT {
                ..Default::default()
            },
        }
    }
}
impl MicromapUsageEXTBuilder {
    #[inline]
    pub fn count(mut self, value: u32) -> Self {
        self.inner.count = value;
        self
    }
    #[inline]
    pub fn subdivision_level(mut self, value: u32) -> Self {
        self.inner.subdivision_level = value;
        self
    }
    #[inline]
    pub fn format(mut self, value: u32) -> Self {
        self.inner.format = value;
        self
    }
}
impl core::ops::Deref for MicromapUsageEXTBuilder {
    type Target = MicromapUsageEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for MicromapUsageEXTBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`MicromapTriangleEXT`].
pub struct MicromapTriangleEXTBuilder {
    inner: MicromapTriangleEXT,
}
impl MicromapTriangleEXT {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> MicromapTriangleEXTBuilder {
        MicromapTriangleEXTBuilder {
            inner: MicromapTriangleEXT {
                ..Default::default()
            },
        }
    }
}
impl MicromapTriangleEXTBuilder {
    #[inline]
    pub fn data_offset(mut self, value: u32) -> Self {
        self.inner.data_offset = value;
        self
    }
    #[inline]
    pub fn subdivision_level(mut self, value: u16) -> Self {
        self.inner.subdivision_level = value;
        self
    }
    #[inline]
    pub fn format(mut self, value: u16) -> Self {
        self.inner.format = value;
        self
    }
}
impl core::ops::Deref for MicromapTriangleEXTBuilder {
    type Target = MicromapTriangleEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for MicromapTriangleEXTBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceOpacityMicromapFeaturesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceOpacityMicromapFeaturesEXTBuilder<'a> {
    inner: PhysicalDeviceOpacityMicromapFeaturesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceOpacityMicromapFeaturesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceOpacityMicromapFeaturesEXTBuilder<'a> {
        PhysicalDeviceOpacityMicromapFeaturesEXTBuilder {
            inner: PhysicalDeviceOpacityMicromapFeaturesEXT {
                s_type: StructureType::from_raw(1000396005i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceOpacityMicromapFeaturesEXTBuilder<'a> {
    #[inline]
    pub fn micromap(mut self, value: bool) -> Self {
        self.inner.micromap = value as u32;
        self
    }
    #[inline]
    pub fn micromap_capture_replay(mut self, value: bool) -> Self {
        self.inner.micromap_capture_replay = value as u32;
        self
    }
    #[inline]
    pub fn micromap_host_commands(mut self, value: bool) -> Self {
        self.inner.micromap_host_commands = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceOpacityMicromapFeaturesEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceOpacityMicromapFeaturesEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceOpacityMicromapFeaturesEXTBuilder<'a> {
    type Target = PhysicalDeviceOpacityMicromapFeaturesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceOpacityMicromapFeaturesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceOpacityMicromapPropertiesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceOpacityMicromapPropertiesEXTBuilder<'a> {
    inner: PhysicalDeviceOpacityMicromapPropertiesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceOpacityMicromapPropertiesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceOpacityMicromapPropertiesEXTBuilder<'a> {
        PhysicalDeviceOpacityMicromapPropertiesEXTBuilder {
            inner: PhysicalDeviceOpacityMicromapPropertiesEXT {
                s_type: StructureType::from_raw(1000396006i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceOpacityMicromapPropertiesEXTBuilder<'a> {
    #[inline]
    pub fn max_opacity2_state_subdivision_level(mut self, value: u32) -> Self {
        self.inner.max_opacity2_state_subdivision_level = value;
        self
    }
    #[inline]
    pub fn max_opacity4_state_subdivision_level(mut self, value: u32) -> Self {
        self.inner.max_opacity4_state_subdivision_level = value;
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceOpacityMicromapPropertiesEXTBuilder<'a> {
    type Target = PhysicalDeviceOpacityMicromapPropertiesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceOpacityMicromapPropertiesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`AccelerationStructureTrianglesOpacityMicromapEXT`] with lifetime-tied pNext safety.
pub struct AccelerationStructureTrianglesOpacityMicromapEXTBuilder<'a> {
    inner: AccelerationStructureTrianglesOpacityMicromapEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl AccelerationStructureTrianglesOpacityMicromapEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> AccelerationStructureTrianglesOpacityMicromapEXTBuilder<'a> {
        AccelerationStructureTrianglesOpacityMicromapEXTBuilder {
            inner: AccelerationStructureTrianglesOpacityMicromapEXT {
                s_type: StructureType::from_raw(1000396009i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> AccelerationStructureTrianglesOpacityMicromapEXTBuilder<'a> {
    #[inline]
    pub fn index_type(mut self, value: IndexType) -> Self {
        self.inner.index_type = value;
        self
    }
    #[inline]
    pub fn index_buffer(mut self, value: DeviceOrHostAddressConstKHR) -> Self {
        self.inner.index_buffer = value;
        self
    }
    #[inline]
    pub fn index_stride(mut self, value: u64) -> Self {
        self.inner.index_stride = value;
        self
    }
    #[inline]
    pub fn base_triangle(mut self, value: u32) -> Self {
        self.inner.base_triangle = value;
        self
    }
    #[inline]
    pub fn usage_counts_count(mut self, value: u32) -> Self {
        self.inner.usage_counts_count = value;
        self
    }
    #[inline]
    pub fn usage_counts(mut self, slice: &'a [MicromapUsageEXT]) -> Self {
        self.inner.usage_counts_count = slice.len() as u32;
        self.inner.p_usage_counts = slice.as_ptr();
        self
    }
    #[inline]
    pub fn pp_usage_counts(mut self, value: *const *const MicromapUsageEXT) -> Self {
        self.inner.pp_usage_counts = value;
        self
    }
    #[inline]
    pub fn micromap(mut self, value: MicromapEXT) -> Self {
        self.inner.micromap = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`AccelerationStructureTrianglesOpacityMicromapEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsAccelerationStructureTrianglesOpacityMicromapEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref
for AccelerationStructureTrianglesOpacityMicromapEXTBuilder<'a> {
    type Target = AccelerationStructureTrianglesOpacityMicromapEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for AccelerationStructureTrianglesOpacityMicromapEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceDisplacementMicromapFeaturesNV`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceDisplacementMicromapFeaturesNVBuilder<'a> {
    inner: PhysicalDeviceDisplacementMicromapFeaturesNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceDisplacementMicromapFeaturesNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceDisplacementMicromapFeaturesNVBuilder<'a> {
        PhysicalDeviceDisplacementMicromapFeaturesNVBuilder {
            inner: PhysicalDeviceDisplacementMicromapFeaturesNV {
                s_type: StructureType::from_raw(1000397000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceDisplacementMicromapFeaturesNVBuilder<'a> {
    #[inline]
    pub fn displacement_micromap(mut self, value: bool) -> Self {
        self.inner.displacement_micromap = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceDisplacementMicromapFeaturesNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceDisplacementMicromapFeaturesNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceDisplacementMicromapFeaturesNVBuilder<'a> {
    type Target = PhysicalDeviceDisplacementMicromapFeaturesNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceDisplacementMicromapFeaturesNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceDisplacementMicromapPropertiesNV`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceDisplacementMicromapPropertiesNVBuilder<'a> {
    inner: PhysicalDeviceDisplacementMicromapPropertiesNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceDisplacementMicromapPropertiesNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceDisplacementMicromapPropertiesNVBuilder<'a> {
        PhysicalDeviceDisplacementMicromapPropertiesNVBuilder {
            inner: PhysicalDeviceDisplacementMicromapPropertiesNV {
                s_type: StructureType::from_raw(1000397001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceDisplacementMicromapPropertiesNVBuilder<'a> {
    #[inline]
    pub fn max_displacement_micromap_subdivision_level(mut self, value: u32) -> Self {
        self.inner.max_displacement_micromap_subdivision_level = value;
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceDisplacementMicromapPropertiesNVBuilder<'a> {
    type Target = PhysicalDeviceDisplacementMicromapPropertiesNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceDisplacementMicromapPropertiesNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`AccelerationStructureTrianglesDisplacementMicromapNV`] with lifetime-tied pNext safety.
pub struct AccelerationStructureTrianglesDisplacementMicromapNVBuilder<'a> {
    inner: AccelerationStructureTrianglesDisplacementMicromapNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl AccelerationStructureTrianglesDisplacementMicromapNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> AccelerationStructureTrianglesDisplacementMicromapNVBuilder<
        'a,
    > {
        AccelerationStructureTrianglesDisplacementMicromapNVBuilder {
            inner: AccelerationStructureTrianglesDisplacementMicromapNV {
                s_type: StructureType::from_raw(1000397002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> AccelerationStructureTrianglesDisplacementMicromapNVBuilder<'a> {
    #[inline]
    pub fn displacement_bias_and_scale_format(mut self, value: Format) -> Self {
        self.inner.displacement_bias_and_scale_format = value;
        self
    }
    #[inline]
    pub fn displacement_vector_format(mut self, value: Format) -> Self {
        self.inner.displacement_vector_format = value;
        self
    }
    #[inline]
    pub fn displacement_bias_and_scale_buffer(
        mut self,
        value: DeviceOrHostAddressConstKHR,
    ) -> Self {
        self.inner.displacement_bias_and_scale_buffer = value;
        self
    }
    #[inline]
    pub fn displacement_bias_and_scale_stride(mut self, value: u64) -> Self {
        self.inner.displacement_bias_and_scale_stride = value;
        self
    }
    #[inline]
    pub fn displacement_vector_buffer(
        mut self,
        value: DeviceOrHostAddressConstKHR,
    ) -> Self {
        self.inner.displacement_vector_buffer = value;
        self
    }
    #[inline]
    pub fn displacement_vector_stride(mut self, value: u64) -> Self {
        self.inner.displacement_vector_stride = value;
        self
    }
    #[inline]
    pub fn displaced_micromap_primitive_flags(
        mut self,
        value: DeviceOrHostAddressConstKHR,
    ) -> Self {
        self.inner.displaced_micromap_primitive_flags = value;
        self
    }
    #[inline]
    pub fn displaced_micromap_primitive_flags_stride(mut self, value: u64) -> Self {
        self.inner.displaced_micromap_primitive_flags_stride = value;
        self
    }
    #[inline]
    pub fn index_type(mut self, value: IndexType) -> Self {
        self.inner.index_type = value;
        self
    }
    #[inline]
    pub fn index_buffer(mut self, value: DeviceOrHostAddressConstKHR) -> Self {
        self.inner.index_buffer = value;
        self
    }
    #[inline]
    pub fn index_stride(mut self, value: u64) -> Self {
        self.inner.index_stride = value;
        self
    }
    #[inline]
    pub fn base_triangle(mut self, value: u32) -> Self {
        self.inner.base_triangle = value;
        self
    }
    #[inline]
    pub fn usage_counts_count(mut self, value: u32) -> Self {
        self.inner.usage_counts_count = value;
        self
    }
    #[inline]
    pub fn usage_counts(mut self, slice: &'a [MicromapUsageEXT]) -> Self {
        self.inner.usage_counts_count = slice.len() as u32;
        self.inner.p_usage_counts = slice.as_ptr();
        self
    }
    #[inline]
    pub fn pp_usage_counts(mut self, value: *const *const MicromapUsageEXT) -> Self {
        self.inner.pp_usage_counts = value;
        self
    }
    #[inline]
    pub fn micromap(mut self, value: MicromapEXT) -> Self {
        self.inner.micromap = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`AccelerationStructureTrianglesDisplacementMicromapNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsAccelerationStructureTrianglesDisplacementMicromapNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref
for AccelerationStructureTrianglesDisplacementMicromapNVBuilder<'a> {
    type Target = AccelerationStructureTrianglesDisplacementMicromapNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for AccelerationStructureTrianglesDisplacementMicromapNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PipelinePropertiesIdentifierEXT`] with lifetime-tied pNext safety.
pub struct PipelinePropertiesIdentifierEXTBuilder<'a> {
    inner: PipelinePropertiesIdentifierEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PipelinePropertiesIdentifierEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PipelinePropertiesIdentifierEXTBuilder<'a> {
        PipelinePropertiesIdentifierEXTBuilder {
            inner: PipelinePropertiesIdentifierEXT {
                s_type: StructureType::from_raw(1000372000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PipelinePropertiesIdentifierEXTBuilder<'a> {
    #[inline]
    pub fn pipeline_identifier(mut self, value: [u8; UUID_SIZE as usize]) -> Self {
        self.inner.pipeline_identifier = value;
        self
    }
}
impl<'a> core::ops::Deref for PipelinePropertiesIdentifierEXTBuilder<'a> {
    type Target = PipelinePropertiesIdentifierEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PipelinePropertiesIdentifierEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDevicePipelinePropertiesFeaturesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDevicePipelinePropertiesFeaturesEXTBuilder<'a> {
    inner: PhysicalDevicePipelinePropertiesFeaturesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDevicePipelinePropertiesFeaturesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDevicePipelinePropertiesFeaturesEXTBuilder<'a> {
        PhysicalDevicePipelinePropertiesFeaturesEXTBuilder {
            inner: PhysicalDevicePipelinePropertiesFeaturesEXT {
                s_type: StructureType::from_raw(1000372001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDevicePipelinePropertiesFeaturesEXTBuilder<'a> {
    #[inline]
    pub fn pipeline_properties_identifier(mut self, value: bool) -> Self {
        self.inner.pipeline_properties_identifier = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDevicePipelinePropertiesFeaturesEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDevicePipelinePropertiesFeaturesEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDevicePipelinePropertiesFeaturesEXTBuilder<'a> {
    type Target = PhysicalDevicePipelinePropertiesFeaturesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDevicePipelinePropertiesFeaturesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMDBuilder<'a> {
    inner: PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMDBuilder<
        'a,
    > {
        PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMDBuilder {
            inner: PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD {
                s_type: StructureType::from_raw(1000321000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMDBuilder<'a> {
    #[inline]
    pub fn shader_early_and_late_fragment_tests(mut self, value: bool) -> Self {
        self.inner.shader_early_and_late_fragment_tests = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMDBuilder<'a> {
    type Target = PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMDBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ExternalMemoryAcquireUnmodifiedEXT`] with lifetime-tied pNext safety.
pub struct ExternalMemoryAcquireUnmodifiedEXTBuilder<'a> {
    inner: ExternalMemoryAcquireUnmodifiedEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ExternalMemoryAcquireUnmodifiedEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ExternalMemoryAcquireUnmodifiedEXTBuilder<'a> {
        ExternalMemoryAcquireUnmodifiedEXTBuilder {
            inner: ExternalMemoryAcquireUnmodifiedEXT {
                s_type: StructureType::from_raw(1000453000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ExternalMemoryAcquireUnmodifiedEXTBuilder<'a> {
    #[inline]
    pub fn acquire_unmodified_memory(mut self, value: bool) -> Self {
        self.inner.acquire_unmodified_memory = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`ExternalMemoryAcquireUnmodifiedEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsExternalMemoryAcquireUnmodifiedEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for ExternalMemoryAcquireUnmodifiedEXTBuilder<'a> {
    type Target = ExternalMemoryAcquireUnmodifiedEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ExternalMemoryAcquireUnmodifiedEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ExportMetalObjectCreateInfoEXT`] with lifetime-tied pNext safety.
pub struct ExportMetalObjectCreateInfoEXTBuilder<'a> {
    inner: ExportMetalObjectCreateInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ExportMetalObjectCreateInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ExportMetalObjectCreateInfoEXTBuilder<'a> {
        ExportMetalObjectCreateInfoEXTBuilder {
            inner: ExportMetalObjectCreateInfoEXT {
                s_type: StructureType::from_raw(1000311000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ExportMetalObjectCreateInfoEXTBuilder<'a> {
    #[inline]
    pub fn export_object_type(
        mut self,
        value: ExportMetalObjectTypeFlagBitsEXT,
    ) -> Self {
        self.inner.export_object_type = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`ExportMetalObjectCreateInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsExportMetalObjectCreateInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for ExportMetalObjectCreateInfoEXTBuilder<'a> {
    type Target = ExportMetalObjectCreateInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ExportMetalObjectCreateInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ExportMetalObjectsInfoEXT`] with lifetime-tied pNext safety.
pub struct ExportMetalObjectsInfoEXTBuilder<'a> {
    inner: ExportMetalObjectsInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ExportMetalObjectsInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ExportMetalObjectsInfoEXTBuilder<'a> {
        ExportMetalObjectsInfoEXTBuilder {
            inner: ExportMetalObjectsInfoEXT {
                s_type: StructureType::from_raw(1000311001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ExportMetalObjectsInfoEXTBuilder<'a> {
    ///Prepend a struct to the pNext chain. See [`ExportMetalObjectsInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsExportMetalObjectsInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for ExportMetalObjectsInfoEXTBuilder<'a> {
    type Target = ExportMetalObjectsInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ExportMetalObjectsInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ExportMetalDeviceInfoEXT`] with lifetime-tied pNext safety.
pub struct ExportMetalDeviceInfoEXTBuilder<'a> {
    inner: ExportMetalDeviceInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ExportMetalDeviceInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ExportMetalDeviceInfoEXTBuilder<'a> {
        ExportMetalDeviceInfoEXTBuilder {
            inner: ExportMetalDeviceInfoEXT {
                s_type: StructureType::from_raw(1000311002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ExportMetalDeviceInfoEXTBuilder<'a> {
    #[inline]
    pub fn mtl_device(mut self, value: *const core::ffi::c_void) -> Self {
        self.inner.mtl_device = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`ExportMetalDeviceInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsExportMetalDeviceInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for ExportMetalDeviceInfoEXTBuilder<'a> {
    type Target = ExportMetalDeviceInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ExportMetalDeviceInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ExportMetalCommandQueueInfoEXT`] with lifetime-tied pNext safety.
pub struct ExportMetalCommandQueueInfoEXTBuilder<'a> {
    inner: ExportMetalCommandQueueInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ExportMetalCommandQueueInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ExportMetalCommandQueueInfoEXTBuilder<'a> {
        ExportMetalCommandQueueInfoEXTBuilder {
            inner: ExportMetalCommandQueueInfoEXT {
                s_type: StructureType::from_raw(1000311003i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ExportMetalCommandQueueInfoEXTBuilder<'a> {
    #[inline]
    pub fn queue(mut self, value: Queue) -> Self {
        self.inner.queue = value;
        self
    }
    #[inline]
    pub fn mtl_command_queue(mut self, value: *const core::ffi::c_void) -> Self {
        self.inner.mtl_command_queue = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`ExportMetalCommandQueueInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsExportMetalCommandQueueInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for ExportMetalCommandQueueInfoEXTBuilder<'a> {
    type Target = ExportMetalCommandQueueInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ExportMetalCommandQueueInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ExportMetalBufferInfoEXT`] with lifetime-tied pNext safety.
pub struct ExportMetalBufferInfoEXTBuilder<'a> {
    inner: ExportMetalBufferInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ExportMetalBufferInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ExportMetalBufferInfoEXTBuilder<'a> {
        ExportMetalBufferInfoEXTBuilder {
            inner: ExportMetalBufferInfoEXT {
                s_type: StructureType::from_raw(1000311004i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ExportMetalBufferInfoEXTBuilder<'a> {
    #[inline]
    pub fn memory(mut self, value: DeviceMemory) -> Self {
        self.inner.memory = value;
        self
    }
    #[inline]
    pub fn mtl_buffer(mut self, value: *const core::ffi::c_void) -> Self {
        self.inner.mtl_buffer = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`ExportMetalBufferInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsExportMetalBufferInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for ExportMetalBufferInfoEXTBuilder<'a> {
    type Target = ExportMetalBufferInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ExportMetalBufferInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ImportMetalBufferInfoEXT`] with lifetime-tied pNext safety.
pub struct ImportMetalBufferInfoEXTBuilder<'a> {
    inner: ImportMetalBufferInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ImportMetalBufferInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ImportMetalBufferInfoEXTBuilder<'a> {
        ImportMetalBufferInfoEXTBuilder {
            inner: ImportMetalBufferInfoEXT {
                s_type: StructureType::from_raw(1000311005i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ImportMetalBufferInfoEXTBuilder<'a> {
    #[inline]
    pub fn mtl_buffer(mut self, value: *const core::ffi::c_void) -> Self {
        self.inner.mtl_buffer = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`ImportMetalBufferInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsImportMetalBufferInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for ImportMetalBufferInfoEXTBuilder<'a> {
    type Target = ImportMetalBufferInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ImportMetalBufferInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ExportMetalTextureInfoEXT`] with lifetime-tied pNext safety.
pub struct ExportMetalTextureInfoEXTBuilder<'a> {
    inner: ExportMetalTextureInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ExportMetalTextureInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ExportMetalTextureInfoEXTBuilder<'a> {
        ExportMetalTextureInfoEXTBuilder {
            inner: ExportMetalTextureInfoEXT {
                s_type: StructureType::from_raw(1000311006i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ExportMetalTextureInfoEXTBuilder<'a> {
    #[inline]
    pub fn image(mut self, value: Image) -> Self {
        self.inner.image = value;
        self
    }
    #[inline]
    pub fn image_view(mut self, value: ImageView) -> Self {
        self.inner.image_view = value;
        self
    }
    #[inline]
    pub fn buffer_view(mut self, value: BufferView) -> Self {
        self.inner.buffer_view = value;
        self
    }
    #[inline]
    pub fn plane(mut self, value: ImageAspectFlagBits) -> Self {
        self.inner.plane = value;
        self
    }
    #[inline]
    pub fn mtl_texture(mut self, value: *const core::ffi::c_void) -> Self {
        self.inner.mtl_texture = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`ExportMetalTextureInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsExportMetalTextureInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for ExportMetalTextureInfoEXTBuilder<'a> {
    type Target = ExportMetalTextureInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ExportMetalTextureInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ImportMetalTextureInfoEXT`] with lifetime-tied pNext safety.
pub struct ImportMetalTextureInfoEXTBuilder<'a> {
    inner: ImportMetalTextureInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ImportMetalTextureInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ImportMetalTextureInfoEXTBuilder<'a> {
        ImportMetalTextureInfoEXTBuilder {
            inner: ImportMetalTextureInfoEXT {
                s_type: StructureType::from_raw(1000311007i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ImportMetalTextureInfoEXTBuilder<'a> {
    #[inline]
    pub fn plane(mut self, value: ImageAspectFlagBits) -> Self {
        self.inner.plane = value;
        self
    }
    #[inline]
    pub fn mtl_texture(mut self, value: *const core::ffi::c_void) -> Self {
        self.inner.mtl_texture = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`ImportMetalTextureInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsImportMetalTextureInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for ImportMetalTextureInfoEXTBuilder<'a> {
    type Target = ImportMetalTextureInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ImportMetalTextureInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ExportMetalIOSurfaceInfoEXT`] with lifetime-tied pNext safety.
pub struct ExportMetalIOSurfaceInfoEXTBuilder<'a> {
    inner: ExportMetalIOSurfaceInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ExportMetalIOSurfaceInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ExportMetalIOSurfaceInfoEXTBuilder<'a> {
        ExportMetalIOSurfaceInfoEXTBuilder {
            inner: ExportMetalIOSurfaceInfoEXT {
                s_type: StructureType::from_raw(1000311008i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ExportMetalIOSurfaceInfoEXTBuilder<'a> {
    #[inline]
    pub fn image(mut self, value: Image) -> Self {
        self.inner.image = value;
        self
    }
    #[inline]
    pub fn io_surface(mut self, value: *const core::ffi::c_void) -> Self {
        self.inner.io_surface = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`ExportMetalIOSurfaceInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsExportMetalIOSurfaceInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for ExportMetalIOSurfaceInfoEXTBuilder<'a> {
    type Target = ExportMetalIOSurfaceInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ExportMetalIOSurfaceInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ImportMetalIOSurfaceInfoEXT`] with lifetime-tied pNext safety.
pub struct ImportMetalIOSurfaceInfoEXTBuilder<'a> {
    inner: ImportMetalIOSurfaceInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ImportMetalIOSurfaceInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ImportMetalIOSurfaceInfoEXTBuilder<'a> {
        ImportMetalIOSurfaceInfoEXTBuilder {
            inner: ImportMetalIOSurfaceInfoEXT {
                s_type: StructureType::from_raw(1000311009i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ImportMetalIOSurfaceInfoEXTBuilder<'a> {
    #[inline]
    pub fn io_surface(mut self, value: *const core::ffi::c_void) -> Self {
        self.inner.io_surface = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`ImportMetalIOSurfaceInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsImportMetalIOSurfaceInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for ImportMetalIOSurfaceInfoEXTBuilder<'a> {
    type Target = ImportMetalIOSurfaceInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ImportMetalIOSurfaceInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ExportMetalSharedEventInfoEXT`] with lifetime-tied pNext safety.
pub struct ExportMetalSharedEventInfoEXTBuilder<'a> {
    inner: ExportMetalSharedEventInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ExportMetalSharedEventInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ExportMetalSharedEventInfoEXTBuilder<'a> {
        ExportMetalSharedEventInfoEXTBuilder {
            inner: ExportMetalSharedEventInfoEXT {
                s_type: StructureType::from_raw(1000311010i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ExportMetalSharedEventInfoEXTBuilder<'a> {
    #[inline]
    pub fn semaphore(mut self, value: Semaphore) -> Self {
        self.inner.semaphore = value;
        self
    }
    #[inline]
    pub fn event(mut self, value: Event) -> Self {
        self.inner.event = value;
        self
    }
    #[inline]
    pub fn mtl_shared_event(mut self, value: *const core::ffi::c_void) -> Self {
        self.inner.mtl_shared_event = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`ExportMetalSharedEventInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsExportMetalSharedEventInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for ExportMetalSharedEventInfoEXTBuilder<'a> {
    type Target = ExportMetalSharedEventInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ExportMetalSharedEventInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ImportMetalSharedEventInfoEXT`] with lifetime-tied pNext safety.
pub struct ImportMetalSharedEventInfoEXTBuilder<'a> {
    inner: ImportMetalSharedEventInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ImportMetalSharedEventInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ImportMetalSharedEventInfoEXTBuilder<'a> {
        ImportMetalSharedEventInfoEXTBuilder {
            inner: ImportMetalSharedEventInfoEXT {
                s_type: StructureType::from_raw(1000311011i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ImportMetalSharedEventInfoEXTBuilder<'a> {
    #[inline]
    pub fn mtl_shared_event(mut self, value: *const core::ffi::c_void) -> Self {
        self.inner.mtl_shared_event = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`ImportMetalSharedEventInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsImportMetalSharedEventInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for ImportMetalSharedEventInfoEXTBuilder<'a> {
    type Target = ImportMetalSharedEventInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ImportMetalSharedEventInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceNonSeamlessCubeMapFeaturesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceNonSeamlessCubeMapFeaturesEXTBuilder<'a> {
    inner: PhysicalDeviceNonSeamlessCubeMapFeaturesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceNonSeamlessCubeMapFeaturesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceNonSeamlessCubeMapFeaturesEXTBuilder<'a> {
        PhysicalDeviceNonSeamlessCubeMapFeaturesEXTBuilder {
            inner: PhysicalDeviceNonSeamlessCubeMapFeaturesEXT {
                s_type: StructureType::from_raw(1000422000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceNonSeamlessCubeMapFeaturesEXTBuilder<'a> {
    #[inline]
    pub fn non_seamless_cube_map(mut self, value: bool) -> Self {
        self.inner.non_seamless_cube_map = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceNonSeamlessCubeMapFeaturesEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceNonSeamlessCubeMapFeaturesEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceNonSeamlessCubeMapFeaturesEXTBuilder<'a> {
    type Target = PhysicalDeviceNonSeamlessCubeMapFeaturesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceNonSeamlessCubeMapFeaturesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDevicePipelineRobustnessFeatures`] with lifetime-tied pNext safety.
pub struct PhysicalDevicePipelineRobustnessFeaturesBuilder<'a> {
    inner: PhysicalDevicePipelineRobustnessFeatures,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDevicePipelineRobustnessFeatures {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDevicePipelineRobustnessFeaturesBuilder<'a> {
        PhysicalDevicePipelineRobustnessFeaturesBuilder {
            inner: PhysicalDevicePipelineRobustnessFeatures {
                s_type: StructureType::from_raw(1000068001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDevicePipelineRobustnessFeaturesBuilder<'a> {
    #[inline]
    pub fn pipeline_robustness(mut self, value: bool) -> Self {
        self.inner.pipeline_robustness = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDevicePipelineRobustnessFeatures`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDevicePipelineRobustnessFeatures>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDevicePipelineRobustnessFeaturesBuilder<'a> {
    type Target = PhysicalDevicePipelineRobustnessFeatures;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDevicePipelineRobustnessFeaturesBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PipelineRobustnessCreateInfo`] with lifetime-tied pNext safety.
pub struct PipelineRobustnessCreateInfoBuilder<'a> {
    inner: PipelineRobustnessCreateInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PipelineRobustnessCreateInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PipelineRobustnessCreateInfoBuilder<'a> {
        PipelineRobustnessCreateInfoBuilder {
            inner: PipelineRobustnessCreateInfo {
                s_type: StructureType::from_raw(1000068000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PipelineRobustnessCreateInfoBuilder<'a> {
    #[inline]
    pub fn storage_buffers(mut self, value: PipelineRobustnessBufferBehavior) -> Self {
        self.inner.storage_buffers = value;
        self
    }
    #[inline]
    pub fn uniform_buffers(mut self, value: PipelineRobustnessBufferBehavior) -> Self {
        self.inner.uniform_buffers = value;
        self
    }
    #[inline]
    pub fn vertex_inputs(mut self, value: PipelineRobustnessBufferBehavior) -> Self {
        self.inner.vertex_inputs = value;
        self
    }
    #[inline]
    pub fn images(mut self, value: PipelineRobustnessImageBehavior) -> Self {
        self.inner.images = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PipelineRobustnessCreateInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPipelineRobustnessCreateInfo>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for PipelineRobustnessCreateInfoBuilder<'a> {
    type Target = PipelineRobustnessCreateInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PipelineRobustnessCreateInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDevicePipelineRobustnessProperties`] with lifetime-tied pNext safety.
pub struct PhysicalDevicePipelineRobustnessPropertiesBuilder<'a> {
    inner: PhysicalDevicePipelineRobustnessProperties,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDevicePipelineRobustnessProperties {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDevicePipelineRobustnessPropertiesBuilder<'a> {
        PhysicalDevicePipelineRobustnessPropertiesBuilder {
            inner: PhysicalDevicePipelineRobustnessProperties {
                s_type: StructureType::from_raw(1000068002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDevicePipelineRobustnessPropertiesBuilder<'a> {
    #[inline]
    pub fn default_robustness_storage_buffers(
        mut self,
        value: PipelineRobustnessBufferBehavior,
    ) -> Self {
        self.inner.default_robustness_storage_buffers = value;
        self
    }
    #[inline]
    pub fn default_robustness_uniform_buffers(
        mut self,
        value: PipelineRobustnessBufferBehavior,
    ) -> Self {
        self.inner.default_robustness_uniform_buffers = value;
        self
    }
    #[inline]
    pub fn default_robustness_vertex_inputs(
        mut self,
        value: PipelineRobustnessBufferBehavior,
    ) -> Self {
        self.inner.default_robustness_vertex_inputs = value;
        self
    }
    #[inline]
    pub fn default_robustness_images(
        mut self,
        value: PipelineRobustnessImageBehavior,
    ) -> Self {
        self.inner.default_robustness_images = value;
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDevicePipelineRobustnessPropertiesBuilder<'a> {
    type Target = PhysicalDevicePipelineRobustnessProperties;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDevicePipelineRobustnessPropertiesBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ImageViewSampleWeightCreateInfoQCOM`] with lifetime-tied pNext safety.
pub struct ImageViewSampleWeightCreateInfoQCOMBuilder<'a> {
    inner: ImageViewSampleWeightCreateInfoQCOM,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ImageViewSampleWeightCreateInfoQCOM {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ImageViewSampleWeightCreateInfoQCOMBuilder<'a> {
        ImageViewSampleWeightCreateInfoQCOMBuilder {
            inner: ImageViewSampleWeightCreateInfoQCOM {
                s_type: StructureType::from_raw(1000440002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ImageViewSampleWeightCreateInfoQCOMBuilder<'a> {
    #[inline]
    pub fn filter_center(mut self, value: Offset2D) -> Self {
        self.inner.filter_center = value;
        self
    }
    #[inline]
    pub fn filter_size(mut self, value: Extent2D) -> Self {
        self.inner.filter_size = value;
        self
    }
    #[inline]
    pub fn num_phases(mut self, value: u32) -> Self {
        self.inner.num_phases = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`ImageViewSampleWeightCreateInfoQCOM`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsImageViewSampleWeightCreateInfoQCOM>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for ImageViewSampleWeightCreateInfoQCOMBuilder<'a> {
    type Target = ImageViewSampleWeightCreateInfoQCOM;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ImageViewSampleWeightCreateInfoQCOMBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceImageProcessingFeaturesQCOM`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceImageProcessingFeaturesQCOMBuilder<'a> {
    inner: PhysicalDeviceImageProcessingFeaturesQCOM,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceImageProcessingFeaturesQCOM {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceImageProcessingFeaturesQCOMBuilder<'a> {
        PhysicalDeviceImageProcessingFeaturesQCOMBuilder {
            inner: PhysicalDeviceImageProcessingFeaturesQCOM {
                s_type: StructureType::from_raw(1000440000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceImageProcessingFeaturesQCOMBuilder<'a> {
    #[inline]
    pub fn texture_sample_weighted(mut self, value: bool) -> Self {
        self.inner.texture_sample_weighted = value as u32;
        self
    }
    #[inline]
    pub fn texture_box_filter(mut self, value: bool) -> Self {
        self.inner.texture_box_filter = value as u32;
        self
    }
    #[inline]
    pub fn texture_block_match(mut self, value: bool) -> Self {
        self.inner.texture_block_match = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceImageProcessingFeaturesQCOM`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceImageProcessingFeaturesQCOM>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceImageProcessingFeaturesQCOMBuilder<'a> {
    type Target = PhysicalDeviceImageProcessingFeaturesQCOM;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceImageProcessingFeaturesQCOMBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceImageProcessingPropertiesQCOM`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceImageProcessingPropertiesQCOMBuilder<'a> {
    inner: PhysicalDeviceImageProcessingPropertiesQCOM,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceImageProcessingPropertiesQCOM {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceImageProcessingPropertiesQCOMBuilder<'a> {
        PhysicalDeviceImageProcessingPropertiesQCOMBuilder {
            inner: PhysicalDeviceImageProcessingPropertiesQCOM {
                s_type: StructureType::from_raw(1000440001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceImageProcessingPropertiesQCOMBuilder<'a> {
    #[inline]
    pub fn max_weight_filter_phases(mut self, value: u32) -> Self {
        self.inner.max_weight_filter_phases = value;
        self
    }
    #[inline]
    pub fn max_weight_filter_dimension(mut self, value: Extent2D) -> Self {
        self.inner.max_weight_filter_dimension = value;
        self
    }
    #[inline]
    pub fn max_block_match_region(mut self, value: Extent2D) -> Self {
        self.inner.max_block_match_region = value;
        self
    }
    #[inline]
    pub fn max_box_filter_block_size(mut self, value: Extent2D) -> Self {
        self.inner.max_box_filter_block_size = value;
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceImageProcessingPropertiesQCOMBuilder<'a> {
    type Target = PhysicalDeviceImageProcessingPropertiesQCOM;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceImageProcessingPropertiesQCOMBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceTilePropertiesFeaturesQCOM`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceTilePropertiesFeaturesQCOMBuilder<'a> {
    inner: PhysicalDeviceTilePropertiesFeaturesQCOM,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceTilePropertiesFeaturesQCOM {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceTilePropertiesFeaturesQCOMBuilder<'a> {
        PhysicalDeviceTilePropertiesFeaturesQCOMBuilder {
            inner: PhysicalDeviceTilePropertiesFeaturesQCOM {
                s_type: StructureType::from_raw(1000484000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceTilePropertiesFeaturesQCOMBuilder<'a> {
    #[inline]
    pub fn tile_properties(mut self, value: bool) -> Self {
        self.inner.tile_properties = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceTilePropertiesFeaturesQCOM`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceTilePropertiesFeaturesQCOM>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceTilePropertiesFeaturesQCOMBuilder<'a> {
    type Target = PhysicalDeviceTilePropertiesFeaturesQCOM;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceTilePropertiesFeaturesQCOMBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`TilePropertiesQCOM`] with lifetime-tied pNext safety.
pub struct TilePropertiesQCOMBuilder<'a> {
    inner: TilePropertiesQCOM,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl TilePropertiesQCOM {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> TilePropertiesQCOMBuilder<'a> {
        TilePropertiesQCOMBuilder {
            inner: TilePropertiesQCOM {
                s_type: StructureType::from_raw(1000484001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> TilePropertiesQCOMBuilder<'a> {
    #[inline]
    pub fn tile_size(mut self, value: Extent3D) -> Self {
        self.inner.tile_size = value;
        self
    }
    #[inline]
    pub fn apron_size(mut self, value: Extent2D) -> Self {
        self.inner.apron_size = value;
        self
    }
    #[inline]
    pub fn origin(mut self, value: Offset2D) -> Self {
        self.inner.origin = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`TilePropertiesQCOM`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsTilePropertiesQCOM>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for TilePropertiesQCOMBuilder<'a> {
    type Target = TilePropertiesQCOM;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for TilePropertiesQCOMBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`TileMemoryBindInfoQCOM`] with lifetime-tied pNext safety.
pub struct TileMemoryBindInfoQCOMBuilder<'a> {
    inner: TileMemoryBindInfoQCOM,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl TileMemoryBindInfoQCOM {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> TileMemoryBindInfoQCOMBuilder<'a> {
        TileMemoryBindInfoQCOMBuilder {
            inner: TileMemoryBindInfoQCOM {
                s_type: StructureType::from_raw(1000547003i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> TileMemoryBindInfoQCOMBuilder<'a> {
    #[inline]
    pub fn memory(mut self, value: DeviceMemory) -> Self {
        self.inner.memory = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`TileMemoryBindInfoQCOM`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsTileMemoryBindInfoQCOM>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for TileMemoryBindInfoQCOMBuilder<'a> {
    type Target = TileMemoryBindInfoQCOM;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for TileMemoryBindInfoQCOMBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceAmigoProfilingFeaturesSEC`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceAmigoProfilingFeaturesSECBuilder<'a> {
    inner: PhysicalDeviceAmigoProfilingFeaturesSEC,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceAmigoProfilingFeaturesSEC {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceAmigoProfilingFeaturesSECBuilder<'a> {
        PhysicalDeviceAmigoProfilingFeaturesSECBuilder {
            inner: PhysicalDeviceAmigoProfilingFeaturesSEC {
                s_type: StructureType::from_raw(1000485000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceAmigoProfilingFeaturesSECBuilder<'a> {
    #[inline]
    pub fn amigo_profiling(mut self, value: bool) -> Self {
        self.inner.amigo_profiling = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceAmigoProfilingFeaturesSEC`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceAmigoProfilingFeaturesSEC>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceAmigoProfilingFeaturesSECBuilder<'a> {
    type Target = PhysicalDeviceAmigoProfilingFeaturesSEC;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceAmigoProfilingFeaturesSECBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`AmigoProfilingSubmitInfoSEC`] with lifetime-tied pNext safety.
pub struct AmigoProfilingSubmitInfoSECBuilder<'a> {
    inner: AmigoProfilingSubmitInfoSEC,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl AmigoProfilingSubmitInfoSEC {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> AmigoProfilingSubmitInfoSECBuilder<'a> {
        AmigoProfilingSubmitInfoSECBuilder {
            inner: AmigoProfilingSubmitInfoSEC {
                s_type: StructureType::from_raw(1000485001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> AmigoProfilingSubmitInfoSECBuilder<'a> {
    #[inline]
    pub fn first_draw_timestamp(mut self, value: u64) -> Self {
        self.inner.first_draw_timestamp = value;
        self
    }
    #[inline]
    pub fn swap_buffer_timestamp(mut self, value: u64) -> Self {
        self.inner.swap_buffer_timestamp = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`AmigoProfilingSubmitInfoSEC`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsAmigoProfilingSubmitInfoSEC>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for AmigoProfilingSubmitInfoSECBuilder<'a> {
    type Target = AmigoProfilingSubmitInfoSEC;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for AmigoProfilingSubmitInfoSECBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXTBuilder<'a> {
    inner: PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXTBuilder<
        'a,
    > {
        PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXTBuilder {
            inner: PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT {
                s_type: StructureType::from_raw(1000339000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXTBuilder<'a> {
    #[inline]
    pub fn attachment_feedback_loop_layout(mut self, value: bool) -> Self {
        self.inner.attachment_feedback_loop_layout = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXTBuilder<'a> {
    type Target = PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`AttachmentFeedbackLoopInfoEXT`] with lifetime-tied pNext safety.
pub struct AttachmentFeedbackLoopInfoEXTBuilder<'a> {
    inner: AttachmentFeedbackLoopInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl AttachmentFeedbackLoopInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> AttachmentFeedbackLoopInfoEXTBuilder<'a> {
        AttachmentFeedbackLoopInfoEXTBuilder {
            inner: AttachmentFeedbackLoopInfoEXT {
                s_type: StructureType::from_raw(1000527001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> AttachmentFeedbackLoopInfoEXTBuilder<'a> {
    #[inline]
    pub fn feedback_loop_enable(mut self, value: bool) -> Self {
        self.inner.feedback_loop_enable = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`AttachmentFeedbackLoopInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsAttachmentFeedbackLoopInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for AttachmentFeedbackLoopInfoEXTBuilder<'a> {
    type Target = AttachmentFeedbackLoopInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for AttachmentFeedbackLoopInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceAddressBindingReportFeaturesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceAddressBindingReportFeaturesEXTBuilder<'a> {
    inner: PhysicalDeviceAddressBindingReportFeaturesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceAddressBindingReportFeaturesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceAddressBindingReportFeaturesEXTBuilder<'a> {
        PhysicalDeviceAddressBindingReportFeaturesEXTBuilder {
            inner: PhysicalDeviceAddressBindingReportFeaturesEXT {
                s_type: StructureType::from_raw(1000354000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceAddressBindingReportFeaturesEXTBuilder<'a> {
    #[inline]
    pub fn report_address_binding(mut self, value: bool) -> Self {
        self.inner.report_address_binding = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceAddressBindingReportFeaturesEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceAddressBindingReportFeaturesEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceAddressBindingReportFeaturesEXTBuilder<'a> {
    type Target = PhysicalDeviceAddressBindingReportFeaturesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceAddressBindingReportFeaturesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`RenderingAttachmentFlagsInfoKHR`] with lifetime-tied pNext safety.
pub struct RenderingAttachmentFlagsInfoKHRBuilder<'a> {
    inner: RenderingAttachmentFlagsInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl RenderingAttachmentFlagsInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> RenderingAttachmentFlagsInfoKHRBuilder<'a> {
        RenderingAttachmentFlagsInfoKHRBuilder {
            inner: RenderingAttachmentFlagsInfoKHR {
                s_type: StructureType::from_raw(1000630002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> RenderingAttachmentFlagsInfoKHRBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: RenderingAttachmentFlagsKHR) -> Self {
        self.inner.flags = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`RenderingAttachmentFlagsInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsRenderingAttachmentFlagsInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for RenderingAttachmentFlagsInfoKHRBuilder<'a> {
    type Target = RenderingAttachmentFlagsInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for RenderingAttachmentFlagsInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ResolveImageModeInfoKHR`] with lifetime-tied pNext safety.
pub struct ResolveImageModeInfoKHRBuilder<'a> {
    inner: ResolveImageModeInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ResolveImageModeInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ResolveImageModeInfoKHRBuilder<'a> {
        ResolveImageModeInfoKHRBuilder {
            inner: ResolveImageModeInfoKHR {
                s_type: StructureType::from_raw(1000630004i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ResolveImageModeInfoKHRBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: ResolveImageFlagsKHR) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn resolve_mode(mut self, value: ResolveModeFlagBits) -> Self {
        self.inner.resolve_mode = value;
        self
    }
    #[inline]
    pub fn stencil_resolve_mode(mut self, value: ResolveModeFlagBits) -> Self {
        self.inner.stencil_resolve_mode = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`ResolveImageModeInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsResolveImageModeInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for ResolveImageModeInfoKHRBuilder<'a> {
    type Target = ResolveImageModeInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ResolveImageModeInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DeviceAddressBindingCallbackDataEXT`] with lifetime-tied pNext safety.
pub struct DeviceAddressBindingCallbackDataEXTBuilder<'a> {
    inner: DeviceAddressBindingCallbackDataEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DeviceAddressBindingCallbackDataEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> DeviceAddressBindingCallbackDataEXTBuilder<'a> {
        DeviceAddressBindingCallbackDataEXTBuilder {
            inner: DeviceAddressBindingCallbackDataEXT {
                s_type: StructureType::from_raw(1000354001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DeviceAddressBindingCallbackDataEXTBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: DeviceAddressBindingFlagsEXT) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn base_address(mut self, value: u64) -> Self {
        self.inner.base_address = value;
        self
    }
    #[inline]
    pub fn size(mut self, value: u64) -> Self {
        self.inner.size = value;
        self
    }
    #[inline]
    pub fn binding_type(mut self, value: DeviceAddressBindingTypeEXT) -> Self {
        self.inner.binding_type = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`DeviceAddressBindingCallbackDataEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsDeviceAddressBindingCallbackDataEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for DeviceAddressBindingCallbackDataEXTBuilder<'a> {
    type Target = DeviceAddressBindingCallbackDataEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for DeviceAddressBindingCallbackDataEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceOpticalFlowFeaturesNV`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceOpticalFlowFeaturesNVBuilder<'a> {
    inner: PhysicalDeviceOpticalFlowFeaturesNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceOpticalFlowFeaturesNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceOpticalFlowFeaturesNVBuilder<'a> {
        PhysicalDeviceOpticalFlowFeaturesNVBuilder {
            inner: PhysicalDeviceOpticalFlowFeaturesNV {
                s_type: StructureType::from_raw(1000464000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceOpticalFlowFeaturesNVBuilder<'a> {
    #[inline]
    pub fn optical_flow(mut self, value: bool) -> Self {
        self.inner.optical_flow = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceOpticalFlowFeaturesNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceOpticalFlowFeaturesNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceOpticalFlowFeaturesNVBuilder<'a> {
    type Target = PhysicalDeviceOpticalFlowFeaturesNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceOpticalFlowFeaturesNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceOpticalFlowPropertiesNV`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceOpticalFlowPropertiesNVBuilder<'a> {
    inner: PhysicalDeviceOpticalFlowPropertiesNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceOpticalFlowPropertiesNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceOpticalFlowPropertiesNVBuilder<'a> {
        PhysicalDeviceOpticalFlowPropertiesNVBuilder {
            inner: PhysicalDeviceOpticalFlowPropertiesNV {
                s_type: StructureType::from_raw(1000464001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceOpticalFlowPropertiesNVBuilder<'a> {
    #[inline]
    pub fn supported_output_grid_sizes(
        mut self,
        value: OpticalFlowGridSizeFlagsNV,
    ) -> Self {
        self.inner.supported_output_grid_sizes = value;
        self
    }
    #[inline]
    pub fn supported_hint_grid_sizes(
        mut self,
        value: OpticalFlowGridSizeFlagsNV,
    ) -> Self {
        self.inner.supported_hint_grid_sizes = value;
        self
    }
    #[inline]
    pub fn hint_supported(mut self, value: bool) -> Self {
        self.inner.hint_supported = value as u32;
        self
    }
    #[inline]
    pub fn cost_supported(mut self, value: bool) -> Self {
        self.inner.cost_supported = value as u32;
        self
    }
    #[inline]
    pub fn bidirectional_flow_supported(mut self, value: bool) -> Self {
        self.inner.bidirectional_flow_supported = value as u32;
        self
    }
    #[inline]
    pub fn global_flow_supported(mut self, value: bool) -> Self {
        self.inner.global_flow_supported = value as u32;
        self
    }
    #[inline]
    pub fn min_width(mut self, value: u32) -> Self {
        self.inner.min_width = value;
        self
    }
    #[inline]
    pub fn min_height(mut self, value: u32) -> Self {
        self.inner.min_height = value;
        self
    }
    #[inline]
    pub fn max_width(mut self, value: u32) -> Self {
        self.inner.max_width = value;
        self
    }
    #[inline]
    pub fn max_height(mut self, value: u32) -> Self {
        self.inner.max_height = value;
        self
    }
    #[inline]
    pub fn max_num_regions_of_interest(mut self, value: u32) -> Self {
        self.inner.max_num_regions_of_interest = value;
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceOpticalFlowPropertiesNVBuilder<'a> {
    type Target = PhysicalDeviceOpticalFlowPropertiesNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceOpticalFlowPropertiesNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`OpticalFlowImageFormatInfoNV`] with lifetime-tied pNext safety.
pub struct OpticalFlowImageFormatInfoNVBuilder<'a> {
    inner: OpticalFlowImageFormatInfoNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl OpticalFlowImageFormatInfoNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> OpticalFlowImageFormatInfoNVBuilder<'a> {
        OpticalFlowImageFormatInfoNVBuilder {
            inner: OpticalFlowImageFormatInfoNV {
                s_type: StructureType::from_raw(1000464002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> OpticalFlowImageFormatInfoNVBuilder<'a> {
    #[inline]
    pub fn usage(mut self, value: OpticalFlowUsageFlagsNV) -> Self {
        self.inner.usage = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`OpticalFlowImageFormatInfoNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsOpticalFlowImageFormatInfoNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for OpticalFlowImageFormatInfoNVBuilder<'a> {
    type Target = OpticalFlowImageFormatInfoNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for OpticalFlowImageFormatInfoNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`OpticalFlowImageFormatPropertiesNV`] with lifetime-tied pNext safety.
pub struct OpticalFlowImageFormatPropertiesNVBuilder<'a> {
    inner: OpticalFlowImageFormatPropertiesNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl OpticalFlowImageFormatPropertiesNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> OpticalFlowImageFormatPropertiesNVBuilder<'a> {
        OpticalFlowImageFormatPropertiesNVBuilder {
            inner: OpticalFlowImageFormatPropertiesNV {
                s_type: StructureType::from_raw(1000464003i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> OpticalFlowImageFormatPropertiesNVBuilder<'a> {
    #[inline]
    pub fn format(mut self, value: Format) -> Self {
        self.inner.format = value;
        self
    }
}
impl<'a> core::ops::Deref for OpticalFlowImageFormatPropertiesNVBuilder<'a> {
    type Target = OpticalFlowImageFormatPropertiesNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for OpticalFlowImageFormatPropertiesNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`OpticalFlowSessionCreateInfoNV`] with lifetime-tied pNext safety.
pub struct OpticalFlowSessionCreateInfoNVBuilder<'a> {
    inner: OpticalFlowSessionCreateInfoNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl OpticalFlowSessionCreateInfoNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> OpticalFlowSessionCreateInfoNVBuilder<'a> {
        OpticalFlowSessionCreateInfoNVBuilder {
            inner: OpticalFlowSessionCreateInfoNV {
                s_type: StructureType::from_raw(1000464004i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> OpticalFlowSessionCreateInfoNVBuilder<'a> {
    #[inline]
    pub fn width(mut self, value: u32) -> Self {
        self.inner.width = value;
        self
    }
    #[inline]
    pub fn height(mut self, value: u32) -> Self {
        self.inner.height = value;
        self
    }
    #[inline]
    pub fn image_format(mut self, value: Format) -> Self {
        self.inner.image_format = value;
        self
    }
    #[inline]
    pub fn flow_vector_format(mut self, value: Format) -> Self {
        self.inner.flow_vector_format = value;
        self
    }
    #[inline]
    pub fn cost_format(mut self, value: Format) -> Self {
        self.inner.cost_format = value;
        self
    }
    #[inline]
    pub fn output_grid_size(mut self, value: OpticalFlowGridSizeFlagsNV) -> Self {
        self.inner.output_grid_size = value;
        self
    }
    #[inline]
    pub fn hint_grid_size(mut self, value: OpticalFlowGridSizeFlagsNV) -> Self {
        self.inner.hint_grid_size = value;
        self
    }
    #[inline]
    pub fn performance_level(mut self, value: OpticalFlowPerformanceLevelNV) -> Self {
        self.inner.performance_level = value;
        self
    }
    #[inline]
    pub fn flags(mut self, value: OpticalFlowSessionCreateFlagsNV) -> Self {
        self.inner.flags = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`OpticalFlowSessionCreateInfoNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsOpticalFlowSessionCreateInfoNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for OpticalFlowSessionCreateInfoNVBuilder<'a> {
    type Target = OpticalFlowSessionCreateInfoNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for OpticalFlowSessionCreateInfoNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`OpticalFlowSessionCreatePrivateDataInfoNV`] with lifetime-tied pNext safety.
pub struct OpticalFlowSessionCreatePrivateDataInfoNVBuilder<'a> {
    inner: OpticalFlowSessionCreatePrivateDataInfoNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl OpticalFlowSessionCreatePrivateDataInfoNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> OpticalFlowSessionCreatePrivateDataInfoNVBuilder<'a> {
        OpticalFlowSessionCreatePrivateDataInfoNVBuilder {
            inner: OpticalFlowSessionCreatePrivateDataInfoNV {
                s_type: StructureType::from_raw(1000464010i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> OpticalFlowSessionCreatePrivateDataInfoNVBuilder<'a> {
    #[inline]
    pub fn id(mut self, value: u32) -> Self {
        self.inner.id = value;
        self
    }
    #[inline]
    pub fn size(mut self, value: u32) -> Self {
        self.inner.size = value;
        self
    }
    #[inline]
    pub fn private_data(mut self, value: *const core::ffi::c_void) -> Self {
        self.inner.p_private_data = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`OpticalFlowSessionCreatePrivateDataInfoNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsOpticalFlowSessionCreatePrivateDataInfoNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for OpticalFlowSessionCreatePrivateDataInfoNVBuilder<'a> {
    type Target = OpticalFlowSessionCreatePrivateDataInfoNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for OpticalFlowSessionCreatePrivateDataInfoNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`OpticalFlowExecuteInfoNV`] with lifetime-tied pNext safety.
pub struct OpticalFlowExecuteInfoNVBuilder<'a> {
    inner: OpticalFlowExecuteInfoNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl OpticalFlowExecuteInfoNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> OpticalFlowExecuteInfoNVBuilder<'a> {
        OpticalFlowExecuteInfoNVBuilder {
            inner: OpticalFlowExecuteInfoNV {
                s_type: StructureType::from_raw(1000464005i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> OpticalFlowExecuteInfoNVBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: OpticalFlowExecuteFlagsNV) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn regions(mut self, slice: &'a [Rect2D]) -> Self {
        self.inner.region_count = slice.len() as u32;
        self.inner.p_regions = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`OpticalFlowExecuteInfoNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsOpticalFlowExecuteInfoNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for OpticalFlowExecuteInfoNVBuilder<'a> {
    type Target = OpticalFlowExecuteInfoNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for OpticalFlowExecuteInfoNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceFaultFeaturesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceFaultFeaturesEXTBuilder<'a> {
    inner: PhysicalDeviceFaultFeaturesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceFaultFeaturesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceFaultFeaturesEXTBuilder<'a> {
        PhysicalDeviceFaultFeaturesEXTBuilder {
            inner: PhysicalDeviceFaultFeaturesEXT {
                s_type: StructureType::from_raw(1000341000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceFaultFeaturesEXTBuilder<'a> {
    #[inline]
    pub fn device_fault(mut self, value: bool) -> Self {
        self.inner.device_fault = value as u32;
        self
    }
    #[inline]
    pub fn device_fault_vendor_binary(mut self, value: bool) -> Self {
        self.inner.device_fault_vendor_binary = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceFaultFeaturesEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceFaultFeaturesEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceFaultFeaturesEXTBuilder<'a> {
    type Target = PhysicalDeviceFaultFeaturesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceFaultFeaturesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DeviceFaultAddressInfoKHR`].
pub struct DeviceFaultAddressInfoKHRBuilder {
    inner: DeviceFaultAddressInfoKHR,
}
impl DeviceFaultAddressInfoKHR {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> DeviceFaultAddressInfoKHRBuilder {
        DeviceFaultAddressInfoKHRBuilder {
            inner: DeviceFaultAddressInfoKHR {
                ..Default::default()
            },
        }
    }
}
impl DeviceFaultAddressInfoKHRBuilder {
    #[inline]
    pub fn address_type(mut self, value: DeviceFaultAddressTypeKHR) -> Self {
        self.inner.address_type = value;
        self
    }
    #[inline]
    pub fn reported_address(mut self, value: u64) -> Self {
        self.inner.reported_address = value;
        self
    }
    #[inline]
    pub fn address_precision(mut self, value: u64) -> Self {
        self.inner.address_precision = value;
        self
    }
}
impl core::ops::Deref for DeviceFaultAddressInfoKHRBuilder {
    type Target = DeviceFaultAddressInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for DeviceFaultAddressInfoKHRBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DeviceFaultVendorInfoKHR`].
pub struct DeviceFaultVendorInfoKHRBuilder {
    inner: DeviceFaultVendorInfoKHR,
}
impl DeviceFaultVendorInfoKHR {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> DeviceFaultVendorInfoKHRBuilder {
        DeviceFaultVendorInfoKHRBuilder {
            inner: DeviceFaultVendorInfoKHR {
                ..Default::default()
            },
        }
    }
}
impl DeviceFaultVendorInfoKHRBuilder {
    #[inline]
    pub fn description(
        mut self,
        value: crate::StringArray<{ MAX_DESCRIPTION_SIZE as usize }>,
    ) -> Self {
        self.inner.description = value;
        self
    }
    #[inline]
    pub fn vendor_fault_code(mut self, value: u64) -> Self {
        self.inner.vendor_fault_code = value;
        self
    }
    #[inline]
    pub fn vendor_fault_data(mut self, value: u64) -> Self {
        self.inner.vendor_fault_data = value;
        self
    }
}
impl core::ops::Deref for DeviceFaultVendorInfoKHRBuilder {
    type Target = DeviceFaultVendorInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for DeviceFaultVendorInfoKHRBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DeviceFaultInfoKHR`] with lifetime-tied pNext safety.
pub struct DeviceFaultInfoKHRBuilder<'a> {
    inner: DeviceFaultInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DeviceFaultInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> DeviceFaultInfoKHRBuilder<'a> {
        DeviceFaultInfoKHRBuilder {
            inner: DeviceFaultInfoKHR {
                s_type: StructureType::from_raw(1000573002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DeviceFaultInfoKHRBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: DeviceFaultFlagsKHR) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn group_id(mut self, value: u64) -> Self {
        self.inner.group_id = value;
        self
    }
    #[inline]
    pub fn description(
        mut self,
        value: crate::StringArray<{ MAX_DESCRIPTION_SIZE as usize }>,
    ) -> Self {
        self.inner.description = value;
        self
    }
    #[inline]
    pub fn fault_address_info(mut self, value: DeviceFaultAddressInfoKHR) -> Self {
        self.inner.fault_address_info = value;
        self
    }
    #[inline]
    pub fn instruction_address_info(mut self, value: DeviceFaultAddressInfoKHR) -> Self {
        self.inner.instruction_address_info = value;
        self
    }
    #[inline]
    pub fn vendor_info(mut self, value: DeviceFaultVendorInfoKHR) -> Self {
        self.inner.vendor_info = value;
        self
    }
}
impl<'a> core::ops::Deref for DeviceFaultInfoKHRBuilder<'a> {
    type Target = DeviceFaultInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for DeviceFaultInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DeviceFaultDebugInfoKHR`] with lifetime-tied pNext safety.
pub struct DeviceFaultDebugInfoKHRBuilder<'a> {
    inner: DeviceFaultDebugInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DeviceFaultDebugInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> DeviceFaultDebugInfoKHRBuilder<'a> {
        DeviceFaultDebugInfoKHRBuilder {
            inner: DeviceFaultDebugInfoKHR {
                s_type: StructureType::from_raw(1000573003i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DeviceFaultDebugInfoKHRBuilder<'a> {
    #[inline]
    pub fn vendor_binary_size(mut self, value: u32) -> Self {
        self.inner.vendor_binary_size = value;
        self
    }
    #[inline]
    pub fn vendor_binary_data(mut self, slice: &'a mut [core::ffi::c_void]) -> Self {
        self.inner.vendor_binary_size = slice.len() as u32;
        self.inner.p_vendor_binary_data = slice.as_mut_ptr();
        self
    }
}
impl<'a> core::ops::Deref for DeviceFaultDebugInfoKHRBuilder<'a> {
    type Target = DeviceFaultDebugInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for DeviceFaultDebugInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DeviceFaultCountsEXT`] with lifetime-tied pNext safety.
pub struct DeviceFaultCountsEXTBuilder<'a> {
    inner: DeviceFaultCountsEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DeviceFaultCountsEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> DeviceFaultCountsEXTBuilder<'a> {
        DeviceFaultCountsEXTBuilder {
            inner: DeviceFaultCountsEXT {
                s_type: StructureType::from_raw(1000341001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DeviceFaultCountsEXTBuilder<'a> {
    #[inline]
    pub fn address_info_count(mut self, value: u32) -> Self {
        self.inner.address_info_count = value;
        self
    }
    #[inline]
    pub fn vendor_info_count(mut self, value: u32) -> Self {
        self.inner.vendor_info_count = value;
        self
    }
    #[inline]
    pub fn vendor_binary_size(mut self, value: u64) -> Self {
        self.inner.vendor_binary_size = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`DeviceFaultCountsEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsDeviceFaultCountsEXT>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for DeviceFaultCountsEXTBuilder<'a> {
    type Target = DeviceFaultCountsEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for DeviceFaultCountsEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DeviceFaultInfoEXT`] with lifetime-tied pNext safety.
pub struct DeviceFaultInfoEXTBuilder<'a> {
    inner: DeviceFaultInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DeviceFaultInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> DeviceFaultInfoEXTBuilder<'a> {
        DeviceFaultInfoEXTBuilder {
            inner: DeviceFaultInfoEXT {
                s_type: StructureType::from_raw(1000341002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DeviceFaultInfoEXTBuilder<'a> {
    #[inline]
    pub fn description(
        mut self,
        value: crate::StringArray<{ MAX_DESCRIPTION_SIZE as usize }>,
    ) -> Self {
        self.inner.description = value;
        self
    }
    #[inline]
    pub fn address_infos(mut self, value: *mut DeviceFaultAddressInfoKHR) -> Self {
        self.inner.p_address_infos = value;
        self
    }
    #[inline]
    pub fn vendor_infos(mut self, value: *mut DeviceFaultVendorInfoKHR) -> Self {
        self.inner.p_vendor_infos = value;
        self
    }
    #[inline]
    pub fn vendor_binary_data(mut self, value: *mut core::ffi::c_void) -> Self {
        self.inner.p_vendor_binary_data = value;
        self
    }
}
impl<'a> core::ops::Deref for DeviceFaultInfoEXTBuilder<'a> {
    type Target = DeviceFaultInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for DeviceFaultInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DeviceFaultVendorBinaryHeaderVersionOneKHR`].
pub struct DeviceFaultVendorBinaryHeaderVersionOneKHRBuilder {
    inner: DeviceFaultVendorBinaryHeaderVersionOneKHR,
}
impl DeviceFaultVendorBinaryHeaderVersionOneKHR {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> DeviceFaultVendorBinaryHeaderVersionOneKHRBuilder {
        DeviceFaultVendorBinaryHeaderVersionOneKHRBuilder {
            inner: DeviceFaultVendorBinaryHeaderVersionOneKHR {
                ..Default::default()
            },
        }
    }
}
impl DeviceFaultVendorBinaryHeaderVersionOneKHRBuilder {
    #[inline]
    pub fn header_size(mut self, value: u32) -> Self {
        self.inner.header_size = value;
        self
    }
    #[inline]
    pub fn header_version(
        mut self,
        value: DeviceFaultVendorBinaryHeaderVersionKHR,
    ) -> Self {
        self.inner.header_version = value;
        self
    }
    #[inline]
    pub fn vendor_id(mut self, value: u32) -> Self {
        self.inner.vendor_id = value;
        self
    }
    #[inline]
    pub fn device_id(mut self, value: u32) -> Self {
        self.inner.device_id = value;
        self
    }
    #[inline]
    pub fn driver_version(mut self, value: u32) -> Self {
        self.inner.driver_version = value;
        self
    }
    #[inline]
    pub fn pipeline_cache_uuid(mut self, value: [u8; UUID_SIZE as usize]) -> Self {
        self.inner.pipeline_cache_uuid = value;
        self
    }
    #[inline]
    pub fn application_name_offset(mut self, value: u32) -> Self {
        self.inner.application_name_offset = value;
        self
    }
    #[inline]
    pub fn application_version(mut self, value: u32) -> Self {
        self.inner.application_version = value;
        self
    }
    #[inline]
    pub fn engine_name_offset(mut self, value: u32) -> Self {
        self.inner.engine_name_offset = value;
        self
    }
    #[inline]
    pub fn engine_version(mut self, value: u32) -> Self {
        self.inner.engine_version = value;
        self
    }
    #[inline]
    pub fn api_version(mut self, value: u32) -> Self {
        self.inner.api_version = value;
        self
    }
}
impl core::ops::Deref for DeviceFaultVendorBinaryHeaderVersionOneKHRBuilder {
    type Target = DeviceFaultVendorBinaryHeaderVersionOneKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for DeviceFaultVendorBinaryHeaderVersionOneKHRBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceFaultFeaturesKHR`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceFaultFeaturesKHRBuilder<'a> {
    inner: PhysicalDeviceFaultFeaturesKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceFaultFeaturesKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceFaultFeaturesKHRBuilder<'a> {
        PhysicalDeviceFaultFeaturesKHRBuilder {
            inner: PhysicalDeviceFaultFeaturesKHR {
                s_type: StructureType::from_raw(1000573000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceFaultFeaturesKHRBuilder<'a> {
    #[inline]
    pub fn device_fault(mut self, value: bool) -> Self {
        self.inner.device_fault = value as u32;
        self
    }
    #[inline]
    pub fn device_fault_vendor_binary(mut self, value: bool) -> Self {
        self.inner.device_fault_vendor_binary = value as u32;
        self
    }
    #[inline]
    pub fn device_fault_report_masked(mut self, value: bool) -> Self {
        self.inner.device_fault_report_masked = value as u32;
        self
    }
    #[inline]
    pub fn device_fault_device_lost_on_masked(mut self, value: bool) -> Self {
        self.inner.device_fault_device_lost_on_masked = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceFaultFeaturesKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceFaultFeaturesKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceFaultFeaturesKHRBuilder<'a> {
    type Target = PhysicalDeviceFaultFeaturesKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceFaultFeaturesKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceFaultPropertiesKHR`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceFaultPropertiesKHRBuilder<'a> {
    inner: PhysicalDeviceFaultPropertiesKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceFaultPropertiesKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceFaultPropertiesKHRBuilder<'a> {
        PhysicalDeviceFaultPropertiesKHRBuilder {
            inner: PhysicalDeviceFaultPropertiesKHR {
                s_type: StructureType::from_raw(1000573001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceFaultPropertiesKHRBuilder<'a> {
    #[inline]
    pub fn max_device_fault_count(mut self, value: u32) -> Self {
        self.inner.max_device_fault_count = value;
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceFaultPropertiesKHRBuilder<'a> {
    type Target = PhysicalDeviceFaultPropertiesKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceFaultPropertiesKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXTBuilder<'a> {
    inner: PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXTBuilder<
        'a,
    > {
        PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXTBuilder {
            inner: PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT {
                s_type: StructureType::from_raw(1000498000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXTBuilder<'a> {
    #[inline]
    pub fn pipeline_library_group_handles(mut self, value: bool) -> Self {
        self.inner.pipeline_library_group_handles = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXTBuilder<'a> {
    type Target = PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DepthBiasInfoEXT`] with lifetime-tied pNext safety.
pub struct DepthBiasInfoEXTBuilder<'a> {
    inner: DepthBiasInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DepthBiasInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> DepthBiasInfoEXTBuilder<'a> {
        DepthBiasInfoEXTBuilder {
            inner: DepthBiasInfoEXT {
                s_type: StructureType::from_raw(1000283001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DepthBiasInfoEXTBuilder<'a> {
    #[inline]
    pub fn depth_bias_constant_factor(mut self, value: f32) -> Self {
        self.inner.depth_bias_constant_factor = value;
        self
    }
    #[inline]
    pub fn depth_bias_clamp(mut self, value: f32) -> Self {
        self.inner.depth_bias_clamp = value;
        self
    }
    #[inline]
    pub fn depth_bias_slope_factor(mut self, value: f32) -> Self {
        self.inner.depth_bias_slope_factor = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`DepthBiasInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsDepthBiasInfoEXT>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for DepthBiasInfoEXTBuilder<'a> {
    type Target = DepthBiasInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for DepthBiasInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DepthBiasRepresentationInfoEXT`] with lifetime-tied pNext safety.
pub struct DepthBiasRepresentationInfoEXTBuilder<'a> {
    inner: DepthBiasRepresentationInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DepthBiasRepresentationInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> DepthBiasRepresentationInfoEXTBuilder<'a> {
        DepthBiasRepresentationInfoEXTBuilder {
            inner: DepthBiasRepresentationInfoEXT {
                s_type: StructureType::from_raw(1000283002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DepthBiasRepresentationInfoEXTBuilder<'a> {
    #[inline]
    pub fn depth_bias_representation(
        mut self,
        value: DepthBiasRepresentationEXT,
    ) -> Self {
        self.inner.depth_bias_representation = value;
        self
    }
    #[inline]
    pub fn depth_bias_exact(mut self, value: bool) -> Self {
        self.inner.depth_bias_exact = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`DepthBiasRepresentationInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsDepthBiasRepresentationInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for DepthBiasRepresentationInfoEXTBuilder<'a> {
    type Target = DepthBiasRepresentationInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for DepthBiasRepresentationInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DecompressMemoryRegionNV`].
pub struct DecompressMemoryRegionNVBuilder {
    inner: DecompressMemoryRegionNV,
}
impl DecompressMemoryRegionNV {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> DecompressMemoryRegionNVBuilder {
        DecompressMemoryRegionNVBuilder {
            inner: DecompressMemoryRegionNV {
                ..Default::default()
            },
        }
    }
}
impl DecompressMemoryRegionNVBuilder {
    #[inline]
    pub fn src_address(mut self, value: u64) -> Self {
        self.inner.src_address = value;
        self
    }
    #[inline]
    pub fn dst_address(mut self, value: u64) -> Self {
        self.inner.dst_address = value;
        self
    }
    #[inline]
    pub fn compressed_size(mut self, value: u64) -> Self {
        self.inner.compressed_size = value;
        self
    }
    #[inline]
    pub fn decompressed_size(mut self, value: u64) -> Self {
        self.inner.decompressed_size = value;
        self
    }
    #[inline]
    pub fn decompression_method(
        mut self,
        value: MemoryDecompressionMethodFlagsNV,
    ) -> Self {
        self.inner.decompression_method = value;
        self
    }
}
impl core::ops::Deref for DecompressMemoryRegionNVBuilder {
    type Target = DecompressMemoryRegionNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for DecompressMemoryRegionNVBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DecompressMemoryRegionEXT`].
pub struct DecompressMemoryRegionEXTBuilder {
    inner: DecompressMemoryRegionEXT,
}
impl DecompressMemoryRegionEXT {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> DecompressMemoryRegionEXTBuilder {
        DecompressMemoryRegionEXTBuilder {
            inner: DecompressMemoryRegionEXT {
                ..Default::default()
            },
        }
    }
}
impl DecompressMemoryRegionEXTBuilder {
    #[inline]
    pub fn src_address(mut self, value: u64) -> Self {
        self.inner.src_address = value;
        self
    }
    #[inline]
    pub fn dst_address(mut self, value: u64) -> Self {
        self.inner.dst_address = value;
        self
    }
    #[inline]
    pub fn compressed_size(mut self, value: u64) -> Self {
        self.inner.compressed_size = value;
        self
    }
    #[inline]
    pub fn decompressed_size(mut self, value: u64) -> Self {
        self.inner.decompressed_size = value;
        self
    }
}
impl core::ops::Deref for DecompressMemoryRegionEXTBuilder {
    type Target = DecompressMemoryRegionEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for DecompressMemoryRegionEXTBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DecompressMemoryInfoEXT`] with lifetime-tied pNext safety.
pub struct DecompressMemoryInfoEXTBuilder<'a> {
    inner: DecompressMemoryInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DecompressMemoryInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> DecompressMemoryInfoEXTBuilder<'a> {
        DecompressMemoryInfoEXTBuilder {
            inner: DecompressMemoryInfoEXT {
                s_type: StructureType::from_raw(1000550002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DecompressMemoryInfoEXTBuilder<'a> {
    #[inline]
    pub fn decompression_method(
        mut self,
        value: MemoryDecompressionMethodFlagsEXT,
    ) -> Self {
        self.inner.decompression_method = value;
        self
    }
    #[inline]
    pub fn regions(mut self, slice: &'a [DecompressMemoryRegionEXT]) -> Self {
        self.inner.region_count = slice.len() as u32;
        self.inner.p_regions = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`DecompressMemoryInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsDecompressMemoryInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for DecompressMemoryInfoEXTBuilder<'a> {
    type Target = DecompressMemoryInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for DecompressMemoryInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceShaderCoreBuiltinsPropertiesARM`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceShaderCoreBuiltinsPropertiesARMBuilder<'a> {
    inner: PhysicalDeviceShaderCoreBuiltinsPropertiesARM,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceShaderCoreBuiltinsPropertiesARM {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceShaderCoreBuiltinsPropertiesARMBuilder<'a> {
        PhysicalDeviceShaderCoreBuiltinsPropertiesARMBuilder {
            inner: PhysicalDeviceShaderCoreBuiltinsPropertiesARM {
                s_type: StructureType::from_raw(1000497001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceShaderCoreBuiltinsPropertiesARMBuilder<'a> {
    #[inline]
    pub fn shader_core_mask(mut self, value: u64) -> Self {
        self.inner.shader_core_mask = value;
        self
    }
    #[inline]
    pub fn shader_core_count(mut self, value: u32) -> Self {
        self.inner.shader_core_count = value;
        self
    }
    #[inline]
    pub fn shader_warps_per_core(mut self, value: u32) -> Self {
        self.inner.shader_warps_per_core = value;
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceShaderCoreBuiltinsPropertiesARMBuilder<'a> {
    type Target = PhysicalDeviceShaderCoreBuiltinsPropertiesARM;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceShaderCoreBuiltinsPropertiesARMBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceShaderCoreBuiltinsFeaturesARM`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceShaderCoreBuiltinsFeaturesARMBuilder<'a> {
    inner: PhysicalDeviceShaderCoreBuiltinsFeaturesARM,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceShaderCoreBuiltinsFeaturesARM {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceShaderCoreBuiltinsFeaturesARMBuilder<'a> {
        PhysicalDeviceShaderCoreBuiltinsFeaturesARMBuilder {
            inner: PhysicalDeviceShaderCoreBuiltinsFeaturesARM {
                s_type: StructureType::from_raw(1000497000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceShaderCoreBuiltinsFeaturesARMBuilder<'a> {
    #[inline]
    pub fn shader_core_builtins(mut self, value: bool) -> Self {
        self.inner.shader_core_builtins = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceShaderCoreBuiltinsFeaturesARM`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceShaderCoreBuiltinsFeaturesARM>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceShaderCoreBuiltinsFeaturesARMBuilder<'a> {
    type Target = PhysicalDeviceShaderCoreBuiltinsFeaturesARM;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceShaderCoreBuiltinsFeaturesARMBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`FrameBoundaryEXT`] with lifetime-tied pNext safety.
pub struct FrameBoundaryEXTBuilder<'a> {
    inner: FrameBoundaryEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl FrameBoundaryEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> FrameBoundaryEXTBuilder<'a> {
        FrameBoundaryEXTBuilder {
            inner: FrameBoundaryEXT {
                s_type: StructureType::from_raw(1000375001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> FrameBoundaryEXTBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: FrameBoundaryFlagsEXT) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn frame_id(mut self, value: u64) -> Self {
        self.inner.frame_id = value;
        self
    }
    #[inline]
    pub fn image_count(mut self, value: u32) -> Self {
        self.inner.image_count = value;
        self
    }
    #[inline]
    pub fn images(mut self, slice: &'a [Image]) -> Self {
        self.inner.image_count = slice.len() as u32;
        self.inner.p_images = slice.as_ptr();
        self
    }
    #[inline]
    pub fn buffer_count(mut self, value: u32) -> Self {
        self.inner.buffer_count = value;
        self
    }
    #[inline]
    pub fn buffers(mut self, slice: &'a [Buffer]) -> Self {
        self.inner.buffer_count = slice.len() as u32;
        self.inner.p_buffers = slice.as_ptr();
        self
    }
    #[inline]
    pub fn tag_name(mut self, value: u64) -> Self {
        self.inner.tag_name = value;
        self
    }
    #[inline]
    pub fn tag_size(mut self, value: usize) -> Self {
        self.inner.tag_size = value;
        self
    }
    #[inline]
    pub fn tag(mut self, slice: &'a [core::ffi::c_void]) -> Self {
        self.inner.tag_size = slice.len();
        self.inner.p_tag = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`FrameBoundaryEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsFrameBoundaryEXT>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for FrameBoundaryEXTBuilder<'a> {
    type Target = FrameBoundaryEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for FrameBoundaryEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceFrameBoundaryFeaturesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceFrameBoundaryFeaturesEXTBuilder<'a> {
    inner: PhysicalDeviceFrameBoundaryFeaturesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceFrameBoundaryFeaturesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceFrameBoundaryFeaturesEXTBuilder<'a> {
        PhysicalDeviceFrameBoundaryFeaturesEXTBuilder {
            inner: PhysicalDeviceFrameBoundaryFeaturesEXT {
                s_type: StructureType::from_raw(1000375000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceFrameBoundaryFeaturesEXTBuilder<'a> {
    #[inline]
    pub fn frame_boundary(mut self, value: bool) -> Self {
        self.inner.frame_boundary = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceFrameBoundaryFeaturesEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceFrameBoundaryFeaturesEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceFrameBoundaryFeaturesEXTBuilder<'a> {
    type Target = PhysicalDeviceFrameBoundaryFeaturesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceFrameBoundaryFeaturesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXTBuilder<'a> {
    inner: PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXTBuilder<
        'a,
    > {
        PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXTBuilder {
            inner: PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT {
                s_type: StructureType::from_raw(1000499000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXTBuilder<'a> {
    #[inline]
    pub fn dynamic_rendering_unused_attachments(mut self, value: bool) -> Self {
        self.inner.dynamic_rendering_unused_attachments = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<
        T: ExtendsPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT,
    >(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXTBuilder<'a> {
    type Target = PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceInternallySynchronizedQueuesFeaturesKHR`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceInternallySynchronizedQueuesFeaturesKHRBuilder<'a> {
    inner: PhysicalDeviceInternallySynchronizedQueuesFeaturesKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceInternallySynchronizedQueuesFeaturesKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceInternallySynchronizedQueuesFeaturesKHRBuilder<
        'a,
    > {
        PhysicalDeviceInternallySynchronizedQueuesFeaturesKHRBuilder {
            inner: PhysicalDeviceInternallySynchronizedQueuesFeaturesKHR {
                s_type: StructureType::from_raw(1000504000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceInternallySynchronizedQueuesFeaturesKHRBuilder<'a> {
    #[inline]
    pub fn internally_synchronized_queues(mut self, value: bool) -> Self {
        self.inner.internally_synchronized_queues = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceInternallySynchronizedQueuesFeaturesKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDeviceInternallySynchronizedQueuesFeaturesKHRBuilder<'a> {
    type Target = PhysicalDeviceInternallySynchronizedQueuesFeaturesKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceInternallySynchronizedQueuesFeaturesKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`SurfacePresentModeKHR`] with lifetime-tied pNext safety.
pub struct SurfacePresentModeKHRBuilder<'a> {
    inner: SurfacePresentModeKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl SurfacePresentModeKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> SurfacePresentModeKHRBuilder<'a> {
        SurfacePresentModeKHRBuilder {
            inner: SurfacePresentModeKHR {
                s_type: StructureType::from_raw(1000274000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> SurfacePresentModeKHRBuilder<'a> {
    #[inline]
    pub fn present_mode(mut self, value: PresentModeKHR) -> Self {
        self.inner.present_mode = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`SurfacePresentModeKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsSurfacePresentModeKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for SurfacePresentModeKHRBuilder<'a> {
    type Target = SurfacePresentModeKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for SurfacePresentModeKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`SurfacePresentScalingCapabilitiesKHR`] with lifetime-tied pNext safety.
pub struct SurfacePresentScalingCapabilitiesKHRBuilder<'a> {
    inner: SurfacePresentScalingCapabilitiesKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl SurfacePresentScalingCapabilitiesKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> SurfacePresentScalingCapabilitiesKHRBuilder<'a> {
        SurfacePresentScalingCapabilitiesKHRBuilder {
            inner: SurfacePresentScalingCapabilitiesKHR {
                s_type: StructureType::from_raw(1000274001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> SurfacePresentScalingCapabilitiesKHRBuilder<'a> {
    #[inline]
    pub fn supported_present_scaling(mut self, value: PresentScalingFlagsKHR) -> Self {
        self.inner.supported_present_scaling = value;
        self
    }
    #[inline]
    pub fn supported_present_gravity_x(mut self, value: PresentGravityFlagsKHR) -> Self {
        self.inner.supported_present_gravity_x = value;
        self
    }
    #[inline]
    pub fn supported_present_gravity_y(mut self, value: PresentGravityFlagsKHR) -> Self {
        self.inner.supported_present_gravity_y = value;
        self
    }
    #[inline]
    pub fn min_scaled_image_extent(mut self, value: Extent2D) -> Self {
        self.inner.min_scaled_image_extent = value;
        self
    }
    #[inline]
    pub fn max_scaled_image_extent(mut self, value: Extent2D) -> Self {
        self.inner.max_scaled_image_extent = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`SurfacePresentScalingCapabilitiesKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsSurfacePresentScalingCapabilitiesKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for SurfacePresentScalingCapabilitiesKHRBuilder<'a> {
    type Target = SurfacePresentScalingCapabilitiesKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for SurfacePresentScalingCapabilitiesKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`SurfacePresentModeCompatibilityKHR`] with lifetime-tied pNext safety.
pub struct SurfacePresentModeCompatibilityKHRBuilder<'a> {
    inner: SurfacePresentModeCompatibilityKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl SurfacePresentModeCompatibilityKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> SurfacePresentModeCompatibilityKHRBuilder<'a> {
        SurfacePresentModeCompatibilityKHRBuilder {
            inner: SurfacePresentModeCompatibilityKHR {
                s_type: StructureType::from_raw(1000274002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> SurfacePresentModeCompatibilityKHRBuilder<'a> {
    #[inline]
    pub fn present_mode_count(mut self, value: u32) -> Self {
        self.inner.present_mode_count = value;
        self
    }
    #[inline]
    pub fn present_modes(mut self, slice: &'a mut [PresentModeKHR]) -> Self {
        self.inner.present_mode_count = slice.len() as u32;
        self.inner.p_present_modes = slice.as_mut_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`SurfacePresentModeCompatibilityKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsSurfacePresentModeCompatibilityKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for SurfacePresentModeCompatibilityKHRBuilder<'a> {
    type Target = SurfacePresentModeCompatibilityKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for SurfacePresentModeCompatibilityKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceSwapchainMaintenance1FeaturesKHR`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceSwapchainMaintenance1FeaturesKHRBuilder<'a> {
    inner: PhysicalDeviceSwapchainMaintenance1FeaturesKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceSwapchainMaintenance1FeaturesKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceSwapchainMaintenance1FeaturesKHRBuilder<'a> {
        PhysicalDeviceSwapchainMaintenance1FeaturesKHRBuilder {
            inner: PhysicalDeviceSwapchainMaintenance1FeaturesKHR {
                s_type: StructureType::from_raw(1000275000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceSwapchainMaintenance1FeaturesKHRBuilder<'a> {
    #[inline]
    pub fn swapchain_maintenance1(mut self, value: bool) -> Self {
        self.inner.swapchain_maintenance1 = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceSwapchainMaintenance1FeaturesKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceSwapchainMaintenance1FeaturesKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceSwapchainMaintenance1FeaturesKHRBuilder<'a> {
    type Target = PhysicalDeviceSwapchainMaintenance1FeaturesKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceSwapchainMaintenance1FeaturesKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`SwapchainPresentFenceInfoKHR`] with lifetime-tied pNext safety.
pub struct SwapchainPresentFenceInfoKHRBuilder<'a> {
    inner: SwapchainPresentFenceInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl SwapchainPresentFenceInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> SwapchainPresentFenceInfoKHRBuilder<'a> {
        SwapchainPresentFenceInfoKHRBuilder {
            inner: SwapchainPresentFenceInfoKHR {
                s_type: StructureType::from_raw(1000275001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> SwapchainPresentFenceInfoKHRBuilder<'a> {
    #[inline]
    pub fn swapchain_count(mut self, value: u32) -> Self {
        self.inner.swapchain_count = value;
        self
    }
    #[inline]
    pub fn fences(mut self, slice: &'a [Fence]) -> Self {
        self.inner.swapchain_count = slice.len() as u32;
        self.inner.p_fences = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`SwapchainPresentFenceInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsSwapchainPresentFenceInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for SwapchainPresentFenceInfoKHRBuilder<'a> {
    type Target = SwapchainPresentFenceInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for SwapchainPresentFenceInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`SwapchainPresentModesCreateInfoKHR`] with lifetime-tied pNext safety.
pub struct SwapchainPresentModesCreateInfoKHRBuilder<'a> {
    inner: SwapchainPresentModesCreateInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl SwapchainPresentModesCreateInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> SwapchainPresentModesCreateInfoKHRBuilder<'a> {
        SwapchainPresentModesCreateInfoKHRBuilder {
            inner: SwapchainPresentModesCreateInfoKHR {
                s_type: StructureType::from_raw(1000275002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> SwapchainPresentModesCreateInfoKHRBuilder<'a> {
    #[inline]
    pub fn present_modes(mut self, slice: &'a [PresentModeKHR]) -> Self {
        self.inner.present_mode_count = slice.len() as u32;
        self.inner.p_present_modes = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`SwapchainPresentModesCreateInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsSwapchainPresentModesCreateInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for SwapchainPresentModesCreateInfoKHRBuilder<'a> {
    type Target = SwapchainPresentModesCreateInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for SwapchainPresentModesCreateInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`SwapchainPresentModeInfoKHR`] with lifetime-tied pNext safety.
pub struct SwapchainPresentModeInfoKHRBuilder<'a> {
    inner: SwapchainPresentModeInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl SwapchainPresentModeInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> SwapchainPresentModeInfoKHRBuilder<'a> {
        SwapchainPresentModeInfoKHRBuilder {
            inner: SwapchainPresentModeInfoKHR {
                s_type: StructureType::from_raw(1000275003i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> SwapchainPresentModeInfoKHRBuilder<'a> {
    #[inline]
    pub fn present_modes(mut self, slice: &'a [PresentModeKHR]) -> Self {
        self.inner.swapchain_count = slice.len() as u32;
        self.inner.p_present_modes = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`SwapchainPresentModeInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsSwapchainPresentModeInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for SwapchainPresentModeInfoKHRBuilder<'a> {
    type Target = SwapchainPresentModeInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for SwapchainPresentModeInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`SwapchainPresentScalingCreateInfoKHR`] with lifetime-tied pNext safety.
pub struct SwapchainPresentScalingCreateInfoKHRBuilder<'a> {
    inner: SwapchainPresentScalingCreateInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl SwapchainPresentScalingCreateInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> SwapchainPresentScalingCreateInfoKHRBuilder<'a> {
        SwapchainPresentScalingCreateInfoKHRBuilder {
            inner: SwapchainPresentScalingCreateInfoKHR {
                s_type: StructureType::from_raw(1000275004i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> SwapchainPresentScalingCreateInfoKHRBuilder<'a> {
    #[inline]
    pub fn scaling_behavior(mut self, value: PresentScalingFlagsKHR) -> Self {
        self.inner.scaling_behavior = value;
        self
    }
    #[inline]
    pub fn present_gravity_x(mut self, value: PresentGravityFlagsKHR) -> Self {
        self.inner.present_gravity_x = value;
        self
    }
    #[inline]
    pub fn present_gravity_y(mut self, value: PresentGravityFlagsKHR) -> Self {
        self.inner.present_gravity_y = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`SwapchainPresentScalingCreateInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsSwapchainPresentScalingCreateInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for SwapchainPresentScalingCreateInfoKHRBuilder<'a> {
    type Target = SwapchainPresentScalingCreateInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for SwapchainPresentScalingCreateInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ReleaseSwapchainImagesInfoKHR`] with lifetime-tied pNext safety.
pub struct ReleaseSwapchainImagesInfoKHRBuilder<'a> {
    inner: ReleaseSwapchainImagesInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ReleaseSwapchainImagesInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ReleaseSwapchainImagesInfoKHRBuilder<'a> {
        ReleaseSwapchainImagesInfoKHRBuilder {
            inner: ReleaseSwapchainImagesInfoKHR {
                s_type: StructureType::from_raw(1000275005i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ReleaseSwapchainImagesInfoKHRBuilder<'a> {
    #[inline]
    pub fn swapchain(mut self, value: SwapchainKHR) -> Self {
        self.inner.swapchain = value;
        self
    }
    #[inline]
    pub fn image_indices(mut self, slice: &'a [u32]) -> Self {
        self.inner.image_index_count = slice.len() as u32;
        self.inner.p_image_indices = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`ReleaseSwapchainImagesInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsReleaseSwapchainImagesInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for ReleaseSwapchainImagesInfoKHRBuilder<'a> {
    type Target = ReleaseSwapchainImagesInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ReleaseSwapchainImagesInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceDepthBiasControlFeaturesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceDepthBiasControlFeaturesEXTBuilder<'a> {
    inner: PhysicalDeviceDepthBiasControlFeaturesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceDepthBiasControlFeaturesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceDepthBiasControlFeaturesEXTBuilder<'a> {
        PhysicalDeviceDepthBiasControlFeaturesEXTBuilder {
            inner: PhysicalDeviceDepthBiasControlFeaturesEXT {
                s_type: StructureType::from_raw(1000283000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceDepthBiasControlFeaturesEXTBuilder<'a> {
    #[inline]
    pub fn depth_bias_control(mut self, value: bool) -> Self {
        self.inner.depth_bias_control = value as u32;
        self
    }
    #[inline]
    pub fn least_representable_value_force_unorm_representation(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.least_representable_value_force_unorm_representation = value as u32;
        self
    }
    #[inline]
    pub fn float_representation(mut self, value: bool) -> Self {
        self.inner.float_representation = value as u32;
        self
    }
    #[inline]
    pub fn depth_bias_exact(mut self, value: bool) -> Self {
        self.inner.depth_bias_exact = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceDepthBiasControlFeaturesEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceDepthBiasControlFeaturesEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceDepthBiasControlFeaturesEXTBuilder<'a> {
    type Target = PhysicalDeviceDepthBiasControlFeaturesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceDepthBiasControlFeaturesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceRayTracingInvocationReorderFeaturesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceRayTracingInvocationReorderFeaturesEXTBuilder<'a> {
    inner: PhysicalDeviceRayTracingInvocationReorderFeaturesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceRayTracingInvocationReorderFeaturesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceRayTracingInvocationReorderFeaturesEXTBuilder<
        'a,
    > {
        PhysicalDeviceRayTracingInvocationReorderFeaturesEXTBuilder {
            inner: PhysicalDeviceRayTracingInvocationReorderFeaturesEXT {
                s_type: StructureType::from_raw(1000581000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceRayTracingInvocationReorderFeaturesEXTBuilder<'a> {
    #[inline]
    pub fn ray_tracing_invocation_reorder(mut self, value: bool) -> Self {
        self.inner.ray_tracing_invocation_reorder = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceRayTracingInvocationReorderFeaturesEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceRayTracingInvocationReorderFeaturesEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDeviceRayTracingInvocationReorderFeaturesEXTBuilder<'a> {
    type Target = PhysicalDeviceRayTracingInvocationReorderFeaturesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceRayTracingInvocationReorderFeaturesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceRayTracingInvocationReorderFeaturesNV`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceRayTracingInvocationReorderFeaturesNVBuilder<'a> {
    inner: PhysicalDeviceRayTracingInvocationReorderFeaturesNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceRayTracingInvocationReorderFeaturesNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceRayTracingInvocationReorderFeaturesNVBuilder<
        'a,
    > {
        PhysicalDeviceRayTracingInvocationReorderFeaturesNVBuilder {
            inner: PhysicalDeviceRayTracingInvocationReorderFeaturesNV {
                s_type: StructureType::from_raw(1000490000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceRayTracingInvocationReorderFeaturesNVBuilder<'a> {
    #[inline]
    pub fn ray_tracing_invocation_reorder(mut self, value: bool) -> Self {
        self.inner.ray_tracing_invocation_reorder = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceRayTracingInvocationReorderFeaturesNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceRayTracingInvocationReorderFeaturesNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDeviceRayTracingInvocationReorderFeaturesNVBuilder<'a> {
    type Target = PhysicalDeviceRayTracingInvocationReorderFeaturesNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceRayTracingInvocationReorderFeaturesNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceRayTracingInvocationReorderPropertiesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceRayTracingInvocationReorderPropertiesEXTBuilder<'a> {
    inner: PhysicalDeviceRayTracingInvocationReorderPropertiesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceRayTracingInvocationReorderPropertiesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceRayTracingInvocationReorderPropertiesEXTBuilder<
        'a,
    > {
        PhysicalDeviceRayTracingInvocationReorderPropertiesEXTBuilder {
            inner: PhysicalDeviceRayTracingInvocationReorderPropertiesEXT {
                s_type: StructureType::from_raw(1000581001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceRayTracingInvocationReorderPropertiesEXTBuilder<'a> {
    #[inline]
    pub fn ray_tracing_invocation_reorder_reordering_hint(
        mut self,
        value: RayTracingInvocationReorderModeEXT,
    ) -> Self {
        self.inner.ray_tracing_invocation_reorder_reordering_hint = value;
        self
    }
    #[inline]
    pub fn max_shader_binding_table_record_index(mut self, value: u32) -> Self {
        self.inner.max_shader_binding_table_record_index = value;
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDeviceRayTracingInvocationReorderPropertiesEXTBuilder<'a> {
    type Target = PhysicalDeviceRayTracingInvocationReorderPropertiesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceRayTracingInvocationReorderPropertiesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceRayTracingInvocationReorderPropertiesNV`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceRayTracingInvocationReorderPropertiesNVBuilder<'a> {
    inner: PhysicalDeviceRayTracingInvocationReorderPropertiesNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceRayTracingInvocationReorderPropertiesNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceRayTracingInvocationReorderPropertiesNVBuilder<
        'a,
    > {
        PhysicalDeviceRayTracingInvocationReorderPropertiesNVBuilder {
            inner: PhysicalDeviceRayTracingInvocationReorderPropertiesNV {
                s_type: StructureType::from_raw(1000490001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceRayTracingInvocationReorderPropertiesNVBuilder<'a> {
    #[inline]
    pub fn ray_tracing_invocation_reorder_reordering_hint(
        mut self,
        value: RayTracingInvocationReorderModeEXT,
    ) -> Self {
        self.inner.ray_tracing_invocation_reorder_reordering_hint = value;
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDeviceRayTracingInvocationReorderPropertiesNVBuilder<'a> {
    type Target = PhysicalDeviceRayTracingInvocationReorderPropertiesNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceRayTracingInvocationReorderPropertiesNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceExtendedSparseAddressSpaceFeaturesNVBuilder<'a> {
    inner: PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceExtendedSparseAddressSpaceFeaturesNVBuilder<
        'a,
    > {
        PhysicalDeviceExtendedSparseAddressSpaceFeaturesNVBuilder {
            inner: PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV {
                s_type: StructureType::from_raw(1000492000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceExtendedSparseAddressSpaceFeaturesNVBuilder<'a> {
    #[inline]
    pub fn extended_sparse_address_space(mut self, value: bool) -> Self {
        self.inner.extended_sparse_address_space = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDeviceExtendedSparseAddressSpaceFeaturesNVBuilder<'a> {
    type Target = PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceExtendedSparseAddressSpaceFeaturesNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceExtendedSparseAddressSpacePropertiesNV`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceExtendedSparseAddressSpacePropertiesNVBuilder<'a> {
    inner: PhysicalDeviceExtendedSparseAddressSpacePropertiesNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceExtendedSparseAddressSpacePropertiesNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceExtendedSparseAddressSpacePropertiesNVBuilder<
        'a,
    > {
        PhysicalDeviceExtendedSparseAddressSpacePropertiesNVBuilder {
            inner: PhysicalDeviceExtendedSparseAddressSpacePropertiesNV {
                s_type: StructureType::from_raw(1000492001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceExtendedSparseAddressSpacePropertiesNVBuilder<'a> {
    #[inline]
    pub fn extended_sparse_address_space_size(mut self, value: u64) -> Self {
        self.inner.extended_sparse_address_space_size = value;
        self
    }
    #[inline]
    pub fn extended_sparse_image_usage_flags(mut self, value: ImageUsageFlags) -> Self {
        self.inner.extended_sparse_image_usage_flags = value;
        self
    }
    #[inline]
    pub fn extended_sparse_buffer_usage_flags(
        mut self,
        value: BufferUsageFlags,
    ) -> Self {
        self.inner.extended_sparse_buffer_usage_flags = value;
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDeviceExtendedSparseAddressSpacePropertiesNVBuilder<'a> {
    type Target = PhysicalDeviceExtendedSparseAddressSpacePropertiesNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceExtendedSparseAddressSpacePropertiesNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DirectDriverLoadingInfoLUNARG`] with lifetime-tied pNext safety.
pub struct DirectDriverLoadingInfoLUNARGBuilder<'a> {
    inner: DirectDriverLoadingInfoLUNARG,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DirectDriverLoadingInfoLUNARG {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> DirectDriverLoadingInfoLUNARGBuilder<'a> {
        DirectDriverLoadingInfoLUNARGBuilder {
            inner: DirectDriverLoadingInfoLUNARG {
                s_type: StructureType::from_raw(1000459000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DirectDriverLoadingInfoLUNARGBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: DirectDriverLoadingFlagsLUNARG) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn pfn_get_instance_proc_addr(
        mut self,
        value: PFN_vkGetInstanceProcAddrLUNARG,
    ) -> Self {
        self.inner.pfn_get_instance_proc_addr = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`DirectDriverLoadingInfoLUNARG`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsDirectDriverLoadingInfoLUNARG>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for DirectDriverLoadingInfoLUNARGBuilder<'a> {
    type Target = DirectDriverLoadingInfoLUNARG;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for DirectDriverLoadingInfoLUNARGBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DirectDriverLoadingListLUNARG`] with lifetime-tied pNext safety.
pub struct DirectDriverLoadingListLUNARGBuilder<'a> {
    inner: DirectDriverLoadingListLUNARG,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DirectDriverLoadingListLUNARG {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> DirectDriverLoadingListLUNARGBuilder<'a> {
        DirectDriverLoadingListLUNARGBuilder {
            inner: DirectDriverLoadingListLUNARG {
                s_type: StructureType::from_raw(1000459001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DirectDriverLoadingListLUNARGBuilder<'a> {
    #[inline]
    pub fn mode(mut self, value: DirectDriverLoadingModeLUNARG) -> Self {
        self.inner.mode = value;
        self
    }
    #[inline]
    pub fn drivers(mut self, slice: &'a [DirectDriverLoadingInfoLUNARG]) -> Self {
        self.inner.driver_count = slice.len() as u32;
        self.inner.p_drivers = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`DirectDriverLoadingListLUNARG`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsDirectDriverLoadingListLUNARG>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for DirectDriverLoadingListLUNARGBuilder<'a> {
    type Target = DirectDriverLoadingListLUNARG;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for DirectDriverLoadingListLUNARGBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOMBuilder<'a> {
    inner: PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOMBuilder<
        'a,
    > {
        PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOMBuilder {
            inner: PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM {
                s_type: StructureType::from_raw(1000488000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOMBuilder<'a> {
    #[inline]
    pub fn multiview_per_view_viewports(mut self, value: bool) -> Self {
        self.inner.multiview_per_view_viewports = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOMBuilder<'a> {
    type Target = PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOMBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceRayTracingPositionFetchFeaturesKHR`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceRayTracingPositionFetchFeaturesKHRBuilder<'a> {
    inner: PhysicalDeviceRayTracingPositionFetchFeaturesKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceRayTracingPositionFetchFeaturesKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceRayTracingPositionFetchFeaturesKHRBuilder<'a> {
        PhysicalDeviceRayTracingPositionFetchFeaturesKHRBuilder {
            inner: PhysicalDeviceRayTracingPositionFetchFeaturesKHR {
                s_type: StructureType::from_raw(1000481000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceRayTracingPositionFetchFeaturesKHRBuilder<'a> {
    #[inline]
    pub fn ray_tracing_position_fetch(mut self, value: bool) -> Self {
        self.inner.ray_tracing_position_fetch = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceRayTracingPositionFetchFeaturesKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceRayTracingPositionFetchFeaturesKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDeviceRayTracingPositionFetchFeaturesKHRBuilder<'a> {
    type Target = PhysicalDeviceRayTracingPositionFetchFeaturesKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceRayTracingPositionFetchFeaturesKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DeviceImageSubresourceInfo`] with lifetime-tied pNext safety.
pub struct DeviceImageSubresourceInfoBuilder<'a> {
    inner: DeviceImageSubresourceInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DeviceImageSubresourceInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> DeviceImageSubresourceInfoBuilder<'a> {
        DeviceImageSubresourceInfoBuilder {
            inner: DeviceImageSubresourceInfo {
                s_type: StructureType::from_raw(1000470004i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DeviceImageSubresourceInfoBuilder<'a> {
    #[inline]
    pub fn create_info(mut self, value: &'a ImageCreateInfo) -> Self {
        self.inner.p_create_info = value;
        self
    }
    #[inline]
    pub fn subresource(mut self, value: &'a ImageSubresource2) -> Self {
        self.inner.p_subresource = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`DeviceImageSubresourceInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsDeviceImageSubresourceInfo>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for DeviceImageSubresourceInfoBuilder<'a> {
    type Target = DeviceImageSubresourceInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for DeviceImageSubresourceInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceShaderCorePropertiesARM`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceShaderCorePropertiesARMBuilder<'a> {
    inner: PhysicalDeviceShaderCorePropertiesARM,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceShaderCorePropertiesARM {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceShaderCorePropertiesARMBuilder<'a> {
        PhysicalDeviceShaderCorePropertiesARMBuilder {
            inner: PhysicalDeviceShaderCorePropertiesARM {
                s_type: StructureType::from_raw(1000415000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceShaderCorePropertiesARMBuilder<'a> {
    #[inline]
    pub fn pixel_rate(mut self, value: u32) -> Self {
        self.inner.pixel_rate = value;
        self
    }
    #[inline]
    pub fn texel_rate(mut self, value: u32) -> Self {
        self.inner.texel_rate = value;
        self
    }
    #[inline]
    pub fn fma_rate(mut self, value: u32) -> Self {
        self.inner.fma_rate = value;
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceShaderCorePropertiesARMBuilder<'a> {
    type Target = PhysicalDeviceShaderCorePropertiesARM;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceShaderCorePropertiesARMBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOMBuilder<'a> {
    inner: PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOMBuilder<
        'a,
    > {
        PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOMBuilder {
            inner: PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM {
                s_type: StructureType::from_raw(1000510000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOMBuilder<'a> {
    #[inline]
    pub fn multiview_per_view_render_areas(mut self, value: bool) -> Self {
        self.inner.multiview_per_view_render_areas = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOMBuilder<'a> {
    type Target = PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOMBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM`] with lifetime-tied pNext safety.
pub struct MultiviewPerViewRenderAreasRenderPassBeginInfoQCOMBuilder<'a> {
    inner: MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> MultiviewPerViewRenderAreasRenderPassBeginInfoQCOMBuilder<
        'a,
    > {
        MultiviewPerViewRenderAreasRenderPassBeginInfoQCOMBuilder {
            inner: MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM {
                s_type: StructureType::from_raw(1000510001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> MultiviewPerViewRenderAreasRenderPassBeginInfoQCOMBuilder<'a> {
    #[inline]
    pub fn per_view_render_areas(mut self, slice: &'a [Rect2D]) -> Self {
        self.inner.per_view_render_area_count = slice.len() as u32;
        self.inner.p_per_view_render_areas = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref
for MultiviewPerViewRenderAreasRenderPassBeginInfoQCOMBuilder<'a> {
    type Target = MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for MultiviewPerViewRenderAreasRenderPassBeginInfoQCOMBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`QueryLowLatencySupportNV`] with lifetime-tied pNext safety.
pub struct QueryLowLatencySupportNVBuilder<'a> {
    inner: QueryLowLatencySupportNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl QueryLowLatencySupportNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> QueryLowLatencySupportNVBuilder<'a> {
        QueryLowLatencySupportNVBuilder {
            inner: QueryLowLatencySupportNV {
                s_type: StructureType::from_raw(1000310000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> QueryLowLatencySupportNVBuilder<'a> {
    #[inline]
    pub fn queried_low_latency_data(mut self, value: *mut core::ffi::c_void) -> Self {
        self.inner.p_queried_low_latency_data = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`QueryLowLatencySupportNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsQueryLowLatencySupportNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for QueryLowLatencySupportNVBuilder<'a> {
    type Target = QueryLowLatencySupportNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for QueryLowLatencySupportNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`MemoryMapInfo`] with lifetime-tied pNext safety.
pub struct MemoryMapInfoBuilder<'a> {
    inner: MemoryMapInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl MemoryMapInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> MemoryMapInfoBuilder<'a> {
        MemoryMapInfoBuilder {
            inner: MemoryMapInfo {
                s_type: StructureType::from_raw(1000271000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> MemoryMapInfoBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: MemoryMapFlags) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn memory(mut self, value: DeviceMemory) -> Self {
        self.inner.memory = value;
        self
    }
    #[inline]
    pub fn offset(mut self, value: u64) -> Self {
        self.inner.offset = value;
        self
    }
    #[inline]
    pub fn size(mut self, value: u64) -> Self {
        self.inner.size = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`MemoryMapInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsMemoryMapInfo>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for MemoryMapInfoBuilder<'a> {
    type Target = MemoryMapInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for MemoryMapInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`MemoryUnmapInfo`] with lifetime-tied pNext safety.
pub struct MemoryUnmapInfoBuilder<'a> {
    inner: MemoryUnmapInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl MemoryUnmapInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> MemoryUnmapInfoBuilder<'a> {
        MemoryUnmapInfoBuilder {
            inner: MemoryUnmapInfo {
                s_type: StructureType::from_raw(1000271001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> MemoryUnmapInfoBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: MemoryUnmapFlags) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn memory(mut self, value: DeviceMemory) -> Self {
        self.inner.memory = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`MemoryUnmapInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsMemoryUnmapInfo>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for MemoryUnmapInfoBuilder<'a> {
    type Target = MemoryUnmapInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for MemoryUnmapInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceShaderObjectFeaturesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceShaderObjectFeaturesEXTBuilder<'a> {
    inner: PhysicalDeviceShaderObjectFeaturesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceShaderObjectFeaturesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceShaderObjectFeaturesEXTBuilder<'a> {
        PhysicalDeviceShaderObjectFeaturesEXTBuilder {
            inner: PhysicalDeviceShaderObjectFeaturesEXT {
                s_type: StructureType::from_raw(1000482000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceShaderObjectFeaturesEXTBuilder<'a> {
    #[inline]
    pub fn shader_object(mut self, value: bool) -> Self {
        self.inner.shader_object = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceShaderObjectFeaturesEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceShaderObjectFeaturesEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceShaderObjectFeaturesEXTBuilder<'a> {
    type Target = PhysicalDeviceShaderObjectFeaturesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceShaderObjectFeaturesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceShaderObjectPropertiesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceShaderObjectPropertiesEXTBuilder<'a> {
    inner: PhysicalDeviceShaderObjectPropertiesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceShaderObjectPropertiesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceShaderObjectPropertiesEXTBuilder<'a> {
        PhysicalDeviceShaderObjectPropertiesEXTBuilder {
            inner: PhysicalDeviceShaderObjectPropertiesEXT {
                s_type: StructureType::from_raw(1000482001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceShaderObjectPropertiesEXTBuilder<'a> {
    #[inline]
    pub fn shader_binary_uuid(mut self, value: [u8; UUID_SIZE as usize]) -> Self {
        self.inner.shader_binary_uuid = value;
        self
    }
    #[inline]
    pub fn shader_binary_version(mut self, value: u32) -> Self {
        self.inner.shader_binary_version = value;
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceShaderObjectPropertiesEXTBuilder<'a> {
    type Target = PhysicalDeviceShaderObjectPropertiesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceShaderObjectPropertiesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ShaderCreateInfoEXT`] with lifetime-tied pNext safety.
pub struct ShaderCreateInfoEXTBuilder<'a> {
    inner: ShaderCreateInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ShaderCreateInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ShaderCreateInfoEXTBuilder<'a> {
        ShaderCreateInfoEXTBuilder {
            inner: ShaderCreateInfoEXT {
                s_type: StructureType::from_raw(1000482002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ShaderCreateInfoEXTBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: ShaderCreateFlagsEXT) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn stage(mut self, value: ShaderStageFlagBits) -> Self {
        self.inner.stage = value;
        self
    }
    #[inline]
    pub fn next_stage(mut self, value: ShaderStageFlags) -> Self {
        self.inner.next_stage = value;
        self
    }
    #[inline]
    pub fn code_type(mut self, value: ShaderCodeTypeEXT) -> Self {
        self.inner.code_type = value;
        self
    }
    #[inline]
    pub fn code(mut self, slice: &'a [core::ffi::c_void]) -> Self {
        self.inner.code_size = slice.len();
        self.inner.p_code = slice.as_ptr();
        self
    }
    #[inline]
    pub fn name(mut self, value: &'a core::ffi::CStr) -> Self {
        self.inner.p_name = value.as_ptr();
        self
    }
    #[inline]
    pub fn set_layout_count(mut self, value: u32) -> Self {
        self.inner.set_layout_count = value;
        self
    }
    #[inline]
    pub fn set_layouts(mut self, slice: &'a [DescriptorSetLayout]) -> Self {
        self.inner.set_layout_count = slice.len() as u32;
        self.inner.p_set_layouts = slice.as_ptr();
        self
    }
    #[inline]
    pub fn push_constant_range_count(mut self, value: u32) -> Self {
        self.inner.push_constant_range_count = value;
        self
    }
    #[inline]
    pub fn push_constant_ranges(mut self, slice: &'a [PushConstantRange]) -> Self {
        self.inner.push_constant_range_count = slice.len() as u32;
        self.inner.p_push_constant_ranges = slice.as_ptr();
        self
    }
    #[inline]
    pub fn specialization_info(mut self, value: &'a SpecializationInfo) -> Self {
        self.inner.p_specialization_info = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`ShaderCreateInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsShaderCreateInfoEXT>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for ShaderCreateInfoEXTBuilder<'a> {
    type Target = ShaderCreateInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ShaderCreateInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceShaderTileImageFeaturesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceShaderTileImageFeaturesEXTBuilder<'a> {
    inner: PhysicalDeviceShaderTileImageFeaturesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceShaderTileImageFeaturesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceShaderTileImageFeaturesEXTBuilder<'a> {
        PhysicalDeviceShaderTileImageFeaturesEXTBuilder {
            inner: PhysicalDeviceShaderTileImageFeaturesEXT {
                s_type: StructureType::from_raw(1000395000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceShaderTileImageFeaturesEXTBuilder<'a> {
    #[inline]
    pub fn shader_tile_image_color_read_access(mut self, value: bool) -> Self {
        self.inner.shader_tile_image_color_read_access = value as u32;
        self
    }
    #[inline]
    pub fn shader_tile_image_depth_read_access(mut self, value: bool) -> Self {
        self.inner.shader_tile_image_depth_read_access = value as u32;
        self
    }
    #[inline]
    pub fn shader_tile_image_stencil_read_access(mut self, value: bool) -> Self {
        self.inner.shader_tile_image_stencil_read_access = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceShaderTileImageFeaturesEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceShaderTileImageFeaturesEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceShaderTileImageFeaturesEXTBuilder<'a> {
    type Target = PhysicalDeviceShaderTileImageFeaturesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceShaderTileImageFeaturesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceShaderTileImagePropertiesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceShaderTileImagePropertiesEXTBuilder<'a> {
    inner: PhysicalDeviceShaderTileImagePropertiesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceShaderTileImagePropertiesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceShaderTileImagePropertiesEXTBuilder<'a> {
        PhysicalDeviceShaderTileImagePropertiesEXTBuilder {
            inner: PhysicalDeviceShaderTileImagePropertiesEXT {
                s_type: StructureType::from_raw(1000395001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceShaderTileImagePropertiesEXTBuilder<'a> {
    #[inline]
    pub fn shader_tile_image_coherent_read_accelerated(mut self, value: bool) -> Self {
        self.inner.shader_tile_image_coherent_read_accelerated = value as u32;
        self
    }
    #[inline]
    pub fn shader_tile_image_read_sample_from_pixel_rate_invocation(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.shader_tile_image_read_sample_from_pixel_rate_invocation = value
            as u32;
        self
    }
    #[inline]
    pub fn shader_tile_image_read_from_helper_invocation(mut self, value: bool) -> Self {
        self.inner.shader_tile_image_read_from_helper_invocation = value as u32;
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceShaderTileImagePropertiesEXTBuilder<'a> {
    type Target = PhysicalDeviceShaderTileImagePropertiesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceShaderTileImagePropertiesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ImportScreenBufferInfoQNX`] with lifetime-tied pNext safety.
pub struct ImportScreenBufferInfoQNXBuilder<'a> {
    inner: ImportScreenBufferInfoQNX,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ImportScreenBufferInfoQNX {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ImportScreenBufferInfoQNXBuilder<'a> {
        ImportScreenBufferInfoQNXBuilder {
            inner: ImportScreenBufferInfoQNX {
                s_type: StructureType::from_raw(1000529002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ImportScreenBufferInfoQNXBuilder<'a> {
    #[inline]
    pub fn buffer(mut self, value: *mut core::ffi::c_void) -> Self {
        self.inner.buffer = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`ImportScreenBufferInfoQNX`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsImportScreenBufferInfoQNX>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for ImportScreenBufferInfoQNXBuilder<'a> {
    type Target = ImportScreenBufferInfoQNX;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ImportScreenBufferInfoQNXBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ScreenBufferPropertiesQNX`] with lifetime-tied pNext safety.
pub struct ScreenBufferPropertiesQNXBuilder<'a> {
    inner: ScreenBufferPropertiesQNX,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ScreenBufferPropertiesQNX {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ScreenBufferPropertiesQNXBuilder<'a> {
        ScreenBufferPropertiesQNXBuilder {
            inner: ScreenBufferPropertiesQNX {
                s_type: StructureType::from_raw(1000529000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ScreenBufferPropertiesQNXBuilder<'a> {
    #[inline]
    pub fn allocation_size(mut self, value: u64) -> Self {
        self.inner.allocation_size = value;
        self
    }
    #[inline]
    pub fn memory_type_bits(mut self, value: u32) -> Self {
        self.inner.memory_type_bits = value;
        self
    }
}
impl<'a> core::ops::Deref for ScreenBufferPropertiesQNXBuilder<'a> {
    type Target = ScreenBufferPropertiesQNX;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ScreenBufferPropertiesQNXBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ScreenBufferFormatPropertiesQNX`] with lifetime-tied pNext safety.
pub struct ScreenBufferFormatPropertiesQNXBuilder<'a> {
    inner: ScreenBufferFormatPropertiesQNX,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ScreenBufferFormatPropertiesQNX {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ScreenBufferFormatPropertiesQNXBuilder<'a> {
        ScreenBufferFormatPropertiesQNXBuilder {
            inner: ScreenBufferFormatPropertiesQNX {
                s_type: StructureType::from_raw(1000529001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ScreenBufferFormatPropertiesQNXBuilder<'a> {
    #[inline]
    pub fn format(mut self, value: Format) -> Self {
        self.inner.format = value;
        self
    }
    #[inline]
    pub fn external_format(mut self, value: u64) -> Self {
        self.inner.external_format = value;
        self
    }
    #[inline]
    pub fn screen_usage(mut self, value: u64) -> Self {
        self.inner.screen_usage = value;
        self
    }
    #[inline]
    pub fn format_features(mut self, value: FormatFeatureFlags) -> Self {
        self.inner.format_features = value;
        self
    }
    #[inline]
    pub fn sampler_ycbcr_conversion_components(
        mut self,
        value: ComponentMapping,
    ) -> Self {
        self.inner.sampler_ycbcr_conversion_components = value;
        self
    }
    #[inline]
    pub fn suggested_ycbcr_model(mut self, value: SamplerYcbcrModelConversion) -> Self {
        self.inner.suggested_ycbcr_model = value;
        self
    }
    #[inline]
    pub fn suggested_ycbcr_range(mut self, value: SamplerYcbcrRange) -> Self {
        self.inner.suggested_ycbcr_range = value;
        self
    }
    #[inline]
    pub fn suggested_x_chroma_offset(mut self, value: ChromaLocation) -> Self {
        self.inner.suggested_x_chroma_offset = value;
        self
    }
    #[inline]
    pub fn suggested_y_chroma_offset(mut self, value: ChromaLocation) -> Self {
        self.inner.suggested_y_chroma_offset = value;
        self
    }
}
impl<'a> core::ops::Deref for ScreenBufferFormatPropertiesQNXBuilder<'a> {
    type Target = ScreenBufferFormatPropertiesQNX;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ScreenBufferFormatPropertiesQNXBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ExternalFormatQNX`] with lifetime-tied pNext safety.
pub struct ExternalFormatQNXBuilder<'a> {
    inner: ExternalFormatQNX,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ExternalFormatQNX {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ExternalFormatQNXBuilder<'a> {
        ExternalFormatQNXBuilder {
            inner: ExternalFormatQNX {
                s_type: StructureType::from_raw(1000529003i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ExternalFormatQNXBuilder<'a> {
    #[inline]
    pub fn external_format(mut self, value: u64) -> Self {
        self.inner.external_format = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`ExternalFormatQNX`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsExternalFormatQNX>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for ExternalFormatQNXBuilder<'a> {
    type Target = ExternalFormatQNX;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ExternalFormatQNXBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceExternalMemoryScreenBufferFeaturesQNXBuilder<'a> {
    inner: PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceExternalMemoryScreenBufferFeaturesQNXBuilder<
        'a,
    > {
        PhysicalDeviceExternalMemoryScreenBufferFeaturesQNXBuilder {
            inner: PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX {
                s_type: StructureType::from_raw(1000529004i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceExternalMemoryScreenBufferFeaturesQNXBuilder<'a> {
    #[inline]
    pub fn screen_buffer_import(mut self, value: bool) -> Self {
        self.inner.screen_buffer_import = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDeviceExternalMemoryScreenBufferFeaturesQNXBuilder<'a> {
    type Target = PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceExternalMemoryScreenBufferFeaturesQNXBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceCooperativeMatrixFeaturesKHR`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceCooperativeMatrixFeaturesKHRBuilder<'a> {
    inner: PhysicalDeviceCooperativeMatrixFeaturesKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceCooperativeMatrixFeaturesKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceCooperativeMatrixFeaturesKHRBuilder<'a> {
        PhysicalDeviceCooperativeMatrixFeaturesKHRBuilder {
            inner: PhysicalDeviceCooperativeMatrixFeaturesKHR {
                s_type: StructureType::from_raw(1000506000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceCooperativeMatrixFeaturesKHRBuilder<'a> {
    #[inline]
    pub fn cooperative_matrix(mut self, value: bool) -> Self {
        self.inner.cooperative_matrix = value as u32;
        self
    }
    #[inline]
    pub fn cooperative_matrix_robust_buffer_access(mut self, value: bool) -> Self {
        self.inner.cooperative_matrix_robust_buffer_access = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceCooperativeMatrixFeaturesKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceCooperativeMatrixFeaturesKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceCooperativeMatrixFeaturesKHRBuilder<'a> {
    type Target = PhysicalDeviceCooperativeMatrixFeaturesKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceCooperativeMatrixFeaturesKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`CooperativeMatrixPropertiesKHR`] with lifetime-tied pNext safety.
pub struct CooperativeMatrixPropertiesKHRBuilder<'a> {
    inner: CooperativeMatrixPropertiesKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl CooperativeMatrixPropertiesKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> CooperativeMatrixPropertiesKHRBuilder<'a> {
        CooperativeMatrixPropertiesKHRBuilder {
            inner: CooperativeMatrixPropertiesKHR {
                s_type: StructureType::from_raw(1000506001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> CooperativeMatrixPropertiesKHRBuilder<'a> {
    #[inline]
    pub fn m_size(mut self, value: u32) -> Self {
        self.inner.m_size = value;
        self
    }
    #[inline]
    pub fn n_size(mut self, value: u32) -> Self {
        self.inner.n_size = value;
        self
    }
    #[inline]
    pub fn k_size(mut self, value: u32) -> Self {
        self.inner.k_size = value;
        self
    }
    #[inline]
    pub fn a_type(mut self, value: ComponentTypeKHR) -> Self {
        self.inner.a_type = value;
        self
    }
    #[inline]
    pub fn b_type(mut self, value: ComponentTypeKHR) -> Self {
        self.inner.b_type = value;
        self
    }
    #[inline]
    pub fn c_type(mut self, value: ComponentTypeKHR) -> Self {
        self.inner.c_type = value;
        self
    }
    #[inline]
    pub fn result_type(mut self, value: ComponentTypeKHR) -> Self {
        self.inner.result_type = value;
        self
    }
    #[inline]
    pub fn saturating_accumulation(mut self, value: bool) -> Self {
        self.inner.saturating_accumulation = value as u32;
        self
    }
    #[inline]
    pub fn scope(mut self, value: ScopeKHR) -> Self {
        self.inner.scope = value;
        self
    }
}
impl<'a> core::ops::Deref for CooperativeMatrixPropertiesKHRBuilder<'a> {
    type Target = CooperativeMatrixPropertiesKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for CooperativeMatrixPropertiesKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceCooperativeMatrixPropertiesKHR`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceCooperativeMatrixPropertiesKHRBuilder<'a> {
    inner: PhysicalDeviceCooperativeMatrixPropertiesKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceCooperativeMatrixPropertiesKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceCooperativeMatrixPropertiesKHRBuilder<'a> {
        PhysicalDeviceCooperativeMatrixPropertiesKHRBuilder {
            inner: PhysicalDeviceCooperativeMatrixPropertiesKHR {
                s_type: StructureType::from_raw(1000506002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceCooperativeMatrixPropertiesKHRBuilder<'a> {
    #[inline]
    pub fn cooperative_matrix_supported_stages(
        mut self,
        value: ShaderStageFlags,
    ) -> Self {
        self.inner.cooperative_matrix_supported_stages = value;
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceCooperativeMatrixPropertiesKHRBuilder<'a> {
    type Target = PhysicalDeviceCooperativeMatrixPropertiesKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceCooperativeMatrixPropertiesKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceCooperativeMatrixConversionFeaturesQCOM`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceCooperativeMatrixConversionFeaturesQCOMBuilder<'a> {
    inner: PhysicalDeviceCooperativeMatrixConversionFeaturesQCOM,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceCooperativeMatrixConversionFeaturesQCOM {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceCooperativeMatrixConversionFeaturesQCOMBuilder<
        'a,
    > {
        PhysicalDeviceCooperativeMatrixConversionFeaturesQCOMBuilder {
            inner: PhysicalDeviceCooperativeMatrixConversionFeaturesQCOM {
                s_type: StructureType::from_raw(1000172000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceCooperativeMatrixConversionFeaturesQCOMBuilder<'a> {
    #[inline]
    pub fn cooperative_matrix_conversion(mut self, value: bool) -> Self {
        self.inner.cooperative_matrix_conversion = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceCooperativeMatrixConversionFeaturesQCOM`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceCooperativeMatrixConversionFeaturesQCOM>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDeviceCooperativeMatrixConversionFeaturesQCOMBuilder<'a> {
    type Target = PhysicalDeviceCooperativeMatrixConversionFeaturesQCOM;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceCooperativeMatrixConversionFeaturesQCOMBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceShaderEnqueuePropertiesAMDX`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceShaderEnqueuePropertiesAMDXBuilder<'a> {
    inner: PhysicalDeviceShaderEnqueuePropertiesAMDX,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceShaderEnqueuePropertiesAMDX {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceShaderEnqueuePropertiesAMDXBuilder<'a> {
        PhysicalDeviceShaderEnqueuePropertiesAMDXBuilder {
            inner: PhysicalDeviceShaderEnqueuePropertiesAMDX {
                s_type: StructureType::from_raw(1000134001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceShaderEnqueuePropertiesAMDXBuilder<'a> {
    #[inline]
    pub fn max_execution_graph_depth(mut self, value: u32) -> Self {
        self.inner.max_execution_graph_depth = value;
        self
    }
    #[inline]
    pub fn max_execution_graph_shader_output_nodes(mut self, value: u32) -> Self {
        self.inner.max_execution_graph_shader_output_nodes = value;
        self
    }
    #[inline]
    pub fn max_execution_graph_shader_payload_size(mut self, value: u32) -> Self {
        self.inner.max_execution_graph_shader_payload_size = value;
        self
    }
    #[inline]
    pub fn max_execution_graph_shader_payload_count(mut self, value: u32) -> Self {
        self.inner.max_execution_graph_shader_payload_count = value;
        self
    }
    #[inline]
    pub fn execution_graph_dispatch_address_alignment(mut self, value: u32) -> Self {
        self.inner.execution_graph_dispatch_address_alignment = value;
        self
    }
    #[inline]
    pub fn max_execution_graph_workgroup_count(mut self, value: [u32; 3usize]) -> Self {
        self.inner.max_execution_graph_workgroup_count = value;
        self
    }
    #[inline]
    pub fn max_execution_graph_workgroups(mut self, value: u32) -> Self {
        self.inner.max_execution_graph_workgroups = value;
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceShaderEnqueuePropertiesAMDXBuilder<'a> {
    type Target = PhysicalDeviceShaderEnqueuePropertiesAMDX;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceShaderEnqueuePropertiesAMDXBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceShaderEnqueueFeaturesAMDX`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceShaderEnqueueFeaturesAMDXBuilder<'a> {
    inner: PhysicalDeviceShaderEnqueueFeaturesAMDX,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceShaderEnqueueFeaturesAMDX {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceShaderEnqueueFeaturesAMDXBuilder<'a> {
        PhysicalDeviceShaderEnqueueFeaturesAMDXBuilder {
            inner: PhysicalDeviceShaderEnqueueFeaturesAMDX {
                s_type: StructureType::from_raw(1000134000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceShaderEnqueueFeaturesAMDXBuilder<'a> {
    #[inline]
    pub fn shader_enqueue(mut self, value: bool) -> Self {
        self.inner.shader_enqueue = value as u32;
        self
    }
    #[inline]
    pub fn shader_mesh_enqueue(mut self, value: bool) -> Self {
        self.inner.shader_mesh_enqueue = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceShaderEnqueueFeaturesAMDX`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceShaderEnqueueFeaturesAMDX>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceShaderEnqueueFeaturesAMDXBuilder<'a> {
    type Target = PhysicalDeviceShaderEnqueueFeaturesAMDX;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceShaderEnqueueFeaturesAMDXBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ExecutionGraphPipelineCreateInfoAMDX`] with lifetime-tied pNext safety.
pub struct ExecutionGraphPipelineCreateInfoAMDXBuilder<'a> {
    inner: ExecutionGraphPipelineCreateInfoAMDX,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ExecutionGraphPipelineCreateInfoAMDX {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ExecutionGraphPipelineCreateInfoAMDXBuilder<'a> {
        ExecutionGraphPipelineCreateInfoAMDXBuilder {
            inner: ExecutionGraphPipelineCreateInfoAMDX {
                s_type: StructureType::from_raw(1000134003i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ExecutionGraphPipelineCreateInfoAMDXBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: PipelineCreateFlags) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn stage_count(mut self, value: u32) -> Self {
        self.inner.stage_count = value;
        self
    }
    #[inline]
    pub fn stages(mut self, slice: &'a [PipelineShaderStageCreateInfo]) -> Self {
        self.inner.stage_count = slice.len() as u32;
        self.inner.p_stages = slice.as_ptr();
        self
    }
    #[inline]
    pub fn library_info(mut self, value: &'a PipelineLibraryCreateInfoKHR) -> Self {
        self.inner.p_library_info = value;
        self
    }
    #[inline]
    pub fn layout(mut self, value: PipelineLayout) -> Self {
        self.inner.layout = value;
        self
    }
    #[inline]
    pub fn base_pipeline_handle(mut self, value: Pipeline) -> Self {
        self.inner.base_pipeline_handle = value;
        self
    }
    #[inline]
    pub fn base_pipeline_index(mut self, value: i32) -> Self {
        self.inner.base_pipeline_index = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`ExecutionGraphPipelineCreateInfoAMDX`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsExecutionGraphPipelineCreateInfoAMDX>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for ExecutionGraphPipelineCreateInfoAMDXBuilder<'a> {
    type Target = ExecutionGraphPipelineCreateInfoAMDX;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ExecutionGraphPipelineCreateInfoAMDXBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PipelineShaderStageNodeCreateInfoAMDX`] with lifetime-tied pNext safety.
pub struct PipelineShaderStageNodeCreateInfoAMDXBuilder<'a> {
    inner: PipelineShaderStageNodeCreateInfoAMDX,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PipelineShaderStageNodeCreateInfoAMDX {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PipelineShaderStageNodeCreateInfoAMDXBuilder<'a> {
        PipelineShaderStageNodeCreateInfoAMDXBuilder {
            inner: PipelineShaderStageNodeCreateInfoAMDX {
                s_type: StructureType::from_raw(1000134004i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PipelineShaderStageNodeCreateInfoAMDXBuilder<'a> {
    #[inline]
    pub fn name(mut self, value: &'a core::ffi::CStr) -> Self {
        self.inner.p_name = value.as_ptr();
        self
    }
    #[inline]
    pub fn index(mut self, value: u32) -> Self {
        self.inner.index = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PipelineShaderStageNodeCreateInfoAMDX`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPipelineShaderStageNodeCreateInfoAMDX>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for PipelineShaderStageNodeCreateInfoAMDXBuilder<'a> {
    type Target = PipelineShaderStageNodeCreateInfoAMDX;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PipelineShaderStageNodeCreateInfoAMDXBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ExecutionGraphPipelineScratchSizeAMDX`] with lifetime-tied pNext safety.
pub struct ExecutionGraphPipelineScratchSizeAMDXBuilder<'a> {
    inner: ExecutionGraphPipelineScratchSizeAMDX,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ExecutionGraphPipelineScratchSizeAMDX {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ExecutionGraphPipelineScratchSizeAMDXBuilder<'a> {
        ExecutionGraphPipelineScratchSizeAMDXBuilder {
            inner: ExecutionGraphPipelineScratchSizeAMDX {
                s_type: StructureType::from_raw(1000134002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ExecutionGraphPipelineScratchSizeAMDXBuilder<'a> {
    #[inline]
    pub fn min_size(mut self, value: u64) -> Self {
        self.inner.min_size = value;
        self
    }
    #[inline]
    pub fn max_size(mut self, value: u64) -> Self {
        self.inner.max_size = value;
        self
    }
    #[inline]
    pub fn size_granularity(mut self, value: u64) -> Self {
        self.inner.size_granularity = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`ExecutionGraphPipelineScratchSizeAMDX`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsExecutionGraphPipelineScratchSizeAMDX>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for ExecutionGraphPipelineScratchSizeAMDXBuilder<'a> {
    type Target = ExecutionGraphPipelineScratchSizeAMDX;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ExecutionGraphPipelineScratchSizeAMDXBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DispatchGraphInfoAMDX`].
pub struct DispatchGraphInfoAMDXBuilder {
    inner: DispatchGraphInfoAMDX,
}
impl DispatchGraphInfoAMDX {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> DispatchGraphInfoAMDXBuilder {
        DispatchGraphInfoAMDXBuilder {
            inner: DispatchGraphInfoAMDX {
                ..Default::default()
            },
        }
    }
}
impl DispatchGraphInfoAMDXBuilder {
    #[inline]
    pub fn node_index(mut self, value: u32) -> Self {
        self.inner.node_index = value;
        self
    }
    #[inline]
    pub fn payload_count(mut self, value: u32) -> Self {
        self.inner.payload_count = value;
        self
    }
    #[inline]
    pub fn payloads(mut self, value: DeviceOrHostAddressConstAMDX) -> Self {
        self.inner.payloads = value;
        self
    }
    #[inline]
    pub fn payload_stride(mut self, value: u64) -> Self {
        self.inner.payload_stride = value;
        self
    }
}
impl core::ops::Deref for DispatchGraphInfoAMDXBuilder {
    type Target = DispatchGraphInfoAMDX;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for DispatchGraphInfoAMDXBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DispatchGraphCountInfoAMDX`].
pub struct DispatchGraphCountInfoAMDXBuilder {
    inner: DispatchGraphCountInfoAMDX,
}
impl DispatchGraphCountInfoAMDX {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> DispatchGraphCountInfoAMDXBuilder {
        DispatchGraphCountInfoAMDXBuilder {
            inner: DispatchGraphCountInfoAMDX {
                ..Default::default()
            },
        }
    }
}
impl DispatchGraphCountInfoAMDXBuilder {
    #[inline]
    pub fn count(mut self, value: u32) -> Self {
        self.inner.count = value;
        self
    }
    #[inline]
    pub fn infos(mut self, value: DeviceOrHostAddressConstAMDX) -> Self {
        self.inner.infos = value;
        self
    }
    #[inline]
    pub fn stride(mut self, value: u64) -> Self {
        self.inner.stride = value;
        self
    }
}
impl core::ops::Deref for DispatchGraphCountInfoAMDXBuilder {
    type Target = DispatchGraphCountInfoAMDX;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for DispatchGraphCountInfoAMDXBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceAntiLagFeaturesAMD`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceAntiLagFeaturesAMDBuilder<'a> {
    inner: PhysicalDeviceAntiLagFeaturesAMD,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceAntiLagFeaturesAMD {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceAntiLagFeaturesAMDBuilder<'a> {
        PhysicalDeviceAntiLagFeaturesAMDBuilder {
            inner: PhysicalDeviceAntiLagFeaturesAMD {
                s_type: StructureType::from_raw(1000476000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceAntiLagFeaturesAMDBuilder<'a> {
    #[inline]
    pub fn anti_lag(mut self, value: bool) -> Self {
        self.inner.anti_lag = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceAntiLagFeaturesAMD`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceAntiLagFeaturesAMD>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceAntiLagFeaturesAMDBuilder<'a> {
    type Target = PhysicalDeviceAntiLagFeaturesAMD;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceAntiLagFeaturesAMDBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`AntiLagDataAMD`] with lifetime-tied pNext safety.
pub struct AntiLagDataAMDBuilder<'a> {
    inner: AntiLagDataAMD,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl AntiLagDataAMD {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> AntiLagDataAMDBuilder<'a> {
        AntiLagDataAMDBuilder {
            inner: AntiLagDataAMD {
                s_type: StructureType::from_raw(1000476001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> AntiLagDataAMDBuilder<'a> {
    #[inline]
    pub fn mode(mut self, value: AntiLagModeAMD) -> Self {
        self.inner.mode = value;
        self
    }
    #[inline]
    pub fn max_fps(mut self, value: u32) -> Self {
        self.inner.max_fps = value;
        self
    }
    #[inline]
    pub fn presentation_info(mut self, value: &'a AntiLagPresentationInfoAMD) -> Self {
        self.inner.p_presentation_info = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`AntiLagDataAMD`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsAntiLagDataAMD>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for AntiLagDataAMDBuilder<'a> {
    type Target = AntiLagDataAMD;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for AntiLagDataAMDBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`AntiLagPresentationInfoAMD`] with lifetime-tied pNext safety.
pub struct AntiLagPresentationInfoAMDBuilder<'a> {
    inner: AntiLagPresentationInfoAMD,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl AntiLagPresentationInfoAMD {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> AntiLagPresentationInfoAMDBuilder<'a> {
        AntiLagPresentationInfoAMDBuilder {
            inner: AntiLagPresentationInfoAMD {
                s_type: StructureType::from_raw(1000476002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> AntiLagPresentationInfoAMDBuilder<'a> {
    #[inline]
    pub fn stage(mut self, value: AntiLagStageAMD) -> Self {
        self.inner.stage = value;
        self
    }
    #[inline]
    pub fn frame_index(mut self, value: u64) -> Self {
        self.inner.frame_index = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`AntiLagPresentationInfoAMD`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsAntiLagPresentationInfoAMD>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for AntiLagPresentationInfoAMDBuilder<'a> {
    type Target = AntiLagPresentationInfoAMD;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for AntiLagPresentationInfoAMDBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`BindMemoryStatus`] with lifetime-tied pNext safety.
pub struct BindMemoryStatusBuilder<'a> {
    inner: BindMemoryStatus,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl BindMemoryStatus {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> BindMemoryStatusBuilder<'a> {
        BindMemoryStatusBuilder {
            inner: BindMemoryStatus {
                s_type: StructureType::from_raw(1000545002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> BindMemoryStatusBuilder<'a> {
    #[inline]
    pub fn result(mut self, value: *mut Result) -> Self {
        self.inner.p_result = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`BindMemoryStatus`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsBindMemoryStatus>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for BindMemoryStatusBuilder<'a> {
    type Target = BindMemoryStatus;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for BindMemoryStatusBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceTileMemoryHeapFeaturesQCOM`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceTileMemoryHeapFeaturesQCOMBuilder<'a> {
    inner: PhysicalDeviceTileMemoryHeapFeaturesQCOM,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceTileMemoryHeapFeaturesQCOM {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceTileMemoryHeapFeaturesQCOMBuilder<'a> {
        PhysicalDeviceTileMemoryHeapFeaturesQCOMBuilder {
            inner: PhysicalDeviceTileMemoryHeapFeaturesQCOM {
                s_type: StructureType::from_raw(1000547000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceTileMemoryHeapFeaturesQCOMBuilder<'a> {
    #[inline]
    pub fn tile_memory_heap(mut self, value: bool) -> Self {
        self.inner.tile_memory_heap = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceTileMemoryHeapFeaturesQCOM`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceTileMemoryHeapFeaturesQCOM>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceTileMemoryHeapFeaturesQCOMBuilder<'a> {
    type Target = PhysicalDeviceTileMemoryHeapFeaturesQCOM;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceTileMemoryHeapFeaturesQCOMBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceTileMemoryHeapPropertiesQCOM`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceTileMemoryHeapPropertiesQCOMBuilder<'a> {
    inner: PhysicalDeviceTileMemoryHeapPropertiesQCOM,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceTileMemoryHeapPropertiesQCOM {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceTileMemoryHeapPropertiesQCOMBuilder<'a> {
        PhysicalDeviceTileMemoryHeapPropertiesQCOMBuilder {
            inner: PhysicalDeviceTileMemoryHeapPropertiesQCOM {
                s_type: StructureType::from_raw(1000547001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceTileMemoryHeapPropertiesQCOMBuilder<'a> {
    #[inline]
    pub fn queue_submit_boundary(mut self, value: bool) -> Self {
        self.inner.queue_submit_boundary = value as u32;
        self
    }
    #[inline]
    pub fn tile_buffer_transfers(mut self, value: bool) -> Self {
        self.inner.tile_buffer_transfers = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceTileMemoryHeapPropertiesQCOM`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceTileMemoryHeapPropertiesQCOM>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceTileMemoryHeapPropertiesQCOMBuilder<'a> {
    type Target = PhysicalDeviceTileMemoryHeapPropertiesQCOM;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceTileMemoryHeapPropertiesQCOMBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`TileMemorySizeInfoQCOM`] with lifetime-tied pNext safety.
pub struct TileMemorySizeInfoQCOMBuilder<'a> {
    inner: TileMemorySizeInfoQCOM,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl TileMemorySizeInfoQCOM {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> TileMemorySizeInfoQCOMBuilder<'a> {
        TileMemorySizeInfoQCOMBuilder {
            inner: TileMemorySizeInfoQCOM {
                s_type: StructureType::from_raw(1000547004i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> TileMemorySizeInfoQCOMBuilder<'a> {
    #[inline]
    pub fn size(mut self, value: u64) -> Self {
        self.inner.size = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`TileMemorySizeInfoQCOM`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsTileMemorySizeInfoQCOM>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for TileMemorySizeInfoQCOMBuilder<'a> {
    type Target = TileMemorySizeInfoQCOM;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for TileMemorySizeInfoQCOMBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`TileMemoryRequirementsQCOM`] with lifetime-tied pNext safety.
pub struct TileMemoryRequirementsQCOMBuilder<'a> {
    inner: TileMemoryRequirementsQCOM,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl TileMemoryRequirementsQCOM {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> TileMemoryRequirementsQCOMBuilder<'a> {
        TileMemoryRequirementsQCOMBuilder {
            inner: TileMemoryRequirementsQCOM {
                s_type: StructureType::from_raw(1000547002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> TileMemoryRequirementsQCOMBuilder<'a> {
    #[inline]
    pub fn size(mut self, value: u64) -> Self {
        self.inner.size = value;
        self
    }
    #[inline]
    pub fn alignment(mut self, value: u64) -> Self {
        self.inner.alignment = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`TileMemoryRequirementsQCOM`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsTileMemoryRequirementsQCOM>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for TileMemoryRequirementsQCOMBuilder<'a> {
    type Target = TileMemoryRequirementsQCOM;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for TileMemoryRequirementsQCOMBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`BindDescriptorSetsInfo`] with lifetime-tied pNext safety.
pub struct BindDescriptorSetsInfoBuilder<'a> {
    inner: BindDescriptorSetsInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl BindDescriptorSetsInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> BindDescriptorSetsInfoBuilder<'a> {
        BindDescriptorSetsInfoBuilder {
            inner: BindDescriptorSetsInfo {
                s_type: StructureType::from_raw(1000545003i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> BindDescriptorSetsInfoBuilder<'a> {
    #[inline]
    pub fn stage_flags(mut self, value: ShaderStageFlags) -> Self {
        self.inner.stage_flags = value;
        self
    }
    #[inline]
    pub fn layout(mut self, value: PipelineLayout) -> Self {
        self.inner.layout = value;
        self
    }
    #[inline]
    pub fn first_set(mut self, value: u32) -> Self {
        self.inner.first_set = value;
        self
    }
    #[inline]
    pub fn descriptor_sets(mut self, slice: &'a [DescriptorSet]) -> Self {
        self.inner.descriptor_set_count = slice.len() as u32;
        self.inner.p_descriptor_sets = slice.as_ptr();
        self
    }
    #[inline]
    pub fn dynamic_offset_count(mut self, value: u32) -> Self {
        self.inner.dynamic_offset_count = value;
        self
    }
    #[inline]
    pub fn dynamic_offsets(mut self, slice: &'a [u32]) -> Self {
        self.inner.dynamic_offset_count = slice.len() as u32;
        self.inner.p_dynamic_offsets = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`BindDescriptorSetsInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsBindDescriptorSetsInfo>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for BindDescriptorSetsInfoBuilder<'a> {
    type Target = BindDescriptorSetsInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for BindDescriptorSetsInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PushConstantsInfo`] with lifetime-tied pNext safety.
pub struct PushConstantsInfoBuilder<'a> {
    inner: PushConstantsInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PushConstantsInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PushConstantsInfoBuilder<'a> {
        PushConstantsInfoBuilder {
            inner: PushConstantsInfo {
                s_type: StructureType::from_raw(1000545004i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PushConstantsInfoBuilder<'a> {
    #[inline]
    pub fn layout(mut self, value: PipelineLayout) -> Self {
        self.inner.layout = value;
        self
    }
    #[inline]
    pub fn stage_flags(mut self, value: ShaderStageFlags) -> Self {
        self.inner.stage_flags = value;
        self
    }
    #[inline]
    pub fn offset(mut self, value: u32) -> Self {
        self.inner.offset = value;
        self
    }
    #[inline]
    pub fn values(mut self, slice: &'a [core::ffi::c_void]) -> Self {
        self.inner.size = slice.len() as u32;
        self.inner.p_values = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`PushConstantsInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPushConstantsInfo>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for PushConstantsInfoBuilder<'a> {
    type Target = PushConstantsInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PushConstantsInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PushDescriptorSetInfo`] with lifetime-tied pNext safety.
pub struct PushDescriptorSetInfoBuilder<'a> {
    inner: PushDescriptorSetInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PushDescriptorSetInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PushDescriptorSetInfoBuilder<'a> {
        PushDescriptorSetInfoBuilder {
            inner: PushDescriptorSetInfo {
                s_type: StructureType::from_raw(1000545005i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PushDescriptorSetInfoBuilder<'a> {
    #[inline]
    pub fn stage_flags(mut self, value: ShaderStageFlags) -> Self {
        self.inner.stage_flags = value;
        self
    }
    #[inline]
    pub fn layout(mut self, value: PipelineLayout) -> Self {
        self.inner.layout = value;
        self
    }
    #[inline]
    pub fn set(mut self, value: u32) -> Self {
        self.inner.set = value;
        self
    }
    #[inline]
    pub fn descriptor_writes(mut self, slice: &'a [WriteDescriptorSet]) -> Self {
        self.inner.descriptor_write_count = slice.len() as u32;
        self.inner.p_descriptor_writes = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`PushDescriptorSetInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPushDescriptorSetInfo>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for PushDescriptorSetInfoBuilder<'a> {
    type Target = PushDescriptorSetInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PushDescriptorSetInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PushDescriptorSetWithTemplateInfo`] with lifetime-tied pNext safety.
pub struct PushDescriptorSetWithTemplateInfoBuilder<'a> {
    inner: PushDescriptorSetWithTemplateInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PushDescriptorSetWithTemplateInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PushDescriptorSetWithTemplateInfoBuilder<'a> {
        PushDescriptorSetWithTemplateInfoBuilder {
            inner: PushDescriptorSetWithTemplateInfo {
                s_type: StructureType::from_raw(1000545006i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PushDescriptorSetWithTemplateInfoBuilder<'a> {
    #[inline]
    pub fn descriptor_update_template(
        mut self,
        value: DescriptorUpdateTemplate,
    ) -> Self {
        self.inner.descriptor_update_template = value;
        self
    }
    #[inline]
    pub fn layout(mut self, value: PipelineLayout) -> Self {
        self.inner.layout = value;
        self
    }
    #[inline]
    pub fn set(mut self, value: u32) -> Self {
        self.inner.set = value;
        self
    }
    #[inline]
    pub fn data(mut self, value: *const core::ffi::c_void) -> Self {
        self.inner.p_data = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PushDescriptorSetWithTemplateInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPushDescriptorSetWithTemplateInfo>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for PushDescriptorSetWithTemplateInfoBuilder<'a> {
    type Target = PushDescriptorSetWithTemplateInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PushDescriptorSetWithTemplateInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`SetDescriptorBufferOffsetsInfoEXT`] with lifetime-tied pNext safety.
pub struct SetDescriptorBufferOffsetsInfoEXTBuilder<'a> {
    inner: SetDescriptorBufferOffsetsInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl SetDescriptorBufferOffsetsInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> SetDescriptorBufferOffsetsInfoEXTBuilder<'a> {
        SetDescriptorBufferOffsetsInfoEXTBuilder {
            inner: SetDescriptorBufferOffsetsInfoEXT {
                s_type: StructureType::from_raw(1000545007i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> SetDescriptorBufferOffsetsInfoEXTBuilder<'a> {
    #[inline]
    pub fn stage_flags(mut self, value: ShaderStageFlags) -> Self {
        self.inner.stage_flags = value;
        self
    }
    #[inline]
    pub fn layout(mut self, value: PipelineLayout) -> Self {
        self.inner.layout = value;
        self
    }
    #[inline]
    pub fn first_set(mut self, value: u32) -> Self {
        self.inner.first_set = value;
        self
    }
    #[inline]
    pub fn buffer_indices(mut self, slice: &'a [u32]) -> Self {
        self.inner.set_count = slice.len() as u32;
        self.inner.p_buffer_indices = slice.as_ptr();
        self
    }
    #[inline]
    pub fn offsets(mut self, slice: &'a [u64]) -> Self {
        self.inner.set_count = slice.len() as u32;
        self.inner.p_offsets = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`SetDescriptorBufferOffsetsInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsSetDescriptorBufferOffsetsInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for SetDescriptorBufferOffsetsInfoEXTBuilder<'a> {
    type Target = SetDescriptorBufferOffsetsInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for SetDescriptorBufferOffsetsInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`BindDescriptorBufferEmbeddedSamplersInfoEXT`] with lifetime-tied pNext safety.
pub struct BindDescriptorBufferEmbeddedSamplersInfoEXTBuilder<'a> {
    inner: BindDescriptorBufferEmbeddedSamplersInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl BindDescriptorBufferEmbeddedSamplersInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> BindDescriptorBufferEmbeddedSamplersInfoEXTBuilder<'a> {
        BindDescriptorBufferEmbeddedSamplersInfoEXTBuilder {
            inner: BindDescriptorBufferEmbeddedSamplersInfoEXT {
                s_type: StructureType::from_raw(1000545008i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> BindDescriptorBufferEmbeddedSamplersInfoEXTBuilder<'a> {
    #[inline]
    pub fn stage_flags(mut self, value: ShaderStageFlags) -> Self {
        self.inner.stage_flags = value;
        self
    }
    #[inline]
    pub fn layout(mut self, value: PipelineLayout) -> Self {
        self.inner.layout = value;
        self
    }
    #[inline]
    pub fn set(mut self, value: u32) -> Self {
        self.inner.set = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`BindDescriptorBufferEmbeddedSamplersInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsBindDescriptorBufferEmbeddedSamplersInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for BindDescriptorBufferEmbeddedSamplersInfoEXTBuilder<'a> {
    type Target = BindDescriptorBufferEmbeddedSamplersInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for BindDescriptorBufferEmbeddedSamplersInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceCubicClampFeaturesQCOM`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceCubicClampFeaturesQCOMBuilder<'a> {
    inner: PhysicalDeviceCubicClampFeaturesQCOM,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceCubicClampFeaturesQCOM {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceCubicClampFeaturesQCOMBuilder<'a> {
        PhysicalDeviceCubicClampFeaturesQCOMBuilder {
            inner: PhysicalDeviceCubicClampFeaturesQCOM {
                s_type: StructureType::from_raw(1000521000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceCubicClampFeaturesQCOMBuilder<'a> {
    #[inline]
    pub fn cubic_range_clamp(mut self, value: bool) -> Self {
        self.inner.cubic_range_clamp = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceCubicClampFeaturesQCOM`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceCubicClampFeaturesQCOM>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceCubicClampFeaturesQCOMBuilder<'a> {
    type Target = PhysicalDeviceCubicClampFeaturesQCOM;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceCubicClampFeaturesQCOMBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceYcbcrDegammaFeaturesQCOM`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceYcbcrDegammaFeaturesQCOMBuilder<'a> {
    inner: PhysicalDeviceYcbcrDegammaFeaturesQCOM,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceYcbcrDegammaFeaturesQCOM {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceYcbcrDegammaFeaturesQCOMBuilder<'a> {
        PhysicalDeviceYcbcrDegammaFeaturesQCOMBuilder {
            inner: PhysicalDeviceYcbcrDegammaFeaturesQCOM {
                s_type: StructureType::from_raw(1000520000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceYcbcrDegammaFeaturesQCOMBuilder<'a> {
    #[inline]
    pub fn ycbcr_degamma(mut self, value: bool) -> Self {
        self.inner.ycbcr_degamma = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceYcbcrDegammaFeaturesQCOM`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceYcbcrDegammaFeaturesQCOM>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceYcbcrDegammaFeaturesQCOMBuilder<'a> {
    type Target = PhysicalDeviceYcbcrDegammaFeaturesQCOM;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceYcbcrDegammaFeaturesQCOMBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM`] with lifetime-tied pNext safety.
pub struct SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOMBuilder<'a> {
    inner: SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOMBuilder<'a> {
        SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOMBuilder {
            inner: SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM {
                s_type: StructureType::from_raw(1000520001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOMBuilder<'a> {
    #[inline]
    pub fn enable_y_degamma(mut self, value: bool) -> Self {
        self.inner.enable_y_degamma = value as u32;
        self
    }
    #[inline]
    pub fn enable_cb_cr_degamma(mut self, value: bool) -> Self {
        self.inner.enable_cb_cr_degamma = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref
for SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOMBuilder<'a> {
    type Target = SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOMBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceCubicWeightsFeaturesQCOM`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceCubicWeightsFeaturesQCOMBuilder<'a> {
    inner: PhysicalDeviceCubicWeightsFeaturesQCOM,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceCubicWeightsFeaturesQCOM {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceCubicWeightsFeaturesQCOMBuilder<'a> {
        PhysicalDeviceCubicWeightsFeaturesQCOMBuilder {
            inner: PhysicalDeviceCubicWeightsFeaturesQCOM {
                s_type: StructureType::from_raw(1000519001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceCubicWeightsFeaturesQCOMBuilder<'a> {
    #[inline]
    pub fn selectable_cubic_weights(mut self, value: bool) -> Self {
        self.inner.selectable_cubic_weights = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceCubicWeightsFeaturesQCOM`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceCubicWeightsFeaturesQCOM>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceCubicWeightsFeaturesQCOMBuilder<'a> {
    type Target = PhysicalDeviceCubicWeightsFeaturesQCOM;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceCubicWeightsFeaturesQCOMBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`SamplerCubicWeightsCreateInfoQCOM`] with lifetime-tied pNext safety.
pub struct SamplerCubicWeightsCreateInfoQCOMBuilder<'a> {
    inner: SamplerCubicWeightsCreateInfoQCOM,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl SamplerCubicWeightsCreateInfoQCOM {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> SamplerCubicWeightsCreateInfoQCOMBuilder<'a> {
        SamplerCubicWeightsCreateInfoQCOMBuilder {
            inner: SamplerCubicWeightsCreateInfoQCOM {
                s_type: StructureType::from_raw(1000519000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> SamplerCubicWeightsCreateInfoQCOMBuilder<'a> {
    #[inline]
    pub fn cubic_weights(mut self, value: CubicFilterWeightsQCOM) -> Self {
        self.inner.cubic_weights = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`SamplerCubicWeightsCreateInfoQCOM`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsSamplerCubicWeightsCreateInfoQCOM>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for SamplerCubicWeightsCreateInfoQCOMBuilder<'a> {
    type Target = SamplerCubicWeightsCreateInfoQCOM;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for SamplerCubicWeightsCreateInfoQCOMBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`BlitImageCubicWeightsInfoQCOM`] with lifetime-tied pNext safety.
pub struct BlitImageCubicWeightsInfoQCOMBuilder<'a> {
    inner: BlitImageCubicWeightsInfoQCOM,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl BlitImageCubicWeightsInfoQCOM {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> BlitImageCubicWeightsInfoQCOMBuilder<'a> {
        BlitImageCubicWeightsInfoQCOMBuilder {
            inner: BlitImageCubicWeightsInfoQCOM {
                s_type: StructureType::from_raw(1000519002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> BlitImageCubicWeightsInfoQCOMBuilder<'a> {
    #[inline]
    pub fn cubic_weights(mut self, value: CubicFilterWeightsQCOM) -> Self {
        self.inner.cubic_weights = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`BlitImageCubicWeightsInfoQCOM`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsBlitImageCubicWeightsInfoQCOM>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for BlitImageCubicWeightsInfoQCOMBuilder<'a> {
    type Target = BlitImageCubicWeightsInfoQCOM;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for BlitImageCubicWeightsInfoQCOMBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceImageProcessing2FeaturesQCOM`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceImageProcessing2FeaturesQCOMBuilder<'a> {
    inner: PhysicalDeviceImageProcessing2FeaturesQCOM,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceImageProcessing2FeaturesQCOM {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceImageProcessing2FeaturesQCOMBuilder<'a> {
        PhysicalDeviceImageProcessing2FeaturesQCOMBuilder {
            inner: PhysicalDeviceImageProcessing2FeaturesQCOM {
                s_type: StructureType::from_raw(1000518000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceImageProcessing2FeaturesQCOMBuilder<'a> {
    #[inline]
    pub fn texture_block_match2(mut self, value: bool) -> Self {
        self.inner.texture_block_match2 = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceImageProcessing2FeaturesQCOM`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceImageProcessing2FeaturesQCOM>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceImageProcessing2FeaturesQCOMBuilder<'a> {
    type Target = PhysicalDeviceImageProcessing2FeaturesQCOM;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceImageProcessing2FeaturesQCOMBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceImageProcessing2PropertiesQCOM`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceImageProcessing2PropertiesQCOMBuilder<'a> {
    inner: PhysicalDeviceImageProcessing2PropertiesQCOM,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceImageProcessing2PropertiesQCOM {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceImageProcessing2PropertiesQCOMBuilder<'a> {
        PhysicalDeviceImageProcessing2PropertiesQCOMBuilder {
            inner: PhysicalDeviceImageProcessing2PropertiesQCOM {
                s_type: StructureType::from_raw(1000518001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceImageProcessing2PropertiesQCOMBuilder<'a> {
    #[inline]
    pub fn max_block_match_window(mut self, value: Extent2D) -> Self {
        self.inner.max_block_match_window = value;
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceImageProcessing2PropertiesQCOMBuilder<'a> {
    type Target = PhysicalDeviceImageProcessing2PropertiesQCOM;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceImageProcessing2PropertiesQCOMBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`SamplerBlockMatchWindowCreateInfoQCOM`] with lifetime-tied pNext safety.
pub struct SamplerBlockMatchWindowCreateInfoQCOMBuilder<'a> {
    inner: SamplerBlockMatchWindowCreateInfoQCOM,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl SamplerBlockMatchWindowCreateInfoQCOM {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> SamplerBlockMatchWindowCreateInfoQCOMBuilder<'a> {
        SamplerBlockMatchWindowCreateInfoQCOMBuilder {
            inner: SamplerBlockMatchWindowCreateInfoQCOM {
                s_type: StructureType::from_raw(1000518002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> SamplerBlockMatchWindowCreateInfoQCOMBuilder<'a> {
    #[inline]
    pub fn window_extent(mut self, value: Extent2D) -> Self {
        self.inner.window_extent = value;
        self
    }
    #[inline]
    pub fn window_compare_mode(
        mut self,
        value: BlockMatchWindowCompareModeQCOM,
    ) -> Self {
        self.inner.window_compare_mode = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`SamplerBlockMatchWindowCreateInfoQCOM`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsSamplerBlockMatchWindowCreateInfoQCOM>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for SamplerBlockMatchWindowCreateInfoQCOMBuilder<'a> {
    type Target = SamplerBlockMatchWindowCreateInfoQCOM;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for SamplerBlockMatchWindowCreateInfoQCOMBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceDescriptorPoolOverallocationFeaturesNV`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceDescriptorPoolOverallocationFeaturesNVBuilder<'a> {
    inner: PhysicalDeviceDescriptorPoolOverallocationFeaturesNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceDescriptorPoolOverallocationFeaturesNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceDescriptorPoolOverallocationFeaturesNVBuilder<
        'a,
    > {
        PhysicalDeviceDescriptorPoolOverallocationFeaturesNVBuilder {
            inner: PhysicalDeviceDescriptorPoolOverallocationFeaturesNV {
                s_type: StructureType::from_raw(1000546000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceDescriptorPoolOverallocationFeaturesNVBuilder<'a> {
    #[inline]
    pub fn descriptor_pool_overallocation(mut self, value: bool) -> Self {
        self.inner.descriptor_pool_overallocation = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceDescriptorPoolOverallocationFeaturesNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceDescriptorPoolOverallocationFeaturesNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDeviceDescriptorPoolOverallocationFeaturesNVBuilder<'a> {
    type Target = PhysicalDeviceDescriptorPoolOverallocationFeaturesNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceDescriptorPoolOverallocationFeaturesNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceLayeredDriverPropertiesMSFT`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceLayeredDriverPropertiesMSFTBuilder<'a> {
    inner: PhysicalDeviceLayeredDriverPropertiesMSFT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceLayeredDriverPropertiesMSFT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceLayeredDriverPropertiesMSFTBuilder<'a> {
        PhysicalDeviceLayeredDriverPropertiesMSFTBuilder {
            inner: PhysicalDeviceLayeredDriverPropertiesMSFT {
                s_type: StructureType::from_raw(1000530000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceLayeredDriverPropertiesMSFTBuilder<'a> {
    #[inline]
    pub fn underlying_api(mut self, value: LayeredDriverUnderlyingApiMSFT) -> Self {
        self.inner.underlying_api = value;
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceLayeredDriverPropertiesMSFTBuilder<'a> {
    type Target = PhysicalDeviceLayeredDriverPropertiesMSFT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceLayeredDriverPropertiesMSFTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDevicePerStageDescriptorSetFeaturesNV`] with lifetime-tied pNext safety.
pub struct PhysicalDevicePerStageDescriptorSetFeaturesNVBuilder<'a> {
    inner: PhysicalDevicePerStageDescriptorSetFeaturesNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDevicePerStageDescriptorSetFeaturesNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDevicePerStageDescriptorSetFeaturesNVBuilder<'a> {
        PhysicalDevicePerStageDescriptorSetFeaturesNVBuilder {
            inner: PhysicalDevicePerStageDescriptorSetFeaturesNV {
                s_type: StructureType::from_raw(1000516000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDevicePerStageDescriptorSetFeaturesNVBuilder<'a> {
    #[inline]
    pub fn per_stage_descriptor_set(mut self, value: bool) -> Self {
        self.inner.per_stage_descriptor_set = value as u32;
        self
    }
    #[inline]
    pub fn dynamic_pipeline_layout(mut self, value: bool) -> Self {
        self.inner.dynamic_pipeline_layout = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDevicePerStageDescriptorSetFeaturesNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDevicePerStageDescriptorSetFeaturesNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDevicePerStageDescriptorSetFeaturesNVBuilder<'a> {
    type Target = PhysicalDevicePerStageDescriptorSetFeaturesNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDevicePerStageDescriptorSetFeaturesNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceExternalFormatResolveFeaturesANDROID`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceExternalFormatResolveFeaturesANDROIDBuilder<'a> {
    inner: PhysicalDeviceExternalFormatResolveFeaturesANDROID,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceExternalFormatResolveFeaturesANDROID {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceExternalFormatResolveFeaturesANDROIDBuilder<
        'a,
    > {
        PhysicalDeviceExternalFormatResolveFeaturesANDROIDBuilder {
            inner: PhysicalDeviceExternalFormatResolveFeaturesANDROID {
                s_type: StructureType::from_raw(1000468000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceExternalFormatResolveFeaturesANDROIDBuilder<'a> {
    #[inline]
    pub fn external_format_resolve(mut self, value: bool) -> Self {
        self.inner.external_format_resolve = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceExternalFormatResolveFeaturesANDROID`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceExternalFormatResolveFeaturesANDROID>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDeviceExternalFormatResolveFeaturesANDROIDBuilder<'a> {
    type Target = PhysicalDeviceExternalFormatResolveFeaturesANDROID;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceExternalFormatResolveFeaturesANDROIDBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceExternalFormatResolvePropertiesANDROID`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceExternalFormatResolvePropertiesANDROIDBuilder<'a> {
    inner: PhysicalDeviceExternalFormatResolvePropertiesANDROID,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceExternalFormatResolvePropertiesANDROID {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceExternalFormatResolvePropertiesANDROIDBuilder<
        'a,
    > {
        PhysicalDeviceExternalFormatResolvePropertiesANDROIDBuilder {
            inner: PhysicalDeviceExternalFormatResolvePropertiesANDROID {
                s_type: StructureType::from_raw(1000468001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceExternalFormatResolvePropertiesANDROIDBuilder<'a> {
    #[inline]
    pub fn null_color_attachment_with_external_format_resolve(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.null_color_attachment_with_external_format_resolve = value as u32;
        self
    }
    #[inline]
    pub fn external_format_resolve_chroma_offset_x(
        mut self,
        value: ChromaLocation,
    ) -> Self {
        self.inner.external_format_resolve_chroma_offset_x = value;
        self
    }
    #[inline]
    pub fn external_format_resolve_chroma_offset_y(
        mut self,
        value: ChromaLocation,
    ) -> Self {
        self.inner.external_format_resolve_chroma_offset_y = value;
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDeviceExternalFormatResolvePropertiesANDROIDBuilder<'a> {
    type Target = PhysicalDeviceExternalFormatResolvePropertiesANDROID;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceExternalFormatResolvePropertiesANDROIDBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`AndroidHardwareBufferFormatResolvePropertiesANDROID`] with lifetime-tied pNext safety.
pub struct AndroidHardwareBufferFormatResolvePropertiesANDROIDBuilder<'a> {
    inner: AndroidHardwareBufferFormatResolvePropertiesANDROID,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl AndroidHardwareBufferFormatResolvePropertiesANDROID {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> AndroidHardwareBufferFormatResolvePropertiesANDROIDBuilder<
        'a,
    > {
        AndroidHardwareBufferFormatResolvePropertiesANDROIDBuilder {
            inner: AndroidHardwareBufferFormatResolvePropertiesANDROID {
                s_type: StructureType::from_raw(1000468002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> AndroidHardwareBufferFormatResolvePropertiesANDROIDBuilder<'a> {
    #[inline]
    pub fn color_attachment_format(mut self, value: Format) -> Self {
        self.inner.color_attachment_format = value;
        self
    }
}
impl<'a> core::ops::Deref
for AndroidHardwareBufferFormatResolvePropertiesANDROIDBuilder<'a> {
    type Target = AndroidHardwareBufferFormatResolvePropertiesANDROID;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for AndroidHardwareBufferFormatResolvePropertiesANDROIDBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`LatencySleepModeInfoNV`] with lifetime-tied pNext safety.
pub struct LatencySleepModeInfoNVBuilder<'a> {
    inner: LatencySleepModeInfoNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl LatencySleepModeInfoNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> LatencySleepModeInfoNVBuilder<'a> {
        LatencySleepModeInfoNVBuilder {
            inner: LatencySleepModeInfoNV {
                s_type: StructureType::from_raw(1000505000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> LatencySleepModeInfoNVBuilder<'a> {
    #[inline]
    pub fn low_latency_mode(mut self, value: bool) -> Self {
        self.inner.low_latency_mode = value as u32;
        self
    }
    #[inline]
    pub fn low_latency_boost(mut self, value: bool) -> Self {
        self.inner.low_latency_boost = value as u32;
        self
    }
    #[inline]
    pub fn minimum_interval_us(mut self, value: u32) -> Self {
        self.inner.minimum_interval_us = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`LatencySleepModeInfoNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsLatencySleepModeInfoNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for LatencySleepModeInfoNVBuilder<'a> {
    type Target = LatencySleepModeInfoNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for LatencySleepModeInfoNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`LatencySleepInfoNV`] with lifetime-tied pNext safety.
pub struct LatencySleepInfoNVBuilder<'a> {
    inner: LatencySleepInfoNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl LatencySleepInfoNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> LatencySleepInfoNVBuilder<'a> {
        LatencySleepInfoNVBuilder {
            inner: LatencySleepInfoNV {
                s_type: StructureType::from_raw(1000505001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> LatencySleepInfoNVBuilder<'a> {
    #[inline]
    pub fn signal_semaphore(mut self, value: Semaphore) -> Self {
        self.inner.signal_semaphore = value;
        self
    }
    #[inline]
    pub fn value(mut self, value: u64) -> Self {
        self.inner.value = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`LatencySleepInfoNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsLatencySleepInfoNV>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for LatencySleepInfoNVBuilder<'a> {
    type Target = LatencySleepInfoNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for LatencySleepInfoNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`SetLatencyMarkerInfoNV`] with lifetime-tied pNext safety.
pub struct SetLatencyMarkerInfoNVBuilder<'a> {
    inner: SetLatencyMarkerInfoNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl SetLatencyMarkerInfoNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> SetLatencyMarkerInfoNVBuilder<'a> {
        SetLatencyMarkerInfoNVBuilder {
            inner: SetLatencyMarkerInfoNV {
                s_type: StructureType::from_raw(1000505002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> SetLatencyMarkerInfoNVBuilder<'a> {
    #[inline]
    pub fn present_id(mut self, value: u64) -> Self {
        self.inner.present_id = value;
        self
    }
    #[inline]
    pub fn marker(mut self, value: LatencyMarkerNV) -> Self {
        self.inner.marker = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`SetLatencyMarkerInfoNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsSetLatencyMarkerInfoNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for SetLatencyMarkerInfoNVBuilder<'a> {
    type Target = SetLatencyMarkerInfoNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for SetLatencyMarkerInfoNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`GetLatencyMarkerInfoNV`] with lifetime-tied pNext safety.
pub struct GetLatencyMarkerInfoNVBuilder<'a> {
    inner: GetLatencyMarkerInfoNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl GetLatencyMarkerInfoNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> GetLatencyMarkerInfoNVBuilder<'a> {
        GetLatencyMarkerInfoNVBuilder {
            inner: GetLatencyMarkerInfoNV {
                s_type: StructureType::from_raw(1000505003i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> GetLatencyMarkerInfoNVBuilder<'a> {
    #[inline]
    pub fn timing_count(mut self, value: u32) -> Self {
        self.inner.timing_count = value;
        self
    }
    #[inline]
    pub fn timings(mut self, slice: &'a mut [LatencyTimingsFrameReportNV]) -> Self {
        self.inner.timing_count = slice.len() as u32;
        self.inner.p_timings = slice.as_mut_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`GetLatencyMarkerInfoNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsGetLatencyMarkerInfoNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for GetLatencyMarkerInfoNVBuilder<'a> {
    type Target = GetLatencyMarkerInfoNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for GetLatencyMarkerInfoNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`LatencyTimingsFrameReportNV`] with lifetime-tied pNext safety.
pub struct LatencyTimingsFrameReportNVBuilder<'a> {
    inner: LatencyTimingsFrameReportNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl LatencyTimingsFrameReportNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> LatencyTimingsFrameReportNVBuilder<'a> {
        LatencyTimingsFrameReportNVBuilder {
            inner: LatencyTimingsFrameReportNV {
                s_type: StructureType::from_raw(1000505004i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> LatencyTimingsFrameReportNVBuilder<'a> {
    #[inline]
    pub fn present_id(mut self, value: u64) -> Self {
        self.inner.present_id = value;
        self
    }
    #[inline]
    pub fn input_sample_time_us(mut self, value: u64) -> Self {
        self.inner.input_sample_time_us = value;
        self
    }
    #[inline]
    pub fn sim_start_time_us(mut self, value: u64) -> Self {
        self.inner.sim_start_time_us = value;
        self
    }
    #[inline]
    pub fn sim_end_time_us(mut self, value: u64) -> Self {
        self.inner.sim_end_time_us = value;
        self
    }
    #[inline]
    pub fn render_submit_start_time_us(mut self, value: u64) -> Self {
        self.inner.render_submit_start_time_us = value;
        self
    }
    #[inline]
    pub fn render_submit_end_time_us(mut self, value: u64) -> Self {
        self.inner.render_submit_end_time_us = value;
        self
    }
    #[inline]
    pub fn present_start_time_us(mut self, value: u64) -> Self {
        self.inner.present_start_time_us = value;
        self
    }
    #[inline]
    pub fn present_end_time_us(mut self, value: u64) -> Self {
        self.inner.present_end_time_us = value;
        self
    }
    #[inline]
    pub fn driver_start_time_us(mut self, value: u64) -> Self {
        self.inner.driver_start_time_us = value;
        self
    }
    #[inline]
    pub fn driver_end_time_us(mut self, value: u64) -> Self {
        self.inner.driver_end_time_us = value;
        self
    }
    #[inline]
    pub fn os_render_queue_start_time_us(mut self, value: u64) -> Self {
        self.inner.os_render_queue_start_time_us = value;
        self
    }
    #[inline]
    pub fn os_render_queue_end_time_us(mut self, value: u64) -> Self {
        self.inner.os_render_queue_end_time_us = value;
        self
    }
    #[inline]
    pub fn gpu_render_start_time_us(mut self, value: u64) -> Self {
        self.inner.gpu_render_start_time_us = value;
        self
    }
    #[inline]
    pub fn gpu_render_end_time_us(mut self, value: u64) -> Self {
        self.inner.gpu_render_end_time_us = value;
        self
    }
}
impl<'a> core::ops::Deref for LatencyTimingsFrameReportNVBuilder<'a> {
    type Target = LatencyTimingsFrameReportNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for LatencyTimingsFrameReportNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`OutOfBandQueueTypeInfoNV`] with lifetime-tied pNext safety.
pub struct OutOfBandQueueTypeInfoNVBuilder<'a> {
    inner: OutOfBandQueueTypeInfoNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl OutOfBandQueueTypeInfoNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> OutOfBandQueueTypeInfoNVBuilder<'a> {
        OutOfBandQueueTypeInfoNVBuilder {
            inner: OutOfBandQueueTypeInfoNV {
                s_type: StructureType::from_raw(1000505006i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> OutOfBandQueueTypeInfoNVBuilder<'a> {
    #[inline]
    pub fn queue_type(mut self, value: OutOfBandQueueTypeNV) -> Self {
        self.inner.queue_type = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`OutOfBandQueueTypeInfoNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsOutOfBandQueueTypeInfoNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for OutOfBandQueueTypeInfoNVBuilder<'a> {
    type Target = OutOfBandQueueTypeInfoNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for OutOfBandQueueTypeInfoNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`LatencySubmissionPresentIdNV`] with lifetime-tied pNext safety.
pub struct LatencySubmissionPresentIdNVBuilder<'a> {
    inner: LatencySubmissionPresentIdNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl LatencySubmissionPresentIdNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> LatencySubmissionPresentIdNVBuilder<'a> {
        LatencySubmissionPresentIdNVBuilder {
            inner: LatencySubmissionPresentIdNV {
                s_type: StructureType::from_raw(1000505005i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> LatencySubmissionPresentIdNVBuilder<'a> {
    #[inline]
    pub fn present_id(mut self, value: u64) -> Self {
        self.inner.present_id = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`LatencySubmissionPresentIdNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsLatencySubmissionPresentIdNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for LatencySubmissionPresentIdNVBuilder<'a> {
    type Target = LatencySubmissionPresentIdNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for LatencySubmissionPresentIdNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`SwapchainLatencyCreateInfoNV`] with lifetime-tied pNext safety.
pub struct SwapchainLatencyCreateInfoNVBuilder<'a> {
    inner: SwapchainLatencyCreateInfoNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl SwapchainLatencyCreateInfoNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> SwapchainLatencyCreateInfoNVBuilder<'a> {
        SwapchainLatencyCreateInfoNVBuilder {
            inner: SwapchainLatencyCreateInfoNV {
                s_type: StructureType::from_raw(1000505007i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> SwapchainLatencyCreateInfoNVBuilder<'a> {
    #[inline]
    pub fn latency_mode_enable(mut self, value: bool) -> Self {
        self.inner.latency_mode_enable = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`SwapchainLatencyCreateInfoNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsSwapchainLatencyCreateInfoNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for SwapchainLatencyCreateInfoNVBuilder<'a> {
    type Target = SwapchainLatencyCreateInfoNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for SwapchainLatencyCreateInfoNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`LatencySurfaceCapabilitiesNV`] with lifetime-tied pNext safety.
pub struct LatencySurfaceCapabilitiesNVBuilder<'a> {
    inner: LatencySurfaceCapabilitiesNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl LatencySurfaceCapabilitiesNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> LatencySurfaceCapabilitiesNVBuilder<'a> {
        LatencySurfaceCapabilitiesNVBuilder {
            inner: LatencySurfaceCapabilitiesNV {
                s_type: StructureType::from_raw(1000505008i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> LatencySurfaceCapabilitiesNVBuilder<'a> {
    #[inline]
    pub fn present_mode_count(mut self, value: u32) -> Self {
        self.inner.present_mode_count = value;
        self
    }
    #[inline]
    pub fn present_modes(mut self, slice: &'a mut [PresentModeKHR]) -> Self {
        self.inner.present_mode_count = slice.len() as u32;
        self.inner.p_present_modes = slice.as_mut_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`LatencySurfaceCapabilitiesNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsLatencySurfaceCapabilitiesNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for LatencySurfaceCapabilitiesNVBuilder<'a> {
    type Target = LatencySurfaceCapabilitiesNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for LatencySurfaceCapabilitiesNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceCudaKernelLaunchFeaturesNV`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceCudaKernelLaunchFeaturesNVBuilder<'a> {
    inner: PhysicalDeviceCudaKernelLaunchFeaturesNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceCudaKernelLaunchFeaturesNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceCudaKernelLaunchFeaturesNVBuilder<'a> {
        PhysicalDeviceCudaKernelLaunchFeaturesNVBuilder {
            inner: PhysicalDeviceCudaKernelLaunchFeaturesNV {
                s_type: StructureType::from_raw(1000307003i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceCudaKernelLaunchFeaturesNVBuilder<'a> {
    #[inline]
    pub fn cuda_kernel_launch_features(mut self, value: bool) -> Self {
        self.inner.cuda_kernel_launch_features = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceCudaKernelLaunchFeaturesNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceCudaKernelLaunchFeaturesNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceCudaKernelLaunchFeaturesNVBuilder<'a> {
    type Target = PhysicalDeviceCudaKernelLaunchFeaturesNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceCudaKernelLaunchFeaturesNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceCudaKernelLaunchPropertiesNV`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceCudaKernelLaunchPropertiesNVBuilder<'a> {
    inner: PhysicalDeviceCudaKernelLaunchPropertiesNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceCudaKernelLaunchPropertiesNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceCudaKernelLaunchPropertiesNVBuilder<'a> {
        PhysicalDeviceCudaKernelLaunchPropertiesNVBuilder {
            inner: PhysicalDeviceCudaKernelLaunchPropertiesNV {
                s_type: StructureType::from_raw(1000307004i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceCudaKernelLaunchPropertiesNVBuilder<'a> {
    #[inline]
    pub fn compute_capability_minor(mut self, value: u32) -> Self {
        self.inner.compute_capability_minor = value;
        self
    }
    #[inline]
    pub fn compute_capability_major(mut self, value: u32) -> Self {
        self.inner.compute_capability_major = value;
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceCudaKernelLaunchPropertiesNVBuilder<'a> {
    type Target = PhysicalDeviceCudaKernelLaunchPropertiesNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceCudaKernelLaunchPropertiesNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DeviceQueueShaderCoreControlCreateInfoARM`] with lifetime-tied pNext safety.
pub struct DeviceQueueShaderCoreControlCreateInfoARMBuilder<'a> {
    inner: DeviceQueueShaderCoreControlCreateInfoARM,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DeviceQueueShaderCoreControlCreateInfoARM {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> DeviceQueueShaderCoreControlCreateInfoARMBuilder<'a> {
        DeviceQueueShaderCoreControlCreateInfoARMBuilder {
            inner: DeviceQueueShaderCoreControlCreateInfoARM {
                s_type: StructureType::from_raw(1000417000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DeviceQueueShaderCoreControlCreateInfoARMBuilder<'a> {
    #[inline]
    pub fn shader_core_count(mut self, value: u32) -> Self {
        self.inner.shader_core_count = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`DeviceQueueShaderCoreControlCreateInfoARM`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsDeviceQueueShaderCoreControlCreateInfoARM>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for DeviceQueueShaderCoreControlCreateInfoARMBuilder<'a> {
    type Target = DeviceQueueShaderCoreControlCreateInfoARM;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for DeviceQueueShaderCoreControlCreateInfoARMBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceSchedulingControlsFeaturesARM`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceSchedulingControlsFeaturesARMBuilder<'a> {
    inner: PhysicalDeviceSchedulingControlsFeaturesARM,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceSchedulingControlsFeaturesARM {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceSchedulingControlsFeaturesARMBuilder<'a> {
        PhysicalDeviceSchedulingControlsFeaturesARMBuilder {
            inner: PhysicalDeviceSchedulingControlsFeaturesARM {
                s_type: StructureType::from_raw(1000417001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceSchedulingControlsFeaturesARMBuilder<'a> {
    #[inline]
    pub fn scheduling_controls(mut self, value: bool) -> Self {
        self.inner.scheduling_controls = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceSchedulingControlsFeaturesARM`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceSchedulingControlsFeaturesARM>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceSchedulingControlsFeaturesARMBuilder<'a> {
    type Target = PhysicalDeviceSchedulingControlsFeaturesARM;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceSchedulingControlsFeaturesARMBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceSchedulingControlsPropertiesARM`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceSchedulingControlsPropertiesARMBuilder<'a> {
    inner: PhysicalDeviceSchedulingControlsPropertiesARM,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceSchedulingControlsPropertiesARM {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceSchedulingControlsPropertiesARMBuilder<'a> {
        PhysicalDeviceSchedulingControlsPropertiesARMBuilder {
            inner: PhysicalDeviceSchedulingControlsPropertiesARM {
                s_type: StructureType::from_raw(1000417002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceSchedulingControlsPropertiesARMBuilder<'a> {
    #[inline]
    pub fn scheduling_controls_flags(
        mut self,
        value: PhysicalDeviceSchedulingControlsFlagsARM,
    ) -> Self {
        self.inner.scheduling_controls_flags = value;
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceSchedulingControlsPropertiesARMBuilder<'a> {
    type Target = PhysicalDeviceSchedulingControlsPropertiesARM;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceSchedulingControlsPropertiesARMBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceRelaxedLineRasterizationFeaturesIMG`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceRelaxedLineRasterizationFeaturesIMGBuilder<'a> {
    inner: PhysicalDeviceRelaxedLineRasterizationFeaturesIMG,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceRelaxedLineRasterizationFeaturesIMG {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceRelaxedLineRasterizationFeaturesIMGBuilder<
        'a,
    > {
        PhysicalDeviceRelaxedLineRasterizationFeaturesIMGBuilder {
            inner: PhysicalDeviceRelaxedLineRasterizationFeaturesIMG {
                s_type: StructureType::from_raw(1000110000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceRelaxedLineRasterizationFeaturesIMGBuilder<'a> {
    #[inline]
    pub fn relaxed_line_rasterization(mut self, value: bool) -> Self {
        self.inner.relaxed_line_rasterization = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceRelaxedLineRasterizationFeaturesIMG`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceRelaxedLineRasterizationFeaturesIMG>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDeviceRelaxedLineRasterizationFeaturesIMGBuilder<'a> {
    type Target = PhysicalDeviceRelaxedLineRasterizationFeaturesIMG;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceRelaxedLineRasterizationFeaturesIMGBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceRenderPassStripedFeaturesARM`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceRenderPassStripedFeaturesARMBuilder<'a> {
    inner: PhysicalDeviceRenderPassStripedFeaturesARM,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceRenderPassStripedFeaturesARM {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceRenderPassStripedFeaturesARMBuilder<'a> {
        PhysicalDeviceRenderPassStripedFeaturesARMBuilder {
            inner: PhysicalDeviceRenderPassStripedFeaturesARM {
                s_type: StructureType::from_raw(1000424000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceRenderPassStripedFeaturesARMBuilder<'a> {
    #[inline]
    pub fn render_pass_striped(mut self, value: bool) -> Self {
        self.inner.render_pass_striped = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceRenderPassStripedFeaturesARM`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceRenderPassStripedFeaturesARM>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceRenderPassStripedFeaturesARMBuilder<'a> {
    type Target = PhysicalDeviceRenderPassStripedFeaturesARM;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceRenderPassStripedFeaturesARMBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceRenderPassStripedPropertiesARM`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceRenderPassStripedPropertiesARMBuilder<'a> {
    inner: PhysicalDeviceRenderPassStripedPropertiesARM,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceRenderPassStripedPropertiesARM {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceRenderPassStripedPropertiesARMBuilder<'a> {
        PhysicalDeviceRenderPassStripedPropertiesARMBuilder {
            inner: PhysicalDeviceRenderPassStripedPropertiesARM {
                s_type: StructureType::from_raw(1000424001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceRenderPassStripedPropertiesARMBuilder<'a> {
    #[inline]
    pub fn render_pass_stripe_granularity(mut self, value: Extent2D) -> Self {
        self.inner.render_pass_stripe_granularity = value;
        self
    }
    #[inline]
    pub fn max_render_pass_stripes(mut self, value: u32) -> Self {
        self.inner.max_render_pass_stripes = value;
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceRenderPassStripedPropertiesARMBuilder<'a> {
    type Target = PhysicalDeviceRenderPassStripedPropertiesARM;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceRenderPassStripedPropertiesARMBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`RenderPassStripeInfoARM`] with lifetime-tied pNext safety.
pub struct RenderPassStripeInfoARMBuilder<'a> {
    inner: RenderPassStripeInfoARM,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl RenderPassStripeInfoARM {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> RenderPassStripeInfoARMBuilder<'a> {
        RenderPassStripeInfoARMBuilder {
            inner: RenderPassStripeInfoARM {
                s_type: StructureType::from_raw(1000424003i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> RenderPassStripeInfoARMBuilder<'a> {
    #[inline]
    pub fn stripe_area(mut self, value: Rect2D) -> Self {
        self.inner.stripe_area = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`RenderPassStripeInfoARM`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsRenderPassStripeInfoARM>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for RenderPassStripeInfoARMBuilder<'a> {
    type Target = RenderPassStripeInfoARM;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for RenderPassStripeInfoARMBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`RenderPassStripeBeginInfoARM`] with lifetime-tied pNext safety.
pub struct RenderPassStripeBeginInfoARMBuilder<'a> {
    inner: RenderPassStripeBeginInfoARM,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl RenderPassStripeBeginInfoARM {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> RenderPassStripeBeginInfoARMBuilder<'a> {
        RenderPassStripeBeginInfoARMBuilder {
            inner: RenderPassStripeBeginInfoARM {
                s_type: StructureType::from_raw(1000424002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> RenderPassStripeBeginInfoARMBuilder<'a> {
    #[inline]
    pub fn stripe_infos(mut self, slice: &'a [RenderPassStripeInfoARM]) -> Self {
        self.inner.stripe_info_count = slice.len() as u32;
        self.inner.p_stripe_infos = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`RenderPassStripeBeginInfoARM`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsRenderPassStripeBeginInfoARM>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for RenderPassStripeBeginInfoARMBuilder<'a> {
    type Target = RenderPassStripeBeginInfoARM;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for RenderPassStripeBeginInfoARMBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`RenderPassStripeSubmitInfoARM`] with lifetime-tied pNext safety.
pub struct RenderPassStripeSubmitInfoARMBuilder<'a> {
    inner: RenderPassStripeSubmitInfoARM,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl RenderPassStripeSubmitInfoARM {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> RenderPassStripeSubmitInfoARMBuilder<'a> {
        RenderPassStripeSubmitInfoARMBuilder {
            inner: RenderPassStripeSubmitInfoARM {
                s_type: StructureType::from_raw(1000424004i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> RenderPassStripeSubmitInfoARMBuilder<'a> {
    #[inline]
    pub fn stripe_semaphore_infos(mut self, slice: &'a [SemaphoreSubmitInfo]) -> Self {
        self.inner.stripe_semaphore_info_count = slice.len() as u32;
        self.inner.p_stripe_semaphore_infos = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`RenderPassStripeSubmitInfoARM`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsRenderPassStripeSubmitInfoARM>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for RenderPassStripeSubmitInfoARMBuilder<'a> {
    type Target = RenderPassStripeSubmitInfoARM;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for RenderPassStripeSubmitInfoARMBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDevicePipelineOpacityMicromapFeaturesARM`] with lifetime-tied pNext safety.
pub struct PhysicalDevicePipelineOpacityMicromapFeaturesARMBuilder<'a> {
    inner: PhysicalDevicePipelineOpacityMicromapFeaturesARM,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDevicePipelineOpacityMicromapFeaturesARM {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDevicePipelineOpacityMicromapFeaturesARMBuilder<'a> {
        PhysicalDevicePipelineOpacityMicromapFeaturesARMBuilder {
            inner: PhysicalDevicePipelineOpacityMicromapFeaturesARM {
                s_type: StructureType::from_raw(1000596000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDevicePipelineOpacityMicromapFeaturesARMBuilder<'a> {
    #[inline]
    pub fn pipeline_opacity_micromap(mut self, value: bool) -> Self {
        self.inner.pipeline_opacity_micromap = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDevicePipelineOpacityMicromapFeaturesARM`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDevicePipelineOpacityMicromapFeaturesARM>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDevicePipelineOpacityMicromapFeaturesARMBuilder<'a> {
    type Target = PhysicalDevicePipelineOpacityMicromapFeaturesARM;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDevicePipelineOpacityMicromapFeaturesARMBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceShaderMaximalReconvergenceFeaturesKHRBuilder<'a> {
    inner: PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceShaderMaximalReconvergenceFeaturesKHRBuilder<
        'a,
    > {
        PhysicalDeviceShaderMaximalReconvergenceFeaturesKHRBuilder {
            inner: PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR {
                s_type: StructureType::from_raw(1000434000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceShaderMaximalReconvergenceFeaturesKHRBuilder<'a> {
    #[inline]
    pub fn shader_maximal_reconvergence(mut self, value: bool) -> Self {
        self.inner.shader_maximal_reconvergence = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDeviceShaderMaximalReconvergenceFeaturesKHRBuilder<'a> {
    type Target = PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceShaderMaximalReconvergenceFeaturesKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceShaderSubgroupRotateFeatures`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceShaderSubgroupRotateFeaturesBuilder<'a> {
    inner: PhysicalDeviceShaderSubgroupRotateFeatures,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceShaderSubgroupRotateFeatures {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceShaderSubgroupRotateFeaturesBuilder<'a> {
        PhysicalDeviceShaderSubgroupRotateFeaturesBuilder {
            inner: PhysicalDeviceShaderSubgroupRotateFeatures {
                s_type: StructureType::from_raw(1000416000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceShaderSubgroupRotateFeaturesBuilder<'a> {
    #[inline]
    pub fn shader_subgroup_rotate(mut self, value: bool) -> Self {
        self.inner.shader_subgroup_rotate = value as u32;
        self
    }
    #[inline]
    pub fn shader_subgroup_rotate_clustered(mut self, value: bool) -> Self {
        self.inner.shader_subgroup_rotate_clustered = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceShaderSubgroupRotateFeatures`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceShaderSubgroupRotateFeatures>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceShaderSubgroupRotateFeaturesBuilder<'a> {
    type Target = PhysicalDeviceShaderSubgroupRotateFeatures;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceShaderSubgroupRotateFeaturesBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceShaderExpectAssumeFeatures`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceShaderExpectAssumeFeaturesBuilder<'a> {
    inner: PhysicalDeviceShaderExpectAssumeFeatures,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceShaderExpectAssumeFeatures {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceShaderExpectAssumeFeaturesBuilder<'a> {
        PhysicalDeviceShaderExpectAssumeFeaturesBuilder {
            inner: PhysicalDeviceShaderExpectAssumeFeatures {
                s_type: StructureType::from_raw(1000544000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceShaderExpectAssumeFeaturesBuilder<'a> {
    #[inline]
    pub fn shader_expect_assume(mut self, value: bool) -> Self {
        self.inner.shader_expect_assume = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceShaderExpectAssumeFeatures`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceShaderExpectAssumeFeatures>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceShaderExpectAssumeFeaturesBuilder<'a> {
    type Target = PhysicalDeviceShaderExpectAssumeFeatures;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceShaderExpectAssumeFeaturesBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceShaderFloatControls2Features`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceShaderFloatControls2FeaturesBuilder<'a> {
    inner: PhysicalDeviceShaderFloatControls2Features,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceShaderFloatControls2Features {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceShaderFloatControls2FeaturesBuilder<'a> {
        PhysicalDeviceShaderFloatControls2FeaturesBuilder {
            inner: PhysicalDeviceShaderFloatControls2Features {
                s_type: StructureType::from_raw(1000528000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceShaderFloatControls2FeaturesBuilder<'a> {
    #[inline]
    pub fn shader_float_controls2(mut self, value: bool) -> Self {
        self.inner.shader_float_controls2 = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceShaderFloatControls2Features`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceShaderFloatControls2Features>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceShaderFloatControls2FeaturesBuilder<'a> {
    type Target = PhysicalDeviceShaderFloatControls2Features;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceShaderFloatControls2FeaturesBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceDynamicRenderingLocalReadFeatures`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceDynamicRenderingLocalReadFeaturesBuilder<'a> {
    inner: PhysicalDeviceDynamicRenderingLocalReadFeatures,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceDynamicRenderingLocalReadFeatures {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceDynamicRenderingLocalReadFeaturesBuilder<'a> {
        PhysicalDeviceDynamicRenderingLocalReadFeaturesBuilder {
            inner: PhysicalDeviceDynamicRenderingLocalReadFeatures {
                s_type: StructureType::from_raw(1000232000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceDynamicRenderingLocalReadFeaturesBuilder<'a> {
    #[inline]
    pub fn dynamic_rendering_local_read(mut self, value: bool) -> Self {
        self.inner.dynamic_rendering_local_read = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceDynamicRenderingLocalReadFeatures`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceDynamicRenderingLocalReadFeatures>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDeviceDynamicRenderingLocalReadFeaturesBuilder<'a> {
    type Target = PhysicalDeviceDynamicRenderingLocalReadFeatures;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceDynamicRenderingLocalReadFeaturesBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`RenderingAttachmentLocationInfo`] with lifetime-tied pNext safety.
pub struct RenderingAttachmentLocationInfoBuilder<'a> {
    inner: RenderingAttachmentLocationInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl RenderingAttachmentLocationInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> RenderingAttachmentLocationInfoBuilder<'a> {
        RenderingAttachmentLocationInfoBuilder {
            inner: RenderingAttachmentLocationInfo {
                s_type: StructureType::from_raw(1000232001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> RenderingAttachmentLocationInfoBuilder<'a> {
    #[inline]
    pub fn color_attachment_locations(mut self, slice: &'a [u32]) -> Self {
        self.inner.color_attachment_count = slice.len() as u32;
        self.inner.p_color_attachment_locations = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`RenderingAttachmentLocationInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsRenderingAttachmentLocationInfo>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for RenderingAttachmentLocationInfoBuilder<'a> {
    type Target = RenderingAttachmentLocationInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for RenderingAttachmentLocationInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`RenderingInputAttachmentIndexInfo`] with lifetime-tied pNext safety.
pub struct RenderingInputAttachmentIndexInfoBuilder<'a> {
    inner: RenderingInputAttachmentIndexInfo,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl RenderingInputAttachmentIndexInfo {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> RenderingInputAttachmentIndexInfoBuilder<'a> {
        RenderingInputAttachmentIndexInfoBuilder {
            inner: RenderingInputAttachmentIndexInfo {
                s_type: StructureType::from_raw(1000232002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> RenderingInputAttachmentIndexInfoBuilder<'a> {
    #[inline]
    pub fn color_attachment_count(mut self, value: u32) -> Self {
        self.inner.color_attachment_count = value;
        self
    }
    #[inline]
    pub fn color_attachment_input_indices(mut self, slice: &'a [u32]) -> Self {
        self.inner.color_attachment_count = slice.len() as u32;
        self.inner.p_color_attachment_input_indices = slice.as_ptr();
        self
    }
    #[inline]
    pub fn depth_input_attachment_index(mut self, value: *const u32) -> Self {
        self.inner.p_depth_input_attachment_index = value;
        self
    }
    #[inline]
    pub fn stencil_input_attachment_index(mut self, value: *const u32) -> Self {
        self.inner.p_stencil_input_attachment_index = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`RenderingInputAttachmentIndexInfo`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsRenderingInputAttachmentIndexInfo>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for RenderingInputAttachmentIndexInfoBuilder<'a> {
    type Target = RenderingInputAttachmentIndexInfo;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for RenderingInputAttachmentIndexInfoBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceShaderQuadControlFeaturesKHR`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceShaderQuadControlFeaturesKHRBuilder<'a> {
    inner: PhysicalDeviceShaderQuadControlFeaturesKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceShaderQuadControlFeaturesKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceShaderQuadControlFeaturesKHRBuilder<'a> {
        PhysicalDeviceShaderQuadControlFeaturesKHRBuilder {
            inner: PhysicalDeviceShaderQuadControlFeaturesKHR {
                s_type: StructureType::from_raw(1000235000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceShaderQuadControlFeaturesKHRBuilder<'a> {
    #[inline]
    pub fn shader_quad_control(mut self, value: bool) -> Self {
        self.inner.shader_quad_control = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceShaderQuadControlFeaturesKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceShaderQuadControlFeaturesKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceShaderQuadControlFeaturesKHRBuilder<'a> {
    type Target = PhysicalDeviceShaderQuadControlFeaturesKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceShaderQuadControlFeaturesKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceShaderAtomicFloat16VectorFeaturesNVBuilder<'a> {
    inner: PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceShaderAtomicFloat16VectorFeaturesNVBuilder<
        'a,
    > {
        PhysicalDeviceShaderAtomicFloat16VectorFeaturesNVBuilder {
            inner: PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV {
                s_type: StructureType::from_raw(1000563000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceShaderAtomicFloat16VectorFeaturesNVBuilder<'a> {
    #[inline]
    pub fn shader_float16_vector_atomics(mut self, value: bool) -> Self {
        self.inner.shader_float16_vector_atomics = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDeviceShaderAtomicFloat16VectorFeaturesNVBuilder<'a> {
    type Target = PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceShaderAtomicFloat16VectorFeaturesNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceMapMemoryPlacedFeaturesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceMapMemoryPlacedFeaturesEXTBuilder<'a> {
    inner: PhysicalDeviceMapMemoryPlacedFeaturesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceMapMemoryPlacedFeaturesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceMapMemoryPlacedFeaturesEXTBuilder<'a> {
        PhysicalDeviceMapMemoryPlacedFeaturesEXTBuilder {
            inner: PhysicalDeviceMapMemoryPlacedFeaturesEXT {
                s_type: StructureType::from_raw(1000272000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceMapMemoryPlacedFeaturesEXTBuilder<'a> {
    #[inline]
    pub fn memory_map_placed(mut self, value: bool) -> Self {
        self.inner.memory_map_placed = value as u32;
        self
    }
    #[inline]
    pub fn memory_map_range_placed(mut self, value: bool) -> Self {
        self.inner.memory_map_range_placed = value as u32;
        self
    }
    #[inline]
    pub fn memory_unmap_reserve(mut self, value: bool) -> Self {
        self.inner.memory_unmap_reserve = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceMapMemoryPlacedFeaturesEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceMapMemoryPlacedFeaturesEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceMapMemoryPlacedFeaturesEXTBuilder<'a> {
    type Target = PhysicalDeviceMapMemoryPlacedFeaturesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceMapMemoryPlacedFeaturesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceMapMemoryPlacedPropertiesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceMapMemoryPlacedPropertiesEXTBuilder<'a> {
    inner: PhysicalDeviceMapMemoryPlacedPropertiesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceMapMemoryPlacedPropertiesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceMapMemoryPlacedPropertiesEXTBuilder<'a> {
        PhysicalDeviceMapMemoryPlacedPropertiesEXTBuilder {
            inner: PhysicalDeviceMapMemoryPlacedPropertiesEXT {
                s_type: StructureType::from_raw(1000272001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceMapMemoryPlacedPropertiesEXTBuilder<'a> {
    #[inline]
    pub fn min_placed_memory_map_alignment(mut self, value: u64) -> Self {
        self.inner.min_placed_memory_map_alignment = value;
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceMapMemoryPlacedPropertiesEXTBuilder<'a> {
    type Target = PhysicalDeviceMapMemoryPlacedPropertiesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceMapMemoryPlacedPropertiesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`MemoryMapPlacedInfoEXT`] with lifetime-tied pNext safety.
pub struct MemoryMapPlacedInfoEXTBuilder<'a> {
    inner: MemoryMapPlacedInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl MemoryMapPlacedInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> MemoryMapPlacedInfoEXTBuilder<'a> {
        MemoryMapPlacedInfoEXTBuilder {
            inner: MemoryMapPlacedInfoEXT {
                s_type: StructureType::from_raw(1000272002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> MemoryMapPlacedInfoEXTBuilder<'a> {
    #[inline]
    pub fn placed_address(mut self, value: *mut core::ffi::c_void) -> Self {
        self.inner.p_placed_address = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`MemoryMapPlacedInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsMemoryMapPlacedInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for MemoryMapPlacedInfoEXTBuilder<'a> {
    type Target = MemoryMapPlacedInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for MemoryMapPlacedInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceShaderBfloat16FeaturesKHR`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceShaderBfloat16FeaturesKHRBuilder<'a> {
    inner: PhysicalDeviceShaderBfloat16FeaturesKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceShaderBfloat16FeaturesKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceShaderBfloat16FeaturesKHRBuilder<'a> {
        PhysicalDeviceShaderBfloat16FeaturesKHRBuilder {
            inner: PhysicalDeviceShaderBfloat16FeaturesKHR {
                s_type: StructureType::from_raw(1000141000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceShaderBfloat16FeaturesKHRBuilder<'a> {
    #[inline]
    pub fn shader_b_float16_type(mut self, value: bool) -> Self {
        self.inner.shader_b_float16_type = value as u32;
        self
    }
    #[inline]
    pub fn shader_b_float16_dot_product(mut self, value: bool) -> Self {
        self.inner.shader_b_float16_dot_product = value as u32;
        self
    }
    #[inline]
    pub fn shader_b_float16_cooperative_matrix(mut self, value: bool) -> Self {
        self.inner.shader_b_float16_cooperative_matrix = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceShaderBfloat16FeaturesKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceShaderBfloat16FeaturesKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceShaderBfloat16FeaturesKHRBuilder<'a> {
    type Target = PhysicalDeviceShaderBfloat16FeaturesKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceShaderBfloat16FeaturesKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceRawAccessChainsFeaturesNV`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceRawAccessChainsFeaturesNVBuilder<'a> {
    inner: PhysicalDeviceRawAccessChainsFeaturesNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceRawAccessChainsFeaturesNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceRawAccessChainsFeaturesNVBuilder<'a> {
        PhysicalDeviceRawAccessChainsFeaturesNVBuilder {
            inner: PhysicalDeviceRawAccessChainsFeaturesNV {
                s_type: StructureType::from_raw(1000555000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceRawAccessChainsFeaturesNVBuilder<'a> {
    #[inline]
    pub fn shader_raw_access_chains(mut self, value: bool) -> Self {
        self.inner.shader_raw_access_chains = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceRawAccessChainsFeaturesNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceRawAccessChainsFeaturesNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceRawAccessChainsFeaturesNVBuilder<'a> {
    type Target = PhysicalDeviceRawAccessChainsFeaturesNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceRawAccessChainsFeaturesNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceCommandBufferInheritanceFeaturesNV`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceCommandBufferInheritanceFeaturesNVBuilder<'a> {
    inner: PhysicalDeviceCommandBufferInheritanceFeaturesNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceCommandBufferInheritanceFeaturesNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceCommandBufferInheritanceFeaturesNVBuilder<'a> {
        PhysicalDeviceCommandBufferInheritanceFeaturesNVBuilder {
            inner: PhysicalDeviceCommandBufferInheritanceFeaturesNV {
                s_type: StructureType::from_raw(1000559000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceCommandBufferInheritanceFeaturesNVBuilder<'a> {
    #[inline]
    pub fn command_buffer_inheritance(mut self, value: bool) -> Self {
        self.inner.command_buffer_inheritance = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceCommandBufferInheritanceFeaturesNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceCommandBufferInheritanceFeaturesNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDeviceCommandBufferInheritanceFeaturesNVBuilder<'a> {
    type Target = PhysicalDeviceCommandBufferInheritanceFeaturesNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceCommandBufferInheritanceFeaturesNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceImageAlignmentControlFeaturesMESA`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceImageAlignmentControlFeaturesMESABuilder<'a> {
    inner: PhysicalDeviceImageAlignmentControlFeaturesMESA,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceImageAlignmentControlFeaturesMESA {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceImageAlignmentControlFeaturesMESABuilder<'a> {
        PhysicalDeviceImageAlignmentControlFeaturesMESABuilder {
            inner: PhysicalDeviceImageAlignmentControlFeaturesMESA {
                s_type: StructureType::from_raw(1000575000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceImageAlignmentControlFeaturesMESABuilder<'a> {
    #[inline]
    pub fn image_alignment_control(mut self, value: bool) -> Self {
        self.inner.image_alignment_control = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceImageAlignmentControlFeaturesMESA`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceImageAlignmentControlFeaturesMESA>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDeviceImageAlignmentControlFeaturesMESABuilder<'a> {
    type Target = PhysicalDeviceImageAlignmentControlFeaturesMESA;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceImageAlignmentControlFeaturesMESABuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceImageAlignmentControlPropertiesMESA`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceImageAlignmentControlPropertiesMESABuilder<'a> {
    inner: PhysicalDeviceImageAlignmentControlPropertiesMESA,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceImageAlignmentControlPropertiesMESA {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceImageAlignmentControlPropertiesMESABuilder<
        'a,
    > {
        PhysicalDeviceImageAlignmentControlPropertiesMESABuilder {
            inner: PhysicalDeviceImageAlignmentControlPropertiesMESA {
                s_type: StructureType::from_raw(1000575001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceImageAlignmentControlPropertiesMESABuilder<'a> {
    #[inline]
    pub fn supported_image_alignment_mask(mut self, value: u32) -> Self {
        self.inner.supported_image_alignment_mask = value;
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDeviceImageAlignmentControlPropertiesMESABuilder<'a> {
    type Target = PhysicalDeviceImageAlignmentControlPropertiesMESA;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceImageAlignmentControlPropertiesMESABuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ImageAlignmentControlCreateInfoMESA`] with lifetime-tied pNext safety.
pub struct ImageAlignmentControlCreateInfoMESABuilder<'a> {
    inner: ImageAlignmentControlCreateInfoMESA,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ImageAlignmentControlCreateInfoMESA {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ImageAlignmentControlCreateInfoMESABuilder<'a> {
        ImageAlignmentControlCreateInfoMESABuilder {
            inner: ImageAlignmentControlCreateInfoMESA {
                s_type: StructureType::from_raw(1000575002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ImageAlignmentControlCreateInfoMESABuilder<'a> {
    #[inline]
    pub fn maximum_requested_alignment(mut self, value: u32) -> Self {
        self.inner.maximum_requested_alignment = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`ImageAlignmentControlCreateInfoMESA`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsImageAlignmentControlCreateInfoMESA>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for ImageAlignmentControlCreateInfoMESABuilder<'a> {
    type Target = ImageAlignmentControlCreateInfoMESA;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ImageAlignmentControlCreateInfoMESABuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceShaderReplicatedCompositesFeaturesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceShaderReplicatedCompositesFeaturesEXTBuilder<'a> {
    inner: PhysicalDeviceShaderReplicatedCompositesFeaturesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceShaderReplicatedCompositesFeaturesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceShaderReplicatedCompositesFeaturesEXTBuilder<
        'a,
    > {
        PhysicalDeviceShaderReplicatedCompositesFeaturesEXTBuilder {
            inner: PhysicalDeviceShaderReplicatedCompositesFeaturesEXT {
                s_type: StructureType::from_raw(1000564000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceShaderReplicatedCompositesFeaturesEXTBuilder<'a> {
    #[inline]
    pub fn shader_replicated_composites(mut self, value: bool) -> Self {
        self.inner.shader_replicated_composites = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceShaderReplicatedCompositesFeaturesEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceShaderReplicatedCompositesFeaturesEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDeviceShaderReplicatedCompositesFeaturesEXTBuilder<'a> {
    type Target = PhysicalDeviceShaderReplicatedCompositesFeaturesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceShaderReplicatedCompositesFeaturesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDevicePresentModeFifoLatestReadyFeaturesKHR`] with lifetime-tied pNext safety.
pub struct PhysicalDevicePresentModeFifoLatestReadyFeaturesKHRBuilder<'a> {
    inner: PhysicalDevicePresentModeFifoLatestReadyFeaturesKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDevicePresentModeFifoLatestReadyFeaturesKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDevicePresentModeFifoLatestReadyFeaturesKHRBuilder<
        'a,
    > {
        PhysicalDevicePresentModeFifoLatestReadyFeaturesKHRBuilder {
            inner: PhysicalDevicePresentModeFifoLatestReadyFeaturesKHR {
                s_type: StructureType::from_raw(1000361000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDevicePresentModeFifoLatestReadyFeaturesKHRBuilder<'a> {
    #[inline]
    pub fn present_mode_fifo_latest_ready(mut self, value: bool) -> Self {
        self.inner.present_mode_fifo_latest_ready = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDevicePresentModeFifoLatestReadyFeaturesKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDevicePresentModeFifoLatestReadyFeaturesKHRBuilder<'a> {
    type Target = PhysicalDevicePresentModeFifoLatestReadyFeaturesKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDevicePresentModeFifoLatestReadyFeaturesKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DepthClampRangeEXT`].
pub struct DepthClampRangeEXTBuilder {
    inner: DepthClampRangeEXT,
}
impl DepthClampRangeEXT {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> DepthClampRangeEXTBuilder {
        DepthClampRangeEXTBuilder {
            inner: DepthClampRangeEXT {
                ..Default::default()
            },
        }
    }
}
impl DepthClampRangeEXTBuilder {
    #[inline]
    pub fn min_depth_clamp(mut self, value: f32) -> Self {
        self.inner.min_depth_clamp = value;
        self
    }
    #[inline]
    pub fn max_depth_clamp(mut self, value: f32) -> Self {
        self.inner.max_depth_clamp = value;
        self
    }
}
impl core::ops::Deref for DepthClampRangeEXTBuilder {
    type Target = DepthClampRangeEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for DepthClampRangeEXTBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceCooperativeMatrix2FeaturesNV`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceCooperativeMatrix2FeaturesNVBuilder<'a> {
    inner: PhysicalDeviceCooperativeMatrix2FeaturesNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceCooperativeMatrix2FeaturesNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceCooperativeMatrix2FeaturesNVBuilder<'a> {
        PhysicalDeviceCooperativeMatrix2FeaturesNVBuilder {
            inner: PhysicalDeviceCooperativeMatrix2FeaturesNV {
                s_type: StructureType::from_raw(1000593000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceCooperativeMatrix2FeaturesNVBuilder<'a> {
    #[inline]
    pub fn cooperative_matrix_workgroup_scope(mut self, value: bool) -> Self {
        self.inner.cooperative_matrix_workgroup_scope = value as u32;
        self
    }
    #[inline]
    pub fn cooperative_matrix_flexible_dimensions(mut self, value: bool) -> Self {
        self.inner.cooperative_matrix_flexible_dimensions = value as u32;
        self
    }
    #[inline]
    pub fn cooperative_matrix_reductions(mut self, value: bool) -> Self {
        self.inner.cooperative_matrix_reductions = value as u32;
        self
    }
    #[inline]
    pub fn cooperative_matrix_conversions(mut self, value: bool) -> Self {
        self.inner.cooperative_matrix_conversions = value as u32;
        self
    }
    #[inline]
    pub fn cooperative_matrix_per_element_operations(mut self, value: bool) -> Self {
        self.inner.cooperative_matrix_per_element_operations = value as u32;
        self
    }
    #[inline]
    pub fn cooperative_matrix_tensor_addressing(mut self, value: bool) -> Self {
        self.inner.cooperative_matrix_tensor_addressing = value as u32;
        self
    }
    #[inline]
    pub fn cooperative_matrix_block_loads(mut self, value: bool) -> Self {
        self.inner.cooperative_matrix_block_loads = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceCooperativeMatrix2FeaturesNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceCooperativeMatrix2FeaturesNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceCooperativeMatrix2FeaturesNVBuilder<'a> {
    type Target = PhysicalDeviceCooperativeMatrix2FeaturesNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceCooperativeMatrix2FeaturesNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceCooperativeMatrix2PropertiesNV`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceCooperativeMatrix2PropertiesNVBuilder<'a> {
    inner: PhysicalDeviceCooperativeMatrix2PropertiesNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceCooperativeMatrix2PropertiesNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceCooperativeMatrix2PropertiesNVBuilder<'a> {
        PhysicalDeviceCooperativeMatrix2PropertiesNVBuilder {
            inner: PhysicalDeviceCooperativeMatrix2PropertiesNV {
                s_type: StructureType::from_raw(1000593002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceCooperativeMatrix2PropertiesNVBuilder<'a> {
    #[inline]
    pub fn cooperative_matrix_workgroup_scope_max_workgroup_size(
        mut self,
        value: u32,
    ) -> Self {
        self.inner.cooperative_matrix_workgroup_scope_max_workgroup_size = value;
        self
    }
    #[inline]
    pub fn cooperative_matrix_flexible_dimensions_max_dimension(
        mut self,
        value: u32,
    ) -> Self {
        self.inner.cooperative_matrix_flexible_dimensions_max_dimension = value;
        self
    }
    #[inline]
    pub fn cooperative_matrix_workgroup_scope_reserved_shared_memory(
        mut self,
        value: u32,
    ) -> Self {
        self.inner.cooperative_matrix_workgroup_scope_reserved_shared_memory = value;
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceCooperativeMatrix2PropertiesNVBuilder<'a> {
    type Target = PhysicalDeviceCooperativeMatrix2PropertiesNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceCooperativeMatrix2PropertiesNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`CooperativeMatrixFlexibleDimensionsPropertiesNV`] with lifetime-tied pNext safety.
pub struct CooperativeMatrixFlexibleDimensionsPropertiesNVBuilder<'a> {
    inner: CooperativeMatrixFlexibleDimensionsPropertiesNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl CooperativeMatrixFlexibleDimensionsPropertiesNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> CooperativeMatrixFlexibleDimensionsPropertiesNVBuilder<'a> {
        CooperativeMatrixFlexibleDimensionsPropertiesNVBuilder {
            inner: CooperativeMatrixFlexibleDimensionsPropertiesNV {
                s_type: StructureType::from_raw(1000593001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> CooperativeMatrixFlexibleDimensionsPropertiesNVBuilder<'a> {
    #[inline]
    pub fn m_granularity(mut self, value: u32) -> Self {
        self.inner.m_granularity = value;
        self
    }
    #[inline]
    pub fn n_granularity(mut self, value: u32) -> Self {
        self.inner.n_granularity = value;
        self
    }
    #[inline]
    pub fn k_granularity(mut self, value: u32) -> Self {
        self.inner.k_granularity = value;
        self
    }
    #[inline]
    pub fn a_type(mut self, value: ComponentTypeKHR) -> Self {
        self.inner.a_type = value;
        self
    }
    #[inline]
    pub fn b_type(mut self, value: ComponentTypeKHR) -> Self {
        self.inner.b_type = value;
        self
    }
    #[inline]
    pub fn c_type(mut self, value: ComponentTypeKHR) -> Self {
        self.inner.c_type = value;
        self
    }
    #[inline]
    pub fn result_type(mut self, value: ComponentTypeKHR) -> Self {
        self.inner.result_type = value;
        self
    }
    #[inline]
    pub fn saturating_accumulation(mut self, value: bool) -> Self {
        self.inner.saturating_accumulation = value as u32;
        self
    }
    #[inline]
    pub fn scope(mut self, value: ScopeKHR) -> Self {
        self.inner.scope = value;
        self
    }
    #[inline]
    pub fn workgroup_invocations(mut self, value: u32) -> Self {
        self.inner.workgroup_invocations = value;
        self
    }
}
impl<'a> core::ops::Deref
for CooperativeMatrixFlexibleDimensionsPropertiesNVBuilder<'a> {
    type Target = CooperativeMatrixFlexibleDimensionsPropertiesNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for CooperativeMatrixFlexibleDimensionsPropertiesNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceHdrVividFeaturesHUAWEI`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceHdrVividFeaturesHUAWEIBuilder<'a> {
    inner: PhysicalDeviceHdrVividFeaturesHUAWEI,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceHdrVividFeaturesHUAWEI {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceHdrVividFeaturesHUAWEIBuilder<'a> {
        PhysicalDeviceHdrVividFeaturesHUAWEIBuilder {
            inner: PhysicalDeviceHdrVividFeaturesHUAWEI {
                s_type: StructureType::from_raw(1000590000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceHdrVividFeaturesHUAWEIBuilder<'a> {
    #[inline]
    pub fn hdr_vivid(mut self, value: bool) -> Self {
        self.inner.hdr_vivid = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceHdrVividFeaturesHUAWEI`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceHdrVividFeaturesHUAWEI>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceHdrVividFeaturesHUAWEIBuilder<'a> {
    type Target = PhysicalDeviceHdrVividFeaturesHUAWEI;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceHdrVividFeaturesHUAWEIBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceVertexAttributeRobustnessFeaturesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceVertexAttributeRobustnessFeaturesEXTBuilder<'a> {
    inner: PhysicalDeviceVertexAttributeRobustnessFeaturesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceVertexAttributeRobustnessFeaturesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceVertexAttributeRobustnessFeaturesEXTBuilder<
        'a,
    > {
        PhysicalDeviceVertexAttributeRobustnessFeaturesEXTBuilder {
            inner: PhysicalDeviceVertexAttributeRobustnessFeaturesEXT {
                s_type: StructureType::from_raw(1000608000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceVertexAttributeRobustnessFeaturesEXTBuilder<'a> {
    #[inline]
    pub fn vertex_attribute_robustness(mut self, value: bool) -> Self {
        self.inner.vertex_attribute_robustness = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceVertexAttributeRobustnessFeaturesEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceVertexAttributeRobustnessFeaturesEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDeviceVertexAttributeRobustnessFeaturesEXTBuilder<'a> {
    type Target = PhysicalDeviceVertexAttributeRobustnessFeaturesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceVertexAttributeRobustnessFeaturesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceDenseGeometryFormatFeaturesAMDX`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceDenseGeometryFormatFeaturesAMDXBuilder<'a> {
    inner: PhysicalDeviceDenseGeometryFormatFeaturesAMDX,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceDenseGeometryFormatFeaturesAMDX {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceDenseGeometryFormatFeaturesAMDXBuilder<'a> {
        PhysicalDeviceDenseGeometryFormatFeaturesAMDXBuilder {
            inner: PhysicalDeviceDenseGeometryFormatFeaturesAMDX {
                s_type: StructureType::from_raw(1000478000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceDenseGeometryFormatFeaturesAMDXBuilder<'a> {
    #[inline]
    pub fn dense_geometry_format(mut self, value: bool) -> Self {
        self.inner.dense_geometry_format = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceDenseGeometryFormatFeaturesAMDX`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceDenseGeometryFormatFeaturesAMDX>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceDenseGeometryFormatFeaturesAMDXBuilder<'a> {
    type Target = PhysicalDeviceDenseGeometryFormatFeaturesAMDX;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceDenseGeometryFormatFeaturesAMDXBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`AccelerationStructureDenseGeometryFormatTrianglesDataAMDX`] with lifetime-tied pNext safety.
pub struct AccelerationStructureDenseGeometryFormatTrianglesDataAMDXBuilder<'a> {
    inner: AccelerationStructureDenseGeometryFormatTrianglesDataAMDX,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl AccelerationStructureDenseGeometryFormatTrianglesDataAMDX {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> AccelerationStructureDenseGeometryFormatTrianglesDataAMDXBuilder<
        'a,
    > {
        AccelerationStructureDenseGeometryFormatTrianglesDataAMDXBuilder {
            inner: AccelerationStructureDenseGeometryFormatTrianglesDataAMDX {
                s_type: StructureType::from_raw(1000478001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> AccelerationStructureDenseGeometryFormatTrianglesDataAMDXBuilder<'a> {
    #[inline]
    pub fn compressed_data(mut self, value: DeviceOrHostAddressConstKHR) -> Self {
        self.inner.compressed_data = value;
        self
    }
    #[inline]
    pub fn data_size(mut self, value: u64) -> Self {
        self.inner.data_size = value;
        self
    }
    #[inline]
    pub fn num_triangles(mut self, value: u32) -> Self {
        self.inner.num_triangles = value;
        self
    }
    #[inline]
    pub fn num_vertices(mut self, value: u32) -> Self {
        self.inner.num_vertices = value;
        self
    }
    #[inline]
    pub fn max_primitive_index(mut self, value: u32) -> Self {
        self.inner.max_primitive_index = value;
        self
    }
    #[inline]
    pub fn max_geometry_index(mut self, value: u32) -> Self {
        self.inner.max_geometry_index = value;
        self
    }
    #[inline]
    pub fn format(mut self, value: CompressedTriangleFormatAMDX) -> Self {
        self.inner.format = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`AccelerationStructureDenseGeometryFormatTrianglesDataAMDX`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<
        T: ExtendsAccelerationStructureDenseGeometryFormatTrianglesDataAMDX,
    >(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref
for AccelerationStructureDenseGeometryFormatTrianglesDataAMDXBuilder<'a> {
    type Target = AccelerationStructureDenseGeometryFormatTrianglesDataAMDX;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for AccelerationStructureDenseGeometryFormatTrianglesDataAMDXBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceDepthClampZeroOneFeaturesKHR`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceDepthClampZeroOneFeaturesKHRBuilder<'a> {
    inner: PhysicalDeviceDepthClampZeroOneFeaturesKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceDepthClampZeroOneFeaturesKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceDepthClampZeroOneFeaturesKHRBuilder<'a> {
        PhysicalDeviceDepthClampZeroOneFeaturesKHRBuilder {
            inner: PhysicalDeviceDepthClampZeroOneFeaturesKHR {
                s_type: StructureType::from_raw(1000421000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceDepthClampZeroOneFeaturesKHRBuilder<'a> {
    #[inline]
    pub fn depth_clamp_zero_one(mut self, value: bool) -> Self {
        self.inner.depth_clamp_zero_one = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceDepthClampZeroOneFeaturesKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceDepthClampZeroOneFeaturesKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceDepthClampZeroOneFeaturesKHRBuilder<'a> {
    type Target = PhysicalDeviceDepthClampZeroOneFeaturesKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceDepthClampZeroOneFeaturesKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceCooperativeVectorFeaturesNV`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceCooperativeVectorFeaturesNVBuilder<'a> {
    inner: PhysicalDeviceCooperativeVectorFeaturesNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceCooperativeVectorFeaturesNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceCooperativeVectorFeaturesNVBuilder<'a> {
        PhysicalDeviceCooperativeVectorFeaturesNVBuilder {
            inner: PhysicalDeviceCooperativeVectorFeaturesNV {
                s_type: StructureType::from_raw(1000491000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceCooperativeVectorFeaturesNVBuilder<'a> {
    #[inline]
    pub fn cooperative_vector(mut self, value: bool) -> Self {
        self.inner.cooperative_vector = value as u32;
        self
    }
    #[inline]
    pub fn cooperative_vector_training(mut self, value: bool) -> Self {
        self.inner.cooperative_vector_training = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceCooperativeVectorFeaturesNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceCooperativeVectorFeaturesNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceCooperativeVectorFeaturesNVBuilder<'a> {
    type Target = PhysicalDeviceCooperativeVectorFeaturesNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceCooperativeVectorFeaturesNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`CooperativeVectorPropertiesNV`] with lifetime-tied pNext safety.
pub struct CooperativeVectorPropertiesNVBuilder<'a> {
    inner: CooperativeVectorPropertiesNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl CooperativeVectorPropertiesNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> CooperativeVectorPropertiesNVBuilder<'a> {
        CooperativeVectorPropertiesNVBuilder {
            inner: CooperativeVectorPropertiesNV {
                s_type: StructureType::from_raw(1000491002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> CooperativeVectorPropertiesNVBuilder<'a> {
    #[inline]
    pub fn input_type(mut self, value: ComponentTypeKHR) -> Self {
        self.inner.input_type = value;
        self
    }
    #[inline]
    pub fn input_interpretation(mut self, value: ComponentTypeKHR) -> Self {
        self.inner.input_interpretation = value;
        self
    }
    #[inline]
    pub fn matrix_interpretation(mut self, value: ComponentTypeKHR) -> Self {
        self.inner.matrix_interpretation = value;
        self
    }
    #[inline]
    pub fn bias_interpretation(mut self, value: ComponentTypeKHR) -> Self {
        self.inner.bias_interpretation = value;
        self
    }
    #[inline]
    pub fn result_type(mut self, value: ComponentTypeKHR) -> Self {
        self.inner.result_type = value;
        self
    }
    #[inline]
    pub fn transpose(mut self, value: bool) -> Self {
        self.inner.transpose = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`CooperativeVectorPropertiesNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsCooperativeVectorPropertiesNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for CooperativeVectorPropertiesNVBuilder<'a> {
    type Target = CooperativeVectorPropertiesNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for CooperativeVectorPropertiesNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceCooperativeVectorPropertiesNV`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceCooperativeVectorPropertiesNVBuilder<'a> {
    inner: PhysicalDeviceCooperativeVectorPropertiesNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceCooperativeVectorPropertiesNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceCooperativeVectorPropertiesNVBuilder<'a> {
        PhysicalDeviceCooperativeVectorPropertiesNVBuilder {
            inner: PhysicalDeviceCooperativeVectorPropertiesNV {
                s_type: StructureType::from_raw(1000491001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceCooperativeVectorPropertiesNVBuilder<'a> {
    #[inline]
    pub fn cooperative_vector_supported_stages(
        mut self,
        value: ShaderStageFlags,
    ) -> Self {
        self.inner.cooperative_vector_supported_stages = value;
        self
    }
    #[inline]
    pub fn cooperative_vector_training_float16_accumulation(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.cooperative_vector_training_float16_accumulation = value as u32;
        self
    }
    #[inline]
    pub fn cooperative_vector_training_float32_accumulation(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.cooperative_vector_training_float32_accumulation = value as u32;
        self
    }
    #[inline]
    pub fn max_cooperative_vector_components(mut self, value: u32) -> Self {
        self.inner.max_cooperative_vector_components = value;
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceCooperativeVectorPropertiesNVBuilder<'a> {
    type Target = PhysicalDeviceCooperativeVectorPropertiesNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceCooperativeVectorPropertiesNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ConvertCooperativeVectorMatrixInfoNV`] with lifetime-tied pNext safety.
pub struct ConvertCooperativeVectorMatrixInfoNVBuilder<'a> {
    inner: ConvertCooperativeVectorMatrixInfoNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ConvertCooperativeVectorMatrixInfoNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ConvertCooperativeVectorMatrixInfoNVBuilder<'a> {
        ConvertCooperativeVectorMatrixInfoNVBuilder {
            inner: ConvertCooperativeVectorMatrixInfoNV {
                s_type: StructureType::from_raw(1000491004i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ConvertCooperativeVectorMatrixInfoNVBuilder<'a> {
    #[inline]
    pub fn src_size(mut self, value: usize) -> Self {
        self.inner.src_size = value;
        self
    }
    #[inline]
    pub fn src_data(mut self, value: DeviceOrHostAddressConstKHR) -> Self {
        self.inner.src_data = value;
        self
    }
    #[inline]
    pub fn dst_size(mut self, value: *mut usize) -> Self {
        self.inner.p_dst_size = value;
        self
    }
    #[inline]
    pub fn dst_data(mut self, value: DeviceOrHostAddressKHR) -> Self {
        self.inner.dst_data = value;
        self
    }
    #[inline]
    pub fn src_component_type(mut self, value: ComponentTypeKHR) -> Self {
        self.inner.src_component_type = value;
        self
    }
    #[inline]
    pub fn dst_component_type(mut self, value: ComponentTypeKHR) -> Self {
        self.inner.dst_component_type = value;
        self
    }
    #[inline]
    pub fn num_rows(mut self, value: u32) -> Self {
        self.inner.num_rows = value;
        self
    }
    #[inline]
    pub fn num_columns(mut self, value: u32) -> Self {
        self.inner.num_columns = value;
        self
    }
    #[inline]
    pub fn src_layout(mut self, value: CooperativeVectorMatrixLayoutNV) -> Self {
        self.inner.src_layout = value;
        self
    }
    #[inline]
    pub fn src_stride(mut self, value: usize) -> Self {
        self.inner.src_stride = value;
        self
    }
    #[inline]
    pub fn dst_layout(mut self, value: CooperativeVectorMatrixLayoutNV) -> Self {
        self.inner.dst_layout = value;
        self
    }
    #[inline]
    pub fn dst_stride(mut self, value: usize) -> Self {
        self.inner.dst_stride = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`ConvertCooperativeVectorMatrixInfoNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsConvertCooperativeVectorMatrixInfoNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for ConvertCooperativeVectorMatrixInfoNVBuilder<'a> {
    type Target = ConvertCooperativeVectorMatrixInfoNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ConvertCooperativeVectorMatrixInfoNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceTileShadingFeaturesQCOM`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceTileShadingFeaturesQCOMBuilder<'a> {
    inner: PhysicalDeviceTileShadingFeaturesQCOM,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceTileShadingFeaturesQCOM {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceTileShadingFeaturesQCOMBuilder<'a> {
        PhysicalDeviceTileShadingFeaturesQCOMBuilder {
            inner: PhysicalDeviceTileShadingFeaturesQCOM {
                s_type: StructureType::from_raw(1000309000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceTileShadingFeaturesQCOMBuilder<'a> {
    #[inline]
    pub fn tile_shading(mut self, value: bool) -> Self {
        self.inner.tile_shading = value as u32;
        self
    }
    #[inline]
    pub fn tile_shading_fragment_stage(mut self, value: bool) -> Self {
        self.inner.tile_shading_fragment_stage = value as u32;
        self
    }
    #[inline]
    pub fn tile_shading_color_attachments(mut self, value: bool) -> Self {
        self.inner.tile_shading_color_attachments = value as u32;
        self
    }
    #[inline]
    pub fn tile_shading_depth_attachments(mut self, value: bool) -> Self {
        self.inner.tile_shading_depth_attachments = value as u32;
        self
    }
    #[inline]
    pub fn tile_shading_stencil_attachments(mut self, value: bool) -> Self {
        self.inner.tile_shading_stencil_attachments = value as u32;
        self
    }
    #[inline]
    pub fn tile_shading_input_attachments(mut self, value: bool) -> Self {
        self.inner.tile_shading_input_attachments = value as u32;
        self
    }
    #[inline]
    pub fn tile_shading_sampled_attachments(mut self, value: bool) -> Self {
        self.inner.tile_shading_sampled_attachments = value as u32;
        self
    }
    #[inline]
    pub fn tile_shading_per_tile_draw(mut self, value: bool) -> Self {
        self.inner.tile_shading_per_tile_draw = value as u32;
        self
    }
    #[inline]
    pub fn tile_shading_per_tile_dispatch(mut self, value: bool) -> Self {
        self.inner.tile_shading_per_tile_dispatch = value as u32;
        self
    }
    #[inline]
    pub fn tile_shading_dispatch_tile(mut self, value: bool) -> Self {
        self.inner.tile_shading_dispatch_tile = value as u32;
        self
    }
    #[inline]
    pub fn tile_shading_apron(mut self, value: bool) -> Self {
        self.inner.tile_shading_apron = value as u32;
        self
    }
    #[inline]
    pub fn tile_shading_anisotropic_apron(mut self, value: bool) -> Self {
        self.inner.tile_shading_anisotropic_apron = value as u32;
        self
    }
    #[inline]
    pub fn tile_shading_atomic_ops(mut self, value: bool) -> Self {
        self.inner.tile_shading_atomic_ops = value as u32;
        self
    }
    #[inline]
    pub fn tile_shading_image_processing(mut self, value: bool) -> Self {
        self.inner.tile_shading_image_processing = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceTileShadingFeaturesQCOM`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceTileShadingFeaturesQCOM>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceTileShadingFeaturesQCOMBuilder<'a> {
    type Target = PhysicalDeviceTileShadingFeaturesQCOM;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceTileShadingFeaturesQCOMBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceTileShadingPropertiesQCOM`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceTileShadingPropertiesQCOMBuilder<'a> {
    inner: PhysicalDeviceTileShadingPropertiesQCOM,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceTileShadingPropertiesQCOM {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceTileShadingPropertiesQCOMBuilder<'a> {
        PhysicalDeviceTileShadingPropertiesQCOMBuilder {
            inner: PhysicalDeviceTileShadingPropertiesQCOM {
                s_type: StructureType::from_raw(1000309001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceTileShadingPropertiesQCOMBuilder<'a> {
    #[inline]
    pub fn max_apron_size(mut self, value: u32) -> Self {
        self.inner.max_apron_size = value;
        self
    }
    #[inline]
    pub fn prefer_non_coherent(mut self, value: bool) -> Self {
        self.inner.prefer_non_coherent = value as u32;
        self
    }
    #[inline]
    pub fn tile_granularity(mut self, value: Extent2D) -> Self {
        self.inner.tile_granularity = value;
        self
    }
    #[inline]
    pub fn max_tile_shading_rate(mut self, value: Extent2D) -> Self {
        self.inner.max_tile_shading_rate = value;
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceTileShadingPropertiesQCOMBuilder<'a> {
    type Target = PhysicalDeviceTileShadingPropertiesQCOM;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceTileShadingPropertiesQCOMBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`RenderPassTileShadingCreateInfoQCOM`] with lifetime-tied pNext safety.
pub struct RenderPassTileShadingCreateInfoQCOMBuilder<'a> {
    inner: RenderPassTileShadingCreateInfoQCOM,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl RenderPassTileShadingCreateInfoQCOM {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> RenderPassTileShadingCreateInfoQCOMBuilder<'a> {
        RenderPassTileShadingCreateInfoQCOMBuilder {
            inner: RenderPassTileShadingCreateInfoQCOM {
                s_type: StructureType::from_raw(1000309002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> RenderPassTileShadingCreateInfoQCOMBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: TileShadingRenderPassFlagsQCOM) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn tile_apron_size(mut self, value: Extent2D) -> Self {
        self.inner.tile_apron_size = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`RenderPassTileShadingCreateInfoQCOM`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsRenderPassTileShadingCreateInfoQCOM>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for RenderPassTileShadingCreateInfoQCOMBuilder<'a> {
    type Target = RenderPassTileShadingCreateInfoQCOM;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for RenderPassTileShadingCreateInfoQCOMBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PerTileBeginInfoQCOM`] with lifetime-tied pNext safety.
pub struct PerTileBeginInfoQCOMBuilder<'a> {
    inner: PerTileBeginInfoQCOM,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PerTileBeginInfoQCOM {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PerTileBeginInfoQCOMBuilder<'a> {
        PerTileBeginInfoQCOMBuilder {
            inner: PerTileBeginInfoQCOM {
                s_type: StructureType::from_raw(1000309003i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PerTileBeginInfoQCOMBuilder<'a> {
    ///Prepend a struct to the pNext chain. See [`PerTileBeginInfoQCOM`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPerTileBeginInfoQCOM>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for PerTileBeginInfoQCOMBuilder<'a> {
    type Target = PerTileBeginInfoQCOM;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PerTileBeginInfoQCOMBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PerTileEndInfoQCOM`] with lifetime-tied pNext safety.
pub struct PerTileEndInfoQCOMBuilder<'a> {
    inner: PerTileEndInfoQCOM,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PerTileEndInfoQCOM {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PerTileEndInfoQCOMBuilder<'a> {
        PerTileEndInfoQCOMBuilder {
            inner: PerTileEndInfoQCOM {
                s_type: StructureType::from_raw(1000309004i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PerTileEndInfoQCOMBuilder<'a> {
    ///Prepend a struct to the pNext chain. See [`PerTileEndInfoQCOM`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPerTileEndInfoQCOM>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for PerTileEndInfoQCOMBuilder<'a> {
    type Target = PerTileEndInfoQCOM;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PerTileEndInfoQCOMBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DispatchTileInfoQCOM`] with lifetime-tied pNext safety.
pub struct DispatchTileInfoQCOMBuilder<'a> {
    inner: DispatchTileInfoQCOM,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DispatchTileInfoQCOM {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> DispatchTileInfoQCOMBuilder<'a> {
        DispatchTileInfoQCOMBuilder {
            inner: DispatchTileInfoQCOM {
                s_type: StructureType::from_raw(1000309005i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DispatchTileInfoQCOMBuilder<'a> {
    ///Prepend a struct to the pNext chain. See [`DispatchTileInfoQCOM`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsDispatchTileInfoQCOM>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for DispatchTileInfoQCOMBuilder<'a> {
    type Target = DispatchTileInfoQCOM;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for DispatchTileInfoQCOMBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceFragmentDensityMapLayeredPropertiesVALVEBuilder<'a> {
    inner: PhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceFragmentDensityMapLayeredPropertiesVALVEBuilder<
        'a,
    > {
        PhysicalDeviceFragmentDensityMapLayeredPropertiesVALVEBuilder {
            inner: PhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE {
                s_type: StructureType::from_raw(1000611001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceFragmentDensityMapLayeredPropertiesVALVEBuilder<'a> {
    #[inline]
    pub fn max_fragment_density_map_layers(mut self, value: u32) -> Self {
        self.inner.max_fragment_density_map_layers = value;
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDeviceFragmentDensityMapLayeredPropertiesVALVEBuilder<'a> {
    type Target = PhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceFragmentDensityMapLayeredPropertiesVALVEBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVEBuilder<'a> {
    inner: PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVEBuilder<
        'a,
    > {
        PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVEBuilder {
            inner: PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE {
                s_type: StructureType::from_raw(1000611000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVEBuilder<'a> {
    #[inline]
    pub fn fragment_density_map_layered(mut self, value: bool) -> Self {
        self.inner.fragment_density_map_layered = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVEBuilder<'a> {
    type Target = PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVEBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PipelineFragmentDensityMapLayeredCreateInfoVALVE`] with lifetime-tied pNext safety.
pub struct PipelineFragmentDensityMapLayeredCreateInfoVALVEBuilder<'a> {
    inner: PipelineFragmentDensityMapLayeredCreateInfoVALVE,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PipelineFragmentDensityMapLayeredCreateInfoVALVE {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PipelineFragmentDensityMapLayeredCreateInfoVALVEBuilder<'a> {
        PipelineFragmentDensityMapLayeredCreateInfoVALVEBuilder {
            inner: PipelineFragmentDensityMapLayeredCreateInfoVALVE {
                s_type: StructureType::from_raw(1000611002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PipelineFragmentDensityMapLayeredCreateInfoVALVEBuilder<'a> {
    #[inline]
    pub fn max_fragment_density_map_layers(mut self, value: u32) -> Self {
        self.inner.max_fragment_density_map_layers = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PipelineFragmentDensityMapLayeredCreateInfoVALVE`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPipelineFragmentDensityMapLayeredCreateInfoVALVE>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref
for PipelineFragmentDensityMapLayeredCreateInfoVALVEBuilder<'a> {
    type Target = PipelineFragmentDensityMapLayeredCreateInfoVALVE;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PipelineFragmentDensityMapLayeredCreateInfoVALVEBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`SetPresentConfigNV`] with lifetime-tied pNext safety.
pub struct SetPresentConfigNVBuilder<'a> {
    inner: SetPresentConfigNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl SetPresentConfigNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> SetPresentConfigNVBuilder<'a> {
        SetPresentConfigNVBuilder {
            inner: SetPresentConfigNV {
                s_type: StructureType::from_raw(1000613000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> SetPresentConfigNVBuilder<'a> {
    #[inline]
    pub fn num_frames_per_batch(mut self, value: u32) -> Self {
        self.inner.num_frames_per_batch = value;
        self
    }
    #[inline]
    pub fn present_config_feedback(mut self, value: u32) -> Self {
        self.inner.present_config_feedback = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`SetPresentConfigNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsSetPresentConfigNV>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for SetPresentConfigNVBuilder<'a> {
    type Target = SetPresentConfigNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for SetPresentConfigNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDevicePresentMeteringFeaturesNV`] with lifetime-tied pNext safety.
pub struct PhysicalDevicePresentMeteringFeaturesNVBuilder<'a> {
    inner: PhysicalDevicePresentMeteringFeaturesNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDevicePresentMeteringFeaturesNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDevicePresentMeteringFeaturesNVBuilder<'a> {
        PhysicalDevicePresentMeteringFeaturesNVBuilder {
            inner: PhysicalDevicePresentMeteringFeaturesNV {
                s_type: StructureType::from_raw(1000613001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDevicePresentMeteringFeaturesNVBuilder<'a> {
    #[inline]
    pub fn present_metering(mut self, value: bool) -> Self {
        self.inner.present_metering = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDevicePresentMeteringFeaturesNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDevicePresentMeteringFeaturesNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDevicePresentMeteringFeaturesNVBuilder<'a> {
    type Target = PhysicalDevicePresentMeteringFeaturesNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDevicePresentMeteringFeaturesNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ExternalComputeQueueDeviceCreateInfoNV`] with lifetime-tied pNext safety.
pub struct ExternalComputeQueueDeviceCreateInfoNVBuilder<'a> {
    inner: ExternalComputeQueueDeviceCreateInfoNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ExternalComputeQueueDeviceCreateInfoNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ExternalComputeQueueDeviceCreateInfoNVBuilder<'a> {
        ExternalComputeQueueDeviceCreateInfoNVBuilder {
            inner: ExternalComputeQueueDeviceCreateInfoNV {
                s_type: StructureType::from_raw(1000556000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ExternalComputeQueueDeviceCreateInfoNVBuilder<'a> {
    #[inline]
    pub fn reserved_external_queues(mut self, value: u32) -> Self {
        self.inner.reserved_external_queues = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`ExternalComputeQueueDeviceCreateInfoNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsExternalComputeQueueDeviceCreateInfoNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for ExternalComputeQueueDeviceCreateInfoNVBuilder<'a> {
    type Target = ExternalComputeQueueDeviceCreateInfoNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ExternalComputeQueueDeviceCreateInfoNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ExternalComputeQueueCreateInfoNV`] with lifetime-tied pNext safety.
pub struct ExternalComputeQueueCreateInfoNVBuilder<'a> {
    inner: ExternalComputeQueueCreateInfoNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ExternalComputeQueueCreateInfoNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ExternalComputeQueueCreateInfoNVBuilder<'a> {
        ExternalComputeQueueCreateInfoNVBuilder {
            inner: ExternalComputeQueueCreateInfoNV {
                s_type: StructureType::from_raw(1000556001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ExternalComputeQueueCreateInfoNVBuilder<'a> {
    #[inline]
    pub fn preferred_queue(mut self, value: Queue) -> Self {
        self.inner.preferred_queue = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`ExternalComputeQueueCreateInfoNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsExternalComputeQueueCreateInfoNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for ExternalComputeQueueCreateInfoNVBuilder<'a> {
    type Target = ExternalComputeQueueCreateInfoNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ExternalComputeQueueCreateInfoNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ExternalComputeQueueDataParamsNV`] with lifetime-tied pNext safety.
pub struct ExternalComputeQueueDataParamsNVBuilder<'a> {
    inner: ExternalComputeQueueDataParamsNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ExternalComputeQueueDataParamsNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ExternalComputeQueueDataParamsNVBuilder<'a> {
        ExternalComputeQueueDataParamsNVBuilder {
            inner: ExternalComputeQueueDataParamsNV {
                s_type: StructureType::from_raw(1000556002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ExternalComputeQueueDataParamsNVBuilder<'a> {
    #[inline]
    pub fn device_index(mut self, value: u32) -> Self {
        self.inner.device_index = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`ExternalComputeQueueDataParamsNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsExternalComputeQueueDataParamsNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for ExternalComputeQueueDataParamsNVBuilder<'a> {
    type Target = ExternalComputeQueueDataParamsNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ExternalComputeQueueDataParamsNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceExternalComputeQueuePropertiesNV`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceExternalComputeQueuePropertiesNVBuilder<'a> {
    inner: PhysicalDeviceExternalComputeQueuePropertiesNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceExternalComputeQueuePropertiesNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceExternalComputeQueuePropertiesNVBuilder<'a> {
        PhysicalDeviceExternalComputeQueuePropertiesNVBuilder {
            inner: PhysicalDeviceExternalComputeQueuePropertiesNV {
                s_type: StructureType::from_raw(1000556003i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceExternalComputeQueuePropertiesNVBuilder<'a> {
    #[inline]
    pub fn external_data_size(mut self, value: u32) -> Self {
        self.inner.external_data_size = value;
        self
    }
    #[inline]
    pub fn max_external_queues(mut self, value: u32) -> Self {
        self.inner.max_external_queues = value;
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceExternalComputeQueuePropertiesNVBuilder<'a> {
    type Target = PhysicalDeviceExternalComputeQueuePropertiesNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceExternalComputeQueuePropertiesNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXTBuilder<'a> {
    inner: PhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXTBuilder<
        'a,
    > {
        PhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXTBuilder {
            inner: PhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT {
                s_type: StructureType::from_raw(1000642000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXTBuilder<'a> {
    #[inline]
    pub fn shader_uniform_buffer_unsized_array(mut self, value: bool) -> Self {
        self.inner.shader_uniform_buffer_unsized_array = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXTBuilder<'a> {
    type Target = PhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceShaderMixedFloatDotProductFeaturesVALVEBuilder<'a> {
    inner: PhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceShaderMixedFloatDotProductFeaturesVALVEBuilder<
        'a,
    > {
        PhysicalDeviceShaderMixedFloatDotProductFeaturesVALVEBuilder {
            inner: PhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE {
                s_type: StructureType::from_raw(1000673000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceShaderMixedFloatDotProductFeaturesVALVEBuilder<'a> {
    #[inline]
    pub fn shader_mixed_float_dot_product_float16_acc_float32(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.shader_mixed_float_dot_product_float16_acc_float32 = value as u32;
        self
    }
    #[inline]
    pub fn shader_mixed_float_dot_product_float16_acc_float16(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.shader_mixed_float_dot_product_float16_acc_float16 = value as u32;
        self
    }
    #[inline]
    pub fn shader_mixed_float_dot_product_b_float16_acc(mut self, value: bool) -> Self {
        self.inner.shader_mixed_float_dot_product_b_float16_acc = value as u32;
        self
    }
    #[inline]
    pub fn shader_mixed_float_dot_product_float8_acc_float32(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.shader_mixed_float_dot_product_float8_acc_float32 = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDeviceShaderMixedFloatDotProductFeaturesVALVEBuilder<'a> {
    type Target = PhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceShaderMixedFloatDotProductFeaturesVALVEBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceFormatPackFeaturesARM`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceFormatPackFeaturesARMBuilder<'a> {
    inner: PhysicalDeviceFormatPackFeaturesARM,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceFormatPackFeaturesARM {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceFormatPackFeaturesARMBuilder<'a> {
        PhysicalDeviceFormatPackFeaturesARMBuilder {
            inner: PhysicalDeviceFormatPackFeaturesARM {
                s_type: StructureType::from_raw(1000609000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceFormatPackFeaturesARMBuilder<'a> {
    #[inline]
    pub fn format_pack(mut self, value: bool) -> Self {
        self.inner.format_pack = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceFormatPackFeaturesARM`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceFormatPackFeaturesARM>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceFormatPackFeaturesARMBuilder<'a> {
    type Target = PhysicalDeviceFormatPackFeaturesARM;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceFormatPackFeaturesARMBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`TensorDescriptionARM`] with lifetime-tied pNext safety.
pub struct TensorDescriptionARMBuilder<'a> {
    inner: TensorDescriptionARM,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl TensorDescriptionARM {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> TensorDescriptionARMBuilder<'a> {
        TensorDescriptionARMBuilder {
            inner: TensorDescriptionARM {
                s_type: StructureType::from_raw(1000460006i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> TensorDescriptionARMBuilder<'a> {
    #[inline]
    pub fn tiling(mut self, value: TensorTilingARM) -> Self {
        self.inner.tiling = value;
        self
    }
    #[inline]
    pub fn format(mut self, value: Format) -> Self {
        self.inner.format = value;
        self
    }
    #[inline]
    pub fn dimensions(mut self, slice: &'a [i64]) -> Self {
        self.inner.dimension_count = slice.len() as u32;
        self.inner.p_dimensions = slice.as_ptr();
        self
    }
    #[inline]
    pub fn strides(mut self, slice: &'a [i64]) -> Self {
        self.inner.dimension_count = slice.len() as u32;
        self.inner.p_strides = slice.as_ptr();
        self
    }
    #[inline]
    pub fn usage(mut self, value: TensorUsageFlagsARM) -> Self {
        self.inner.usage = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`TensorDescriptionARM`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsTensorDescriptionARM>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for TensorDescriptionARMBuilder<'a> {
    type Target = TensorDescriptionARM;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for TensorDescriptionARMBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`TensorCreateInfoARM`] with lifetime-tied pNext safety.
pub struct TensorCreateInfoARMBuilder<'a> {
    inner: TensorCreateInfoARM,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl TensorCreateInfoARM {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> TensorCreateInfoARMBuilder<'a> {
        TensorCreateInfoARMBuilder {
            inner: TensorCreateInfoARM {
                s_type: StructureType::from_raw(1000460000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> TensorCreateInfoARMBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: TensorCreateFlagsARM) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn description(mut self, value: &'a TensorDescriptionARM) -> Self {
        self.inner.p_description = value;
        self
    }
    #[inline]
    pub fn sharing_mode(mut self, value: SharingMode) -> Self {
        self.inner.sharing_mode = value;
        self
    }
    #[inline]
    pub fn queue_family_indices(mut self, slice: &'a [u32]) -> Self {
        self.inner.queue_family_index_count = slice.len() as u32;
        self.inner.p_queue_family_indices = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`TensorCreateInfoARM`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsTensorCreateInfoARM>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for TensorCreateInfoARMBuilder<'a> {
    type Target = TensorCreateInfoARM;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for TensorCreateInfoARMBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`TensorViewCreateInfoARM`] with lifetime-tied pNext safety.
pub struct TensorViewCreateInfoARMBuilder<'a> {
    inner: TensorViewCreateInfoARM,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl TensorViewCreateInfoARM {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> TensorViewCreateInfoARMBuilder<'a> {
        TensorViewCreateInfoARMBuilder {
            inner: TensorViewCreateInfoARM {
                s_type: StructureType::from_raw(1000460001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> TensorViewCreateInfoARMBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: TensorViewCreateFlagsARM) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn tensor(mut self, value: TensorARM) -> Self {
        self.inner.tensor = value;
        self
    }
    #[inline]
    pub fn format(mut self, value: Format) -> Self {
        self.inner.format = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`TensorViewCreateInfoARM`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsTensorViewCreateInfoARM>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for TensorViewCreateInfoARMBuilder<'a> {
    type Target = TensorViewCreateInfoARM;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for TensorViewCreateInfoARMBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`TensorMemoryRequirementsInfoARM`] with lifetime-tied pNext safety.
pub struct TensorMemoryRequirementsInfoARMBuilder<'a> {
    inner: TensorMemoryRequirementsInfoARM,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl TensorMemoryRequirementsInfoARM {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> TensorMemoryRequirementsInfoARMBuilder<'a> {
        TensorMemoryRequirementsInfoARMBuilder {
            inner: TensorMemoryRequirementsInfoARM {
                s_type: StructureType::from_raw(1000460007i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> TensorMemoryRequirementsInfoARMBuilder<'a> {
    #[inline]
    pub fn tensor(mut self, value: TensorARM) -> Self {
        self.inner.tensor = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`TensorMemoryRequirementsInfoARM`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsTensorMemoryRequirementsInfoARM>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for TensorMemoryRequirementsInfoARMBuilder<'a> {
    type Target = TensorMemoryRequirementsInfoARM;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for TensorMemoryRequirementsInfoARMBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`BindTensorMemoryInfoARM`] with lifetime-tied pNext safety.
pub struct BindTensorMemoryInfoARMBuilder<'a> {
    inner: BindTensorMemoryInfoARM,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl BindTensorMemoryInfoARM {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> BindTensorMemoryInfoARMBuilder<'a> {
        BindTensorMemoryInfoARMBuilder {
            inner: BindTensorMemoryInfoARM {
                s_type: StructureType::from_raw(1000460002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> BindTensorMemoryInfoARMBuilder<'a> {
    #[inline]
    pub fn tensor(mut self, value: TensorARM) -> Self {
        self.inner.tensor = value;
        self
    }
    #[inline]
    pub fn memory(mut self, value: DeviceMemory) -> Self {
        self.inner.memory = value;
        self
    }
    #[inline]
    pub fn memory_offset(mut self, value: u64) -> Self {
        self.inner.memory_offset = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`BindTensorMemoryInfoARM`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsBindTensorMemoryInfoARM>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for BindTensorMemoryInfoARMBuilder<'a> {
    type Target = BindTensorMemoryInfoARM;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for BindTensorMemoryInfoARMBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`WriteDescriptorSetTensorARM`] with lifetime-tied pNext safety.
pub struct WriteDescriptorSetTensorARMBuilder<'a> {
    inner: WriteDescriptorSetTensorARM,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl WriteDescriptorSetTensorARM {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> WriteDescriptorSetTensorARMBuilder<'a> {
        WriteDescriptorSetTensorARMBuilder {
            inner: WriteDescriptorSetTensorARM {
                s_type: StructureType::from_raw(1000460003i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> WriteDescriptorSetTensorARMBuilder<'a> {
    #[inline]
    pub fn tensor_view_count(mut self, value: u32) -> Self {
        self.inner.tensor_view_count = value;
        self
    }
    #[inline]
    pub fn tensor_views(mut self, slice: &'a [TensorViewARM]) -> Self {
        self.inner.tensor_view_count = slice.len() as u32;
        self.inner.p_tensor_views = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`WriteDescriptorSetTensorARM`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsWriteDescriptorSetTensorARM>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for WriteDescriptorSetTensorARMBuilder<'a> {
    type Target = WriteDescriptorSetTensorARM;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for WriteDescriptorSetTensorARMBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`TensorFormatPropertiesARM`] with lifetime-tied pNext safety.
pub struct TensorFormatPropertiesARMBuilder<'a> {
    inner: TensorFormatPropertiesARM,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl TensorFormatPropertiesARM {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> TensorFormatPropertiesARMBuilder<'a> {
        TensorFormatPropertiesARMBuilder {
            inner: TensorFormatPropertiesARM {
                s_type: StructureType::from_raw(1000460005i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> TensorFormatPropertiesARMBuilder<'a> {
    #[inline]
    pub fn optimal_tiling_tensor_features(mut self, value: FormatFeatureFlags2) -> Self {
        self.inner.optimal_tiling_tensor_features = value;
        self
    }
    #[inline]
    pub fn linear_tiling_tensor_features(mut self, value: FormatFeatureFlags2) -> Self {
        self.inner.linear_tiling_tensor_features = value;
        self
    }
}
impl<'a> core::ops::Deref for TensorFormatPropertiesARMBuilder<'a> {
    type Target = TensorFormatPropertiesARM;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for TensorFormatPropertiesARMBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceTensorPropertiesARM`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceTensorPropertiesARMBuilder<'a> {
    inner: PhysicalDeviceTensorPropertiesARM,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceTensorPropertiesARM {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceTensorPropertiesARMBuilder<'a> {
        PhysicalDeviceTensorPropertiesARMBuilder {
            inner: PhysicalDeviceTensorPropertiesARM {
                s_type: StructureType::from_raw(1000460004i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceTensorPropertiesARMBuilder<'a> {
    #[inline]
    pub fn max_tensor_dimension_count(mut self, value: u32) -> Self {
        self.inner.max_tensor_dimension_count = value;
        self
    }
    #[inline]
    pub fn max_tensor_elements(mut self, value: u64) -> Self {
        self.inner.max_tensor_elements = value;
        self
    }
    #[inline]
    pub fn max_per_dimension_tensor_elements(mut self, value: u64) -> Self {
        self.inner.max_per_dimension_tensor_elements = value;
        self
    }
    #[inline]
    pub fn max_tensor_stride(mut self, value: i64) -> Self {
        self.inner.max_tensor_stride = value;
        self
    }
    #[inline]
    pub fn max_tensor_size(mut self, value: u64) -> Self {
        self.inner.max_tensor_size = value;
        self
    }
    #[inline]
    pub fn max_tensor_shader_access_array_length(mut self, value: u32) -> Self {
        self.inner.max_tensor_shader_access_array_length = value;
        self
    }
    #[inline]
    pub fn max_tensor_shader_access_size(mut self, value: u32) -> Self {
        self.inner.max_tensor_shader_access_size = value;
        self
    }
    #[inline]
    pub fn max_descriptor_set_storage_tensors(mut self, value: u32) -> Self {
        self.inner.max_descriptor_set_storage_tensors = value;
        self
    }
    #[inline]
    pub fn max_per_stage_descriptor_set_storage_tensors(mut self, value: u32) -> Self {
        self.inner.max_per_stage_descriptor_set_storage_tensors = value;
        self
    }
    #[inline]
    pub fn max_descriptor_set_update_after_bind_storage_tensors(
        mut self,
        value: u32,
    ) -> Self {
        self.inner.max_descriptor_set_update_after_bind_storage_tensors = value;
        self
    }
    #[inline]
    pub fn max_per_stage_descriptor_update_after_bind_storage_tensors(
        mut self,
        value: u32,
    ) -> Self {
        self.inner.max_per_stage_descriptor_update_after_bind_storage_tensors = value;
        self
    }
    #[inline]
    pub fn shader_storage_tensor_array_non_uniform_indexing_native(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.shader_storage_tensor_array_non_uniform_indexing_native = value
            as u32;
        self
    }
    #[inline]
    pub fn shader_tensor_supported_stages(mut self, value: ShaderStageFlags) -> Self {
        self.inner.shader_tensor_supported_stages = value;
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceTensorPropertiesARMBuilder<'a> {
    type Target = PhysicalDeviceTensorPropertiesARM;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceTensorPropertiesARMBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`TensorMemoryBarrierARM`] with lifetime-tied pNext safety.
pub struct TensorMemoryBarrierARMBuilder<'a> {
    inner: TensorMemoryBarrierARM,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl TensorMemoryBarrierARM {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> TensorMemoryBarrierARMBuilder<'a> {
        TensorMemoryBarrierARMBuilder {
            inner: TensorMemoryBarrierARM {
                s_type: StructureType::from_raw(1000460008i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> TensorMemoryBarrierARMBuilder<'a> {
    #[inline]
    pub fn src_stage_mask(mut self, value: PipelineStageFlags2) -> Self {
        self.inner.src_stage_mask = value;
        self
    }
    #[inline]
    pub fn src_access_mask(mut self, value: AccessFlags2) -> Self {
        self.inner.src_access_mask = value;
        self
    }
    #[inline]
    pub fn dst_stage_mask(mut self, value: PipelineStageFlags2) -> Self {
        self.inner.dst_stage_mask = value;
        self
    }
    #[inline]
    pub fn dst_access_mask(mut self, value: AccessFlags2) -> Self {
        self.inner.dst_access_mask = value;
        self
    }
    #[inline]
    pub fn src_queue_family_index(mut self, value: u32) -> Self {
        self.inner.src_queue_family_index = value;
        self
    }
    #[inline]
    pub fn dst_queue_family_index(mut self, value: u32) -> Self {
        self.inner.dst_queue_family_index = value;
        self
    }
    #[inline]
    pub fn tensor(mut self, value: TensorARM) -> Self {
        self.inner.tensor = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`TensorMemoryBarrierARM`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsTensorMemoryBarrierARM>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for TensorMemoryBarrierARMBuilder<'a> {
    type Target = TensorMemoryBarrierARM;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for TensorMemoryBarrierARMBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`TensorDependencyInfoARM`] with lifetime-tied pNext safety.
pub struct TensorDependencyInfoARMBuilder<'a> {
    inner: TensorDependencyInfoARM,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl TensorDependencyInfoARM {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> TensorDependencyInfoARMBuilder<'a> {
        TensorDependencyInfoARMBuilder {
            inner: TensorDependencyInfoARM {
                s_type: StructureType::from_raw(1000460013i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> TensorDependencyInfoARMBuilder<'a> {
    #[inline]
    pub fn tensor_memory_barrier_count(mut self, value: u32) -> Self {
        self.inner.tensor_memory_barrier_count = value;
        self
    }
    #[inline]
    pub fn tensor_memory_barriers(mut self, value: &'a TensorMemoryBarrierARM) -> Self {
        self.inner.p_tensor_memory_barriers = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`TensorDependencyInfoARM`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsTensorDependencyInfoARM>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for TensorDependencyInfoARMBuilder<'a> {
    type Target = TensorDependencyInfoARM;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for TensorDependencyInfoARMBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceTensorFeaturesARM`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceTensorFeaturesARMBuilder<'a> {
    inner: PhysicalDeviceTensorFeaturesARM,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceTensorFeaturesARM {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceTensorFeaturesARMBuilder<'a> {
        PhysicalDeviceTensorFeaturesARMBuilder {
            inner: PhysicalDeviceTensorFeaturesARM {
                s_type: StructureType::from_raw(1000460009i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceTensorFeaturesARMBuilder<'a> {
    #[inline]
    pub fn tensor_non_packed(mut self, value: bool) -> Self {
        self.inner.tensor_non_packed = value as u32;
        self
    }
    #[inline]
    pub fn shader_tensor_access(mut self, value: bool) -> Self {
        self.inner.shader_tensor_access = value as u32;
        self
    }
    #[inline]
    pub fn shader_storage_tensor_array_dynamic_indexing(mut self, value: bool) -> Self {
        self.inner.shader_storage_tensor_array_dynamic_indexing = value as u32;
        self
    }
    #[inline]
    pub fn shader_storage_tensor_array_non_uniform_indexing(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.shader_storage_tensor_array_non_uniform_indexing = value as u32;
        self
    }
    #[inline]
    pub fn descriptor_binding_storage_tensor_update_after_bind(
        mut self,
        value: bool,
    ) -> Self {
        self.inner.descriptor_binding_storage_tensor_update_after_bind = value as u32;
        self
    }
    #[inline]
    pub fn tensors(mut self, value: bool) -> Self {
        self.inner.tensors = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceTensorFeaturesARM`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceTensorFeaturesARM>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceTensorFeaturesARMBuilder<'a> {
    type Target = PhysicalDeviceTensorFeaturesARM;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceTensorFeaturesARMBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DeviceTensorMemoryRequirementsARM`] with lifetime-tied pNext safety.
pub struct DeviceTensorMemoryRequirementsARMBuilder<'a> {
    inner: DeviceTensorMemoryRequirementsARM,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DeviceTensorMemoryRequirementsARM {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> DeviceTensorMemoryRequirementsARMBuilder<'a> {
        DeviceTensorMemoryRequirementsARMBuilder {
            inner: DeviceTensorMemoryRequirementsARM {
                s_type: StructureType::from_raw(1000460010i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DeviceTensorMemoryRequirementsARMBuilder<'a> {
    #[inline]
    pub fn create_info(mut self, value: &'a TensorCreateInfoARM) -> Self {
        self.inner.p_create_info = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`DeviceTensorMemoryRequirementsARM`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsDeviceTensorMemoryRequirementsARM>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for DeviceTensorMemoryRequirementsARMBuilder<'a> {
    type Target = DeviceTensorMemoryRequirementsARM;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for DeviceTensorMemoryRequirementsARMBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`CopyTensorInfoARM`] with lifetime-tied pNext safety.
pub struct CopyTensorInfoARMBuilder<'a> {
    inner: CopyTensorInfoARM,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl CopyTensorInfoARM {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> CopyTensorInfoARMBuilder<'a> {
        CopyTensorInfoARMBuilder {
            inner: CopyTensorInfoARM {
                s_type: StructureType::from_raw(1000460011i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> CopyTensorInfoARMBuilder<'a> {
    #[inline]
    pub fn src_tensor(mut self, value: TensorARM) -> Self {
        self.inner.src_tensor = value;
        self
    }
    #[inline]
    pub fn dst_tensor(mut self, value: TensorARM) -> Self {
        self.inner.dst_tensor = value;
        self
    }
    #[inline]
    pub fn regions(mut self, slice: &'a [TensorCopyARM]) -> Self {
        self.inner.region_count = slice.len() as u32;
        self.inner.p_regions = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`CopyTensorInfoARM`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsCopyTensorInfoARM>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for CopyTensorInfoARMBuilder<'a> {
    type Target = CopyTensorInfoARM;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for CopyTensorInfoARMBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`TensorCopyARM`] with lifetime-tied pNext safety.
pub struct TensorCopyARMBuilder<'a> {
    inner: TensorCopyARM,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl TensorCopyARM {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> TensorCopyARMBuilder<'a> {
        TensorCopyARMBuilder {
            inner: TensorCopyARM {
                s_type: StructureType::from_raw(1000460012i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> TensorCopyARMBuilder<'a> {
    #[inline]
    pub fn dimension_count(mut self, value: u32) -> Self {
        self.inner.dimension_count = value;
        self
    }
    #[inline]
    pub fn src_offset(mut self, slice: &'a [u64]) -> Self {
        self.inner.dimension_count = slice.len() as u32;
        self.inner.p_src_offset = slice.as_ptr();
        self
    }
    #[inline]
    pub fn dst_offset(mut self, slice: &'a [u64]) -> Self {
        self.inner.dimension_count = slice.len() as u32;
        self.inner.p_dst_offset = slice.as_ptr();
        self
    }
    #[inline]
    pub fn extent(mut self, slice: &'a [u64]) -> Self {
        self.inner.dimension_count = slice.len() as u32;
        self.inner.p_extent = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`TensorCopyARM`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsTensorCopyARM>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for TensorCopyARMBuilder<'a> {
    type Target = TensorCopyARM;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for TensorCopyARMBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`MemoryDedicatedAllocateInfoTensorARM`] with lifetime-tied pNext safety.
pub struct MemoryDedicatedAllocateInfoTensorARMBuilder<'a> {
    inner: MemoryDedicatedAllocateInfoTensorARM,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl MemoryDedicatedAllocateInfoTensorARM {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> MemoryDedicatedAllocateInfoTensorARMBuilder<'a> {
        MemoryDedicatedAllocateInfoTensorARMBuilder {
            inner: MemoryDedicatedAllocateInfoTensorARM {
                s_type: StructureType::from_raw(1000460014i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> MemoryDedicatedAllocateInfoTensorARMBuilder<'a> {
    #[inline]
    pub fn tensor(mut self, value: TensorARM) -> Self {
        self.inner.tensor = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`MemoryDedicatedAllocateInfoTensorARM`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsMemoryDedicatedAllocateInfoTensorARM>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for MemoryDedicatedAllocateInfoTensorARMBuilder<'a> {
    type Target = MemoryDedicatedAllocateInfoTensorARM;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for MemoryDedicatedAllocateInfoTensorARMBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceDescriptorBufferTensorPropertiesARM`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceDescriptorBufferTensorPropertiesARMBuilder<'a> {
    inner: PhysicalDeviceDescriptorBufferTensorPropertiesARM,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceDescriptorBufferTensorPropertiesARM {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceDescriptorBufferTensorPropertiesARMBuilder<
        'a,
    > {
        PhysicalDeviceDescriptorBufferTensorPropertiesARMBuilder {
            inner: PhysicalDeviceDescriptorBufferTensorPropertiesARM {
                s_type: StructureType::from_raw(1000460019i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceDescriptorBufferTensorPropertiesARMBuilder<'a> {
    #[inline]
    pub fn tensor_capture_replay_descriptor_data_size(mut self, value: usize) -> Self {
        self.inner.tensor_capture_replay_descriptor_data_size = value;
        self
    }
    #[inline]
    pub fn tensor_view_capture_replay_descriptor_data_size(
        mut self,
        value: usize,
    ) -> Self {
        self.inner.tensor_view_capture_replay_descriptor_data_size = value;
        self
    }
    #[inline]
    pub fn tensor_descriptor_size(mut self, value: usize) -> Self {
        self.inner.tensor_descriptor_size = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceDescriptorBufferTensorPropertiesARM`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceDescriptorBufferTensorPropertiesARM>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDeviceDescriptorBufferTensorPropertiesARMBuilder<'a> {
    type Target = PhysicalDeviceDescriptorBufferTensorPropertiesARM;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceDescriptorBufferTensorPropertiesARMBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceDescriptorBufferTensorFeaturesARM`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceDescriptorBufferTensorFeaturesARMBuilder<'a> {
    inner: PhysicalDeviceDescriptorBufferTensorFeaturesARM,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceDescriptorBufferTensorFeaturesARM {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceDescriptorBufferTensorFeaturesARMBuilder<'a> {
        PhysicalDeviceDescriptorBufferTensorFeaturesARMBuilder {
            inner: PhysicalDeviceDescriptorBufferTensorFeaturesARM {
                s_type: StructureType::from_raw(1000460018i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceDescriptorBufferTensorFeaturesARMBuilder<'a> {
    #[inline]
    pub fn descriptor_buffer_tensor_descriptors(mut self, value: bool) -> Self {
        self.inner.descriptor_buffer_tensor_descriptors = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceDescriptorBufferTensorFeaturesARM`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceDescriptorBufferTensorFeaturesARM>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDeviceDescriptorBufferTensorFeaturesARMBuilder<'a> {
    type Target = PhysicalDeviceDescriptorBufferTensorFeaturesARM;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceDescriptorBufferTensorFeaturesARMBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`TensorCaptureDescriptorDataInfoARM`] with lifetime-tied pNext safety.
pub struct TensorCaptureDescriptorDataInfoARMBuilder<'a> {
    inner: TensorCaptureDescriptorDataInfoARM,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl TensorCaptureDescriptorDataInfoARM {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> TensorCaptureDescriptorDataInfoARMBuilder<'a> {
        TensorCaptureDescriptorDataInfoARMBuilder {
            inner: TensorCaptureDescriptorDataInfoARM {
                s_type: StructureType::from_raw(1000460021i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> TensorCaptureDescriptorDataInfoARMBuilder<'a> {
    #[inline]
    pub fn tensor(mut self, value: TensorARM) -> Self {
        self.inner.tensor = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`TensorCaptureDescriptorDataInfoARM`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsTensorCaptureDescriptorDataInfoARM>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for TensorCaptureDescriptorDataInfoARMBuilder<'a> {
    type Target = TensorCaptureDescriptorDataInfoARM;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for TensorCaptureDescriptorDataInfoARMBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`TensorViewCaptureDescriptorDataInfoARM`] with lifetime-tied pNext safety.
pub struct TensorViewCaptureDescriptorDataInfoARMBuilder<'a> {
    inner: TensorViewCaptureDescriptorDataInfoARM,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl TensorViewCaptureDescriptorDataInfoARM {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> TensorViewCaptureDescriptorDataInfoARMBuilder<'a> {
        TensorViewCaptureDescriptorDataInfoARMBuilder {
            inner: TensorViewCaptureDescriptorDataInfoARM {
                s_type: StructureType::from_raw(1000460022i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> TensorViewCaptureDescriptorDataInfoARMBuilder<'a> {
    #[inline]
    pub fn tensor_view(mut self, value: TensorViewARM) -> Self {
        self.inner.tensor_view = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`TensorViewCaptureDescriptorDataInfoARM`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsTensorViewCaptureDescriptorDataInfoARM>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for TensorViewCaptureDescriptorDataInfoARMBuilder<'a> {
    type Target = TensorViewCaptureDescriptorDataInfoARM;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for TensorViewCaptureDescriptorDataInfoARMBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DescriptorGetTensorInfoARM`] with lifetime-tied pNext safety.
pub struct DescriptorGetTensorInfoARMBuilder<'a> {
    inner: DescriptorGetTensorInfoARM,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DescriptorGetTensorInfoARM {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> DescriptorGetTensorInfoARMBuilder<'a> {
        DescriptorGetTensorInfoARMBuilder {
            inner: DescriptorGetTensorInfoARM {
                s_type: StructureType::from_raw(1000460020i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DescriptorGetTensorInfoARMBuilder<'a> {
    #[inline]
    pub fn tensor_view(mut self, value: TensorViewARM) -> Self {
        self.inner.tensor_view = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`DescriptorGetTensorInfoARM`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsDescriptorGetTensorInfoARM>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for DescriptorGetTensorInfoARMBuilder<'a> {
    type Target = DescriptorGetTensorInfoARM;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for DescriptorGetTensorInfoARMBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`FrameBoundaryTensorsARM`] with lifetime-tied pNext safety.
pub struct FrameBoundaryTensorsARMBuilder<'a> {
    inner: FrameBoundaryTensorsARM,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl FrameBoundaryTensorsARM {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> FrameBoundaryTensorsARMBuilder<'a> {
        FrameBoundaryTensorsARMBuilder {
            inner: FrameBoundaryTensorsARM {
                s_type: StructureType::from_raw(1000460023i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> FrameBoundaryTensorsARMBuilder<'a> {
    #[inline]
    pub fn tensors(mut self, slice: &'a [TensorARM]) -> Self {
        self.inner.tensor_count = slice.len() as u32;
        self.inner.p_tensors = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`FrameBoundaryTensorsARM`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsFrameBoundaryTensorsARM>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for FrameBoundaryTensorsARMBuilder<'a> {
    type Target = FrameBoundaryTensorsARM;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for FrameBoundaryTensorsARMBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceExternalTensorInfoARM`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceExternalTensorInfoARMBuilder<'a> {
    inner: PhysicalDeviceExternalTensorInfoARM,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceExternalTensorInfoARM {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceExternalTensorInfoARMBuilder<'a> {
        PhysicalDeviceExternalTensorInfoARMBuilder {
            inner: PhysicalDeviceExternalTensorInfoARM {
                s_type: StructureType::from_raw(1000460015i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceExternalTensorInfoARMBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: TensorCreateFlagsARM) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn description(mut self, value: &'a TensorDescriptionARM) -> Self {
        self.inner.p_description = value;
        self
    }
    #[inline]
    pub fn handle_type(mut self, value: ExternalMemoryHandleTypeFlagBits) -> Self {
        self.inner.handle_type = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceExternalTensorInfoARM`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceExternalTensorInfoARM>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceExternalTensorInfoARMBuilder<'a> {
    type Target = PhysicalDeviceExternalTensorInfoARM;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceExternalTensorInfoARMBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ExternalTensorPropertiesARM`] with lifetime-tied pNext safety.
pub struct ExternalTensorPropertiesARMBuilder<'a> {
    inner: ExternalTensorPropertiesARM,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ExternalTensorPropertiesARM {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ExternalTensorPropertiesARMBuilder<'a> {
        ExternalTensorPropertiesARMBuilder {
            inner: ExternalTensorPropertiesARM {
                s_type: StructureType::from_raw(1000460016i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ExternalTensorPropertiesARMBuilder<'a> {
    #[inline]
    pub fn external_memory_properties(
        mut self,
        value: ExternalMemoryProperties,
    ) -> Self {
        self.inner.external_memory_properties = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`ExternalTensorPropertiesARM`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsExternalTensorPropertiesARM>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for ExternalTensorPropertiesARMBuilder<'a> {
    type Target = ExternalTensorPropertiesARM;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ExternalTensorPropertiesARMBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ExternalMemoryTensorCreateInfoARM`] with lifetime-tied pNext safety.
pub struct ExternalMemoryTensorCreateInfoARMBuilder<'a> {
    inner: ExternalMemoryTensorCreateInfoARM,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ExternalMemoryTensorCreateInfoARM {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ExternalMemoryTensorCreateInfoARMBuilder<'a> {
        ExternalMemoryTensorCreateInfoARMBuilder {
            inner: ExternalMemoryTensorCreateInfoARM {
                s_type: StructureType::from_raw(1000460017i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ExternalMemoryTensorCreateInfoARMBuilder<'a> {
    #[inline]
    pub fn handle_types(mut self, value: ExternalMemoryHandleTypeFlags) -> Self {
        self.inner.handle_types = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`ExternalMemoryTensorCreateInfoARM`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsExternalMemoryTensorCreateInfoARM>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for ExternalMemoryTensorCreateInfoARMBuilder<'a> {
    type Target = ExternalMemoryTensorCreateInfoARM;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ExternalMemoryTensorCreateInfoARMBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceShaderFloat8FeaturesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceShaderFloat8FeaturesEXTBuilder<'a> {
    inner: PhysicalDeviceShaderFloat8FeaturesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceShaderFloat8FeaturesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceShaderFloat8FeaturesEXTBuilder<'a> {
        PhysicalDeviceShaderFloat8FeaturesEXTBuilder {
            inner: PhysicalDeviceShaderFloat8FeaturesEXT {
                s_type: StructureType::from_raw(1000567000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceShaderFloat8FeaturesEXTBuilder<'a> {
    #[inline]
    pub fn shader_float8(mut self, value: bool) -> Self {
        self.inner.shader_float8 = value as u32;
        self
    }
    #[inline]
    pub fn shader_float8_cooperative_matrix(mut self, value: bool) -> Self {
        self.inner.shader_float8_cooperative_matrix = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceShaderFloat8FeaturesEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceShaderFloat8FeaturesEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceShaderFloat8FeaturesEXTBuilder<'a> {
    type Target = PhysicalDeviceShaderFloat8FeaturesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceShaderFloat8FeaturesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`SurfaceCreateInfoOHOS`] with lifetime-tied pNext safety.
pub struct SurfaceCreateInfoOHOSBuilder<'a> {
    inner: SurfaceCreateInfoOHOS,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl SurfaceCreateInfoOHOS {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> SurfaceCreateInfoOHOSBuilder<'a> {
        SurfaceCreateInfoOHOSBuilder {
            inner: SurfaceCreateInfoOHOS {
                s_type: StructureType::from_raw(1000685000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> SurfaceCreateInfoOHOSBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: SurfaceCreateFlagsOHOS) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn window(mut self, value: *mut core::ffi::c_void) -> Self {
        self.inner.window = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`SurfaceCreateInfoOHOS`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsSurfaceCreateInfoOHOS>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for SurfaceCreateInfoOHOSBuilder<'a> {
    type Target = SurfaceCreateInfoOHOS;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for SurfaceCreateInfoOHOSBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceDataGraphFeaturesARM`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceDataGraphFeaturesARMBuilder<'a> {
    inner: PhysicalDeviceDataGraphFeaturesARM,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceDataGraphFeaturesARM {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceDataGraphFeaturesARMBuilder<'a> {
        PhysicalDeviceDataGraphFeaturesARMBuilder {
            inner: PhysicalDeviceDataGraphFeaturesARM {
                s_type: StructureType::from_raw(1000507006i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceDataGraphFeaturesARMBuilder<'a> {
    #[inline]
    pub fn data_graph(mut self, value: bool) -> Self {
        self.inner.data_graph = value as u32;
        self
    }
    #[inline]
    pub fn data_graph_update_after_bind(mut self, value: bool) -> Self {
        self.inner.data_graph_update_after_bind = value as u32;
        self
    }
    #[inline]
    pub fn data_graph_specialization_constants(mut self, value: bool) -> Self {
        self.inner.data_graph_specialization_constants = value as u32;
        self
    }
    #[inline]
    pub fn data_graph_descriptor_buffer(mut self, value: bool) -> Self {
        self.inner.data_graph_descriptor_buffer = value as u32;
        self
    }
    #[inline]
    pub fn data_graph_shader_module(mut self, value: bool) -> Self {
        self.inner.data_graph_shader_module = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceDataGraphFeaturesARM`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceDataGraphFeaturesARM>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceDataGraphFeaturesARMBuilder<'a> {
    type Target = PhysicalDeviceDataGraphFeaturesARM;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceDataGraphFeaturesARMBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM`] with lifetime-tied pNext safety.
pub struct DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARMBuilder<'a> {
    inner: DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARMBuilder<
        'a,
    > {
        DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARMBuilder {
            inner: DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM {
                s_type: StructureType::from_raw(1000507015i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARMBuilder<'a> {
    #[inline]
    pub fn dimension(mut self, value: u32) -> Self {
        self.inner.dimension = value;
        self
    }
    #[inline]
    pub fn zero_count(mut self, value: u32) -> Self {
        self.inner.zero_count = value;
        self
    }
    #[inline]
    pub fn group_size(mut self, value: u32) -> Self {
        self.inner.group_size = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<
        T: ExtendsDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM,
    >(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref
for DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARMBuilder<'a> {
    type Target = DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARMBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DataGraphPipelineConstantARM`] with lifetime-tied pNext safety.
pub struct DataGraphPipelineConstantARMBuilder<'a> {
    inner: DataGraphPipelineConstantARM,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DataGraphPipelineConstantARM {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> DataGraphPipelineConstantARMBuilder<'a> {
        DataGraphPipelineConstantARMBuilder {
            inner: DataGraphPipelineConstantARM {
                s_type: StructureType::from_raw(1000507003i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DataGraphPipelineConstantARMBuilder<'a> {
    #[inline]
    pub fn id(mut self, value: u32) -> Self {
        self.inner.id = value;
        self
    }
    #[inline]
    pub fn constant_data(mut self, value: *const core::ffi::c_void) -> Self {
        self.inner.p_constant_data = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`DataGraphPipelineConstantARM`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsDataGraphPipelineConstantARM>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for DataGraphPipelineConstantARMBuilder<'a> {
    type Target = DataGraphPipelineConstantARM;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for DataGraphPipelineConstantARMBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DataGraphPipelineResourceInfoARM`] with lifetime-tied pNext safety.
pub struct DataGraphPipelineResourceInfoARMBuilder<'a> {
    inner: DataGraphPipelineResourceInfoARM,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DataGraphPipelineResourceInfoARM {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> DataGraphPipelineResourceInfoARMBuilder<'a> {
        DataGraphPipelineResourceInfoARMBuilder {
            inner: DataGraphPipelineResourceInfoARM {
                s_type: StructureType::from_raw(1000507002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DataGraphPipelineResourceInfoARMBuilder<'a> {
    #[inline]
    pub fn descriptor_set(mut self, value: u32) -> Self {
        self.inner.descriptor_set = value;
        self
    }
    #[inline]
    pub fn binding(mut self, value: u32) -> Self {
        self.inner.binding = value;
        self
    }
    #[inline]
    pub fn array_element(mut self, value: u32) -> Self {
        self.inner.array_element = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`DataGraphPipelineResourceInfoARM`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsDataGraphPipelineResourceInfoARM>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for DataGraphPipelineResourceInfoARMBuilder<'a> {
    type Target = DataGraphPipelineResourceInfoARM;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for DataGraphPipelineResourceInfoARMBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DataGraphPipelineCompilerControlCreateInfoARM`] with lifetime-tied pNext safety.
pub struct DataGraphPipelineCompilerControlCreateInfoARMBuilder<'a> {
    inner: DataGraphPipelineCompilerControlCreateInfoARM,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DataGraphPipelineCompilerControlCreateInfoARM {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> DataGraphPipelineCompilerControlCreateInfoARMBuilder<'a> {
        DataGraphPipelineCompilerControlCreateInfoARMBuilder {
            inner: DataGraphPipelineCompilerControlCreateInfoARM {
                s_type: StructureType::from_raw(1000507010i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DataGraphPipelineCompilerControlCreateInfoARMBuilder<'a> {
    #[inline]
    pub fn vendor_options(mut self, value: &'a core::ffi::CStr) -> Self {
        self.inner.p_vendor_options = value.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`DataGraphPipelineCompilerControlCreateInfoARM`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsDataGraphPipelineCompilerControlCreateInfoARM>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for DataGraphPipelineCompilerControlCreateInfoARMBuilder<'a> {
    type Target = DataGraphPipelineCompilerControlCreateInfoARM;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for DataGraphPipelineCompilerControlCreateInfoARMBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DataGraphPipelineCreateInfoARM`] with lifetime-tied pNext safety.
pub struct DataGraphPipelineCreateInfoARMBuilder<'a> {
    inner: DataGraphPipelineCreateInfoARM,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DataGraphPipelineCreateInfoARM {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> DataGraphPipelineCreateInfoARMBuilder<'a> {
        DataGraphPipelineCreateInfoARMBuilder {
            inner: DataGraphPipelineCreateInfoARM {
                s_type: StructureType::from_raw(1000507000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DataGraphPipelineCreateInfoARMBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: PipelineCreateFlags2KHR) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn layout(mut self, value: PipelineLayout) -> Self {
        self.inner.layout = value;
        self
    }
    #[inline]
    pub fn resource_infos(
        mut self,
        slice: &'a [DataGraphPipelineResourceInfoARM],
    ) -> Self {
        self.inner.resource_info_count = slice.len() as u32;
        self.inner.p_resource_infos = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`DataGraphPipelineCreateInfoARM`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsDataGraphPipelineCreateInfoARM>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for DataGraphPipelineCreateInfoARMBuilder<'a> {
    type Target = DataGraphPipelineCreateInfoARM;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for DataGraphPipelineCreateInfoARMBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DataGraphPipelineShaderModuleCreateInfoARM`] with lifetime-tied pNext safety.
pub struct DataGraphPipelineShaderModuleCreateInfoARMBuilder<'a> {
    inner: DataGraphPipelineShaderModuleCreateInfoARM,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DataGraphPipelineShaderModuleCreateInfoARM {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> DataGraphPipelineShaderModuleCreateInfoARMBuilder<'a> {
        DataGraphPipelineShaderModuleCreateInfoARMBuilder {
            inner: DataGraphPipelineShaderModuleCreateInfoARM {
                s_type: StructureType::from_raw(1000507007i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DataGraphPipelineShaderModuleCreateInfoARMBuilder<'a> {
    #[inline]
    pub fn module(mut self, value: ShaderModule) -> Self {
        self.inner.module = value;
        self
    }
    #[inline]
    pub fn name(mut self, value: &'a core::ffi::CStr) -> Self {
        self.inner.p_name = value.as_ptr();
        self
    }
    #[inline]
    pub fn specialization_info(mut self, value: &'a SpecializationInfo) -> Self {
        self.inner.p_specialization_info = value;
        self
    }
    #[inline]
    pub fn constant_count(mut self, value: u32) -> Self {
        self.inner.constant_count = value;
        self
    }
    #[inline]
    pub fn constants(mut self, slice: &'a [DataGraphPipelineConstantARM]) -> Self {
        self.inner.constant_count = slice.len() as u32;
        self.inner.p_constants = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`DataGraphPipelineShaderModuleCreateInfoARM`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsDataGraphPipelineShaderModuleCreateInfoARM>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for DataGraphPipelineShaderModuleCreateInfoARMBuilder<'a> {
    type Target = DataGraphPipelineShaderModuleCreateInfoARM;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for DataGraphPipelineShaderModuleCreateInfoARMBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DataGraphPipelineSessionCreateInfoARM`] with lifetime-tied pNext safety.
pub struct DataGraphPipelineSessionCreateInfoARMBuilder<'a> {
    inner: DataGraphPipelineSessionCreateInfoARM,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DataGraphPipelineSessionCreateInfoARM {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> DataGraphPipelineSessionCreateInfoARMBuilder<'a> {
        DataGraphPipelineSessionCreateInfoARMBuilder {
            inner: DataGraphPipelineSessionCreateInfoARM {
                s_type: StructureType::from_raw(1000507001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DataGraphPipelineSessionCreateInfoARMBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: DataGraphPipelineSessionCreateFlagsARM) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn data_graph_pipeline(mut self, value: Pipeline) -> Self {
        self.inner.data_graph_pipeline = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`DataGraphPipelineSessionCreateInfoARM`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsDataGraphPipelineSessionCreateInfoARM>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for DataGraphPipelineSessionCreateInfoARMBuilder<'a> {
    type Target = DataGraphPipelineSessionCreateInfoARM;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for DataGraphPipelineSessionCreateInfoARMBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DataGraphPipelineSessionBindPointRequirementsInfoARM`] with lifetime-tied pNext safety.
pub struct DataGraphPipelineSessionBindPointRequirementsInfoARMBuilder<'a> {
    inner: DataGraphPipelineSessionBindPointRequirementsInfoARM,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DataGraphPipelineSessionBindPointRequirementsInfoARM {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> DataGraphPipelineSessionBindPointRequirementsInfoARMBuilder<
        'a,
    > {
        DataGraphPipelineSessionBindPointRequirementsInfoARMBuilder {
            inner: DataGraphPipelineSessionBindPointRequirementsInfoARM {
                s_type: StructureType::from_raw(1000507011i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DataGraphPipelineSessionBindPointRequirementsInfoARMBuilder<'a> {
    #[inline]
    pub fn session(mut self, value: DataGraphPipelineSessionARM) -> Self {
        self.inner.session = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`DataGraphPipelineSessionBindPointRequirementsInfoARM`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsDataGraphPipelineSessionBindPointRequirementsInfoARM>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref
for DataGraphPipelineSessionBindPointRequirementsInfoARMBuilder<'a> {
    type Target = DataGraphPipelineSessionBindPointRequirementsInfoARM;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for DataGraphPipelineSessionBindPointRequirementsInfoARMBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DataGraphPipelineSessionBindPointRequirementARM`] with lifetime-tied pNext safety.
pub struct DataGraphPipelineSessionBindPointRequirementARMBuilder<'a> {
    inner: DataGraphPipelineSessionBindPointRequirementARM,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DataGraphPipelineSessionBindPointRequirementARM {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> DataGraphPipelineSessionBindPointRequirementARMBuilder<'a> {
        DataGraphPipelineSessionBindPointRequirementARMBuilder {
            inner: DataGraphPipelineSessionBindPointRequirementARM {
                s_type: StructureType::from_raw(1000507012i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DataGraphPipelineSessionBindPointRequirementARMBuilder<'a> {
    #[inline]
    pub fn bind_point(mut self, value: DataGraphPipelineSessionBindPointARM) -> Self {
        self.inner.bind_point = value;
        self
    }
    #[inline]
    pub fn bind_point_type(
        mut self,
        value: DataGraphPipelineSessionBindPointTypeARM,
    ) -> Self {
        self.inner.bind_point_type = value;
        self
    }
    #[inline]
    pub fn num_objects(mut self, value: u32) -> Self {
        self.inner.num_objects = value;
        self
    }
}
impl<'a> core::ops::Deref
for DataGraphPipelineSessionBindPointRequirementARMBuilder<'a> {
    type Target = DataGraphPipelineSessionBindPointRequirementARM;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for DataGraphPipelineSessionBindPointRequirementARMBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DataGraphPipelineSessionMemoryRequirementsInfoARM`] with lifetime-tied pNext safety.
pub struct DataGraphPipelineSessionMemoryRequirementsInfoARMBuilder<'a> {
    inner: DataGraphPipelineSessionMemoryRequirementsInfoARM,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DataGraphPipelineSessionMemoryRequirementsInfoARM {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> DataGraphPipelineSessionMemoryRequirementsInfoARMBuilder<
        'a,
    > {
        DataGraphPipelineSessionMemoryRequirementsInfoARMBuilder {
            inner: DataGraphPipelineSessionMemoryRequirementsInfoARM {
                s_type: StructureType::from_raw(1000507004i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DataGraphPipelineSessionMemoryRequirementsInfoARMBuilder<'a> {
    #[inline]
    pub fn session(mut self, value: DataGraphPipelineSessionARM) -> Self {
        self.inner.session = value;
        self
    }
    #[inline]
    pub fn bind_point(mut self, value: DataGraphPipelineSessionBindPointARM) -> Self {
        self.inner.bind_point = value;
        self
    }
    #[inline]
    pub fn object_index(mut self, value: u32) -> Self {
        self.inner.object_index = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`DataGraphPipelineSessionMemoryRequirementsInfoARM`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsDataGraphPipelineSessionMemoryRequirementsInfoARM>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref
for DataGraphPipelineSessionMemoryRequirementsInfoARMBuilder<'a> {
    type Target = DataGraphPipelineSessionMemoryRequirementsInfoARM;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for DataGraphPipelineSessionMemoryRequirementsInfoARMBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`BindDataGraphPipelineSessionMemoryInfoARM`] with lifetime-tied pNext safety.
pub struct BindDataGraphPipelineSessionMemoryInfoARMBuilder<'a> {
    inner: BindDataGraphPipelineSessionMemoryInfoARM,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl BindDataGraphPipelineSessionMemoryInfoARM {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> BindDataGraphPipelineSessionMemoryInfoARMBuilder<'a> {
        BindDataGraphPipelineSessionMemoryInfoARMBuilder {
            inner: BindDataGraphPipelineSessionMemoryInfoARM {
                s_type: StructureType::from_raw(1000507005i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> BindDataGraphPipelineSessionMemoryInfoARMBuilder<'a> {
    #[inline]
    pub fn session(mut self, value: DataGraphPipelineSessionARM) -> Self {
        self.inner.session = value;
        self
    }
    #[inline]
    pub fn bind_point(mut self, value: DataGraphPipelineSessionBindPointARM) -> Self {
        self.inner.bind_point = value;
        self
    }
    #[inline]
    pub fn object_index(mut self, value: u32) -> Self {
        self.inner.object_index = value;
        self
    }
    #[inline]
    pub fn memory(mut self, value: DeviceMemory) -> Self {
        self.inner.memory = value;
        self
    }
    #[inline]
    pub fn memory_offset(mut self, value: u64) -> Self {
        self.inner.memory_offset = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`BindDataGraphPipelineSessionMemoryInfoARM`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsBindDataGraphPipelineSessionMemoryInfoARM>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for BindDataGraphPipelineSessionMemoryInfoARMBuilder<'a> {
    type Target = BindDataGraphPipelineSessionMemoryInfoARM;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for BindDataGraphPipelineSessionMemoryInfoARMBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DataGraphPipelineInfoARM`] with lifetime-tied pNext safety.
pub struct DataGraphPipelineInfoARMBuilder<'a> {
    inner: DataGraphPipelineInfoARM,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DataGraphPipelineInfoARM {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> DataGraphPipelineInfoARMBuilder<'a> {
        DataGraphPipelineInfoARMBuilder {
            inner: DataGraphPipelineInfoARM {
                s_type: StructureType::from_raw(1000507009i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DataGraphPipelineInfoARMBuilder<'a> {
    #[inline]
    pub fn data_graph_pipeline(mut self, value: Pipeline) -> Self {
        self.inner.data_graph_pipeline = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`DataGraphPipelineInfoARM`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsDataGraphPipelineInfoARM>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for DataGraphPipelineInfoARMBuilder<'a> {
    type Target = DataGraphPipelineInfoARM;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for DataGraphPipelineInfoARMBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DataGraphPipelinePropertyQueryResultARM`] with lifetime-tied pNext safety.
pub struct DataGraphPipelinePropertyQueryResultARMBuilder<'a> {
    inner: DataGraphPipelinePropertyQueryResultARM,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DataGraphPipelinePropertyQueryResultARM {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> DataGraphPipelinePropertyQueryResultARMBuilder<'a> {
        DataGraphPipelinePropertyQueryResultARMBuilder {
            inner: DataGraphPipelinePropertyQueryResultARM {
                s_type: StructureType::from_raw(1000507008i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DataGraphPipelinePropertyQueryResultARMBuilder<'a> {
    #[inline]
    pub fn property(mut self, value: DataGraphPipelinePropertyARM) -> Self {
        self.inner.property = value;
        self
    }
    #[inline]
    pub fn is_text(mut self, value: bool) -> Self {
        self.inner.is_text = value as u32;
        self
    }
    #[inline]
    pub fn data_size(mut self, value: usize) -> Self {
        self.inner.data_size = value;
        self
    }
    #[inline]
    pub fn data(mut self, slice: &'a mut [core::ffi::c_void]) -> Self {
        self.inner.data_size = slice.len();
        self.inner.p_data = slice.as_mut_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`DataGraphPipelinePropertyQueryResultARM`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsDataGraphPipelinePropertyQueryResultARM>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for DataGraphPipelinePropertyQueryResultARMBuilder<'a> {
    type Target = DataGraphPipelinePropertyQueryResultARM;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for DataGraphPipelinePropertyQueryResultARMBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DataGraphPipelineIdentifierCreateInfoARM`] with lifetime-tied pNext safety.
pub struct DataGraphPipelineIdentifierCreateInfoARMBuilder<'a> {
    inner: DataGraphPipelineIdentifierCreateInfoARM,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DataGraphPipelineIdentifierCreateInfoARM {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> DataGraphPipelineIdentifierCreateInfoARMBuilder<'a> {
        DataGraphPipelineIdentifierCreateInfoARMBuilder {
            inner: DataGraphPipelineIdentifierCreateInfoARM {
                s_type: StructureType::from_raw(1000507013i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DataGraphPipelineIdentifierCreateInfoARMBuilder<'a> {
    #[inline]
    pub fn identifier(mut self, slice: &'a [u8]) -> Self {
        self.inner.identifier_size = slice.len() as u32;
        self.inner.p_identifier = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`DataGraphPipelineIdentifierCreateInfoARM`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsDataGraphPipelineIdentifierCreateInfoARM>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for DataGraphPipelineIdentifierCreateInfoARMBuilder<'a> {
    type Target = DataGraphPipelineIdentifierCreateInfoARM;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for DataGraphPipelineIdentifierCreateInfoARMBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DataGraphPipelineDispatchInfoARM`] with lifetime-tied pNext safety.
pub struct DataGraphPipelineDispatchInfoARMBuilder<'a> {
    inner: DataGraphPipelineDispatchInfoARM,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DataGraphPipelineDispatchInfoARM {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> DataGraphPipelineDispatchInfoARMBuilder<'a> {
        DataGraphPipelineDispatchInfoARMBuilder {
            inner: DataGraphPipelineDispatchInfoARM {
                s_type: StructureType::from_raw(1000507014i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DataGraphPipelineDispatchInfoARMBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: DataGraphPipelineDispatchFlagsARM) -> Self {
        self.inner.flags = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`DataGraphPipelineDispatchInfoARM`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsDataGraphPipelineDispatchInfoARM>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for DataGraphPipelineDispatchInfoARMBuilder<'a> {
    type Target = DataGraphPipelineDispatchInfoARM;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for DataGraphPipelineDispatchInfoARMBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceDataGraphProcessingEngineARM`].
pub struct PhysicalDeviceDataGraphProcessingEngineARMBuilder {
    inner: PhysicalDeviceDataGraphProcessingEngineARM,
}
impl PhysicalDeviceDataGraphProcessingEngineARM {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> PhysicalDeviceDataGraphProcessingEngineARMBuilder {
        PhysicalDeviceDataGraphProcessingEngineARMBuilder {
            inner: PhysicalDeviceDataGraphProcessingEngineARM {
                ..Default::default()
            },
        }
    }
}
impl PhysicalDeviceDataGraphProcessingEngineARMBuilder {
    #[inline]
    pub fn r#type(
        mut self,
        value: PhysicalDeviceDataGraphProcessingEngineTypeARM,
    ) -> Self {
        self.inner.r#type = value;
        self
    }
    #[inline]
    pub fn is_foreign(mut self, value: bool) -> Self {
        self.inner.is_foreign = value as u32;
        self
    }
}
impl core::ops::Deref for PhysicalDeviceDataGraphProcessingEngineARMBuilder {
    type Target = PhysicalDeviceDataGraphProcessingEngineARM;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for PhysicalDeviceDataGraphProcessingEngineARMBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceDataGraphOperationSupportARM`].
pub struct PhysicalDeviceDataGraphOperationSupportARMBuilder {
    inner: PhysicalDeviceDataGraphOperationSupportARM,
}
impl PhysicalDeviceDataGraphOperationSupportARM {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> PhysicalDeviceDataGraphOperationSupportARMBuilder {
        PhysicalDeviceDataGraphOperationSupportARMBuilder {
            inner: PhysicalDeviceDataGraphOperationSupportARM {
                ..Default::default()
            },
        }
    }
}
impl PhysicalDeviceDataGraphOperationSupportARMBuilder {
    #[inline]
    pub fn operation_type(
        mut self,
        value: PhysicalDeviceDataGraphOperationTypeARM,
    ) -> Self {
        self.inner.operation_type = value;
        self
    }
    #[inline]
    pub fn name(
        mut self,
        value: crate::StringArray<
            { MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM as usize },
        >,
    ) -> Self {
        self.inner.name = value;
        self
    }
    #[inline]
    pub fn version(mut self, value: u32) -> Self {
        self.inner.version = value;
        self
    }
}
impl core::ops::Deref for PhysicalDeviceDataGraphOperationSupportARMBuilder {
    type Target = PhysicalDeviceDataGraphOperationSupportARM;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for PhysicalDeviceDataGraphOperationSupportARMBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`QueueFamilyDataGraphPropertiesARM`] with lifetime-tied pNext safety.
pub struct QueueFamilyDataGraphPropertiesARMBuilder<'a> {
    inner: QueueFamilyDataGraphPropertiesARM,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl QueueFamilyDataGraphPropertiesARM {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> QueueFamilyDataGraphPropertiesARMBuilder<'a> {
        QueueFamilyDataGraphPropertiesARMBuilder {
            inner: QueueFamilyDataGraphPropertiesARM {
                s_type: StructureType::from_raw(1000507018i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> QueueFamilyDataGraphPropertiesARMBuilder<'a> {
    #[inline]
    pub fn engine(mut self, value: PhysicalDeviceDataGraphProcessingEngineARM) -> Self {
        self.inner.engine = value;
        self
    }
    #[inline]
    pub fn operation(
        mut self,
        value: PhysicalDeviceDataGraphOperationSupportARM,
    ) -> Self {
        self.inner.operation = value;
        self
    }
}
impl<'a> core::ops::Deref for QueueFamilyDataGraphPropertiesARMBuilder<'a> {
    type Target = QueueFamilyDataGraphPropertiesARM;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for QueueFamilyDataGraphPropertiesARMBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARMBuilder<'a> {
    inner: PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARMBuilder<
        'a,
    > {
        PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARMBuilder {
            inner: PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM {
                s_type: StructureType::from_raw(1000507019i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARMBuilder<'a> {
    #[inline]
    pub fn queue_family_index(mut self, value: u32) -> Self {
        self.inner.queue_family_index = value;
        self
    }
    #[inline]
    pub fn engine_type(
        mut self,
        value: PhysicalDeviceDataGraphProcessingEngineTypeARM,
    ) -> Self {
        self.inner.engine_type = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<
        T: ExtendsPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM,
    >(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARMBuilder<'a> {
    type Target = PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARMBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`QueueFamilyDataGraphProcessingEnginePropertiesARM`] with lifetime-tied pNext safety.
pub struct QueueFamilyDataGraphProcessingEnginePropertiesARMBuilder<'a> {
    inner: QueueFamilyDataGraphProcessingEnginePropertiesARM,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl QueueFamilyDataGraphProcessingEnginePropertiesARM {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> QueueFamilyDataGraphProcessingEnginePropertiesARMBuilder<
        'a,
    > {
        QueueFamilyDataGraphProcessingEnginePropertiesARMBuilder {
            inner: QueueFamilyDataGraphProcessingEnginePropertiesARM {
                s_type: StructureType::from_raw(1000507017i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> QueueFamilyDataGraphProcessingEnginePropertiesARMBuilder<'a> {
    #[inline]
    pub fn foreign_semaphore_handle_types(
        mut self,
        value: ExternalSemaphoreHandleTypeFlags,
    ) -> Self {
        self.inner.foreign_semaphore_handle_types = value;
        self
    }
    #[inline]
    pub fn foreign_memory_handle_types(
        mut self,
        value: ExternalMemoryHandleTypeFlags,
    ) -> Self {
        self.inner.foreign_memory_handle_types = value;
        self
    }
}
impl<'a> core::ops::Deref
for QueueFamilyDataGraphProcessingEnginePropertiesARMBuilder<'a> {
    type Target = QueueFamilyDataGraphProcessingEnginePropertiesARM;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for QueueFamilyDataGraphProcessingEnginePropertiesARMBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DataGraphProcessingEngineCreateInfoARM`] with lifetime-tied pNext safety.
pub struct DataGraphProcessingEngineCreateInfoARMBuilder<'a> {
    inner: DataGraphProcessingEngineCreateInfoARM,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DataGraphProcessingEngineCreateInfoARM {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> DataGraphProcessingEngineCreateInfoARMBuilder<'a> {
        DataGraphProcessingEngineCreateInfoARMBuilder {
            inner: DataGraphProcessingEngineCreateInfoARM {
                s_type: StructureType::from_raw(1000507016i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DataGraphProcessingEngineCreateInfoARMBuilder<'a> {
    #[inline]
    pub fn processing_engines(
        mut self,
        slice: &'a mut [PhysicalDeviceDataGraphProcessingEngineARM],
    ) -> Self {
        self.inner.processing_engine_count = slice.len() as u32;
        self.inner.p_processing_engines = slice.as_mut_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`DataGraphProcessingEngineCreateInfoARM`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsDataGraphProcessingEngineCreateInfoARM>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for DataGraphProcessingEngineCreateInfoARMBuilder<'a> {
    type Target = DataGraphProcessingEngineCreateInfoARM;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for DataGraphProcessingEngineCreateInfoARMBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDevicePipelineCacheIncrementalModeFeaturesSEC`] with lifetime-tied pNext safety.
pub struct PhysicalDevicePipelineCacheIncrementalModeFeaturesSECBuilder<'a> {
    inner: PhysicalDevicePipelineCacheIncrementalModeFeaturesSEC,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDevicePipelineCacheIncrementalModeFeaturesSEC {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDevicePipelineCacheIncrementalModeFeaturesSECBuilder<
        'a,
    > {
        PhysicalDevicePipelineCacheIncrementalModeFeaturesSECBuilder {
            inner: PhysicalDevicePipelineCacheIncrementalModeFeaturesSEC {
                s_type: StructureType::from_raw(1000637000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDevicePipelineCacheIncrementalModeFeaturesSECBuilder<'a> {
    #[inline]
    pub fn pipeline_cache_incremental_mode(mut self, value: bool) -> Self {
        self.inner.pipeline_cache_incremental_mode = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDevicePipelineCacheIncrementalModeFeaturesSEC`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDevicePipelineCacheIncrementalModeFeaturesSECBuilder<'a> {
    type Target = PhysicalDevicePipelineCacheIncrementalModeFeaturesSEC;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDevicePipelineCacheIncrementalModeFeaturesSECBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DataGraphPipelineBuiltinModelCreateInfoQCOM`] with lifetime-tied pNext safety.
pub struct DataGraphPipelineBuiltinModelCreateInfoQCOMBuilder<'a> {
    inner: DataGraphPipelineBuiltinModelCreateInfoQCOM,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DataGraphPipelineBuiltinModelCreateInfoQCOM {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> DataGraphPipelineBuiltinModelCreateInfoQCOMBuilder<'a> {
        DataGraphPipelineBuiltinModelCreateInfoQCOMBuilder {
            inner: DataGraphPipelineBuiltinModelCreateInfoQCOM {
                s_type: StructureType::from_raw(1000629001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DataGraphPipelineBuiltinModelCreateInfoQCOMBuilder<'a> {
    #[inline]
    pub fn operation(
        mut self,
        value: &'a PhysicalDeviceDataGraphOperationSupportARM,
    ) -> Self {
        self.inner.p_operation = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`DataGraphPipelineBuiltinModelCreateInfoQCOM`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsDataGraphPipelineBuiltinModelCreateInfoQCOM>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for DataGraphPipelineBuiltinModelCreateInfoQCOMBuilder<'a> {
    type Target = DataGraphPipelineBuiltinModelCreateInfoQCOM;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for DataGraphPipelineBuiltinModelCreateInfoQCOMBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceDataGraphModelFeaturesQCOM`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceDataGraphModelFeaturesQCOMBuilder<'a> {
    inner: PhysicalDeviceDataGraphModelFeaturesQCOM,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceDataGraphModelFeaturesQCOM {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceDataGraphModelFeaturesQCOMBuilder<'a> {
        PhysicalDeviceDataGraphModelFeaturesQCOMBuilder {
            inner: PhysicalDeviceDataGraphModelFeaturesQCOM {
                s_type: StructureType::from_raw(1000629000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceDataGraphModelFeaturesQCOMBuilder<'a> {
    #[inline]
    pub fn data_graph_model(mut self, value: bool) -> Self {
        self.inner.data_graph_model = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceDataGraphModelFeaturesQCOM`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceDataGraphModelFeaturesQCOM>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceDataGraphModelFeaturesQCOMBuilder<'a> {
    type Target = PhysicalDeviceDataGraphModelFeaturesQCOM;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceDataGraphModelFeaturesQCOMBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceShaderUntypedPointersFeaturesKHR`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceShaderUntypedPointersFeaturesKHRBuilder<'a> {
    inner: PhysicalDeviceShaderUntypedPointersFeaturesKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceShaderUntypedPointersFeaturesKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceShaderUntypedPointersFeaturesKHRBuilder<'a> {
        PhysicalDeviceShaderUntypedPointersFeaturesKHRBuilder {
            inner: PhysicalDeviceShaderUntypedPointersFeaturesKHR {
                s_type: StructureType::from_raw(1000387000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceShaderUntypedPointersFeaturesKHRBuilder<'a> {
    #[inline]
    pub fn shader_untyped_pointers(mut self, value: bool) -> Self {
        self.inner.shader_untyped_pointers = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceShaderUntypedPointersFeaturesKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceShaderUntypedPointersFeaturesKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceShaderUntypedPointersFeaturesKHRBuilder<'a> {
    type Target = PhysicalDeviceShaderUntypedPointersFeaturesKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceShaderUntypedPointersFeaturesKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`NativeBufferOHOS`] with lifetime-tied pNext safety.
pub struct NativeBufferOHOSBuilder<'a> {
    inner: NativeBufferOHOS,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl NativeBufferOHOS {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> NativeBufferOHOSBuilder<'a> {
        NativeBufferOHOSBuilder {
            inner: NativeBufferOHOS {
                s_type: Default::default(),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> NativeBufferOHOSBuilder<'a> {
    #[inline]
    pub fn handle(mut self, value: *mut core::ffi::c_void) -> Self {
        self.inner.handle = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`NativeBufferOHOS`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsNativeBufferOHOS>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for NativeBufferOHOSBuilder<'a> {
    type Target = NativeBufferOHOS;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for NativeBufferOHOSBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`SwapchainImageCreateInfoOHOS`] with lifetime-tied pNext safety.
pub struct SwapchainImageCreateInfoOHOSBuilder<'a> {
    inner: SwapchainImageCreateInfoOHOS,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl SwapchainImageCreateInfoOHOS {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> SwapchainImageCreateInfoOHOSBuilder<'a> {
        SwapchainImageCreateInfoOHOSBuilder {
            inner: SwapchainImageCreateInfoOHOS {
                s_type: Default::default(),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> SwapchainImageCreateInfoOHOSBuilder<'a> {
    #[inline]
    pub fn usage(mut self, value: SwapchainImageUsageFlagsOHOS) -> Self {
        self.inner.usage = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`SwapchainImageCreateInfoOHOS`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsSwapchainImageCreateInfoOHOS>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for SwapchainImageCreateInfoOHOSBuilder<'a> {
    type Target = SwapchainImageCreateInfoOHOS;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for SwapchainImageCreateInfoOHOSBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDevicePresentationPropertiesOHOS`] with lifetime-tied pNext safety.
pub struct PhysicalDevicePresentationPropertiesOHOSBuilder<'a> {
    inner: PhysicalDevicePresentationPropertiesOHOS,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDevicePresentationPropertiesOHOS {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDevicePresentationPropertiesOHOSBuilder<'a> {
        PhysicalDevicePresentationPropertiesOHOSBuilder {
            inner: PhysicalDevicePresentationPropertiesOHOS {
                s_type: Default::default(),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDevicePresentationPropertiesOHOSBuilder<'a> {
    #[inline]
    pub fn shared_image(mut self, value: bool) -> Self {
        self.inner.shared_image = value as u32;
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDevicePresentationPropertiesOHOSBuilder<'a> {
    type Target = PhysicalDevicePresentationPropertiesOHOS;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDevicePresentationPropertiesOHOSBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceVideoEncodeRgbConversionFeaturesVALVEBuilder<'a> {
    inner: PhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceVideoEncodeRgbConversionFeaturesVALVEBuilder<
        'a,
    > {
        PhysicalDeviceVideoEncodeRgbConversionFeaturesVALVEBuilder {
            inner: PhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE {
                s_type: StructureType::from_raw(1000390000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceVideoEncodeRgbConversionFeaturesVALVEBuilder<'a> {
    #[inline]
    pub fn video_encode_rgb_conversion(mut self, value: bool) -> Self {
        self.inner.video_encode_rgb_conversion = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDeviceVideoEncodeRgbConversionFeaturesVALVEBuilder<'a> {
    type Target = PhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceVideoEncodeRgbConversionFeaturesVALVEBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VideoEncodeRgbConversionCapabilitiesVALVE`] with lifetime-tied pNext safety.
pub struct VideoEncodeRgbConversionCapabilitiesVALVEBuilder<'a> {
    inner: VideoEncodeRgbConversionCapabilitiesVALVE,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl VideoEncodeRgbConversionCapabilitiesVALVE {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> VideoEncodeRgbConversionCapabilitiesVALVEBuilder<'a> {
        VideoEncodeRgbConversionCapabilitiesVALVEBuilder {
            inner: VideoEncodeRgbConversionCapabilitiesVALVE {
                s_type: StructureType::from_raw(1000390001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> VideoEncodeRgbConversionCapabilitiesVALVEBuilder<'a> {
    #[inline]
    pub fn rgb_models(mut self, value: VideoEncodeRgbModelConversionFlagsVALVE) -> Self {
        self.inner.rgb_models = value;
        self
    }
    #[inline]
    pub fn rgb_ranges(
        mut self,
        value: VideoEncodeRgbRangeCompressionFlagsVALVE,
    ) -> Self {
        self.inner.rgb_ranges = value;
        self
    }
    #[inline]
    pub fn x_chroma_offsets(
        mut self,
        value: VideoEncodeRgbChromaOffsetFlagsVALVE,
    ) -> Self {
        self.inner.x_chroma_offsets = value;
        self
    }
    #[inline]
    pub fn y_chroma_offsets(
        mut self,
        value: VideoEncodeRgbChromaOffsetFlagsVALVE,
    ) -> Self {
        self.inner.y_chroma_offsets = value;
        self
    }
}
impl<'a> core::ops::Deref for VideoEncodeRgbConversionCapabilitiesVALVEBuilder<'a> {
    type Target = VideoEncodeRgbConversionCapabilitiesVALVE;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for VideoEncodeRgbConversionCapabilitiesVALVEBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VideoEncodeProfileRgbConversionInfoVALVE`] with lifetime-tied pNext safety.
pub struct VideoEncodeProfileRgbConversionInfoVALVEBuilder<'a> {
    inner: VideoEncodeProfileRgbConversionInfoVALVE,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl VideoEncodeProfileRgbConversionInfoVALVE {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> VideoEncodeProfileRgbConversionInfoVALVEBuilder<'a> {
        VideoEncodeProfileRgbConversionInfoVALVEBuilder {
            inner: VideoEncodeProfileRgbConversionInfoVALVE {
                s_type: StructureType::from_raw(1000390002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> VideoEncodeProfileRgbConversionInfoVALVEBuilder<'a> {
    #[inline]
    pub fn perform_encode_rgb_conversion(mut self, value: bool) -> Self {
        self.inner.perform_encode_rgb_conversion = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`VideoEncodeProfileRgbConversionInfoVALVE`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsVideoEncodeProfileRgbConversionInfoVALVE>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for VideoEncodeProfileRgbConversionInfoVALVEBuilder<'a> {
    type Target = VideoEncodeProfileRgbConversionInfoVALVE;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for VideoEncodeProfileRgbConversionInfoVALVEBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`VideoEncodeSessionRgbConversionCreateInfoVALVE`] with lifetime-tied pNext safety.
pub struct VideoEncodeSessionRgbConversionCreateInfoVALVEBuilder<'a> {
    inner: VideoEncodeSessionRgbConversionCreateInfoVALVE,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl VideoEncodeSessionRgbConversionCreateInfoVALVE {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> VideoEncodeSessionRgbConversionCreateInfoVALVEBuilder<'a> {
        VideoEncodeSessionRgbConversionCreateInfoVALVEBuilder {
            inner: VideoEncodeSessionRgbConversionCreateInfoVALVE {
                s_type: StructureType::from_raw(1000390003i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> VideoEncodeSessionRgbConversionCreateInfoVALVEBuilder<'a> {
    #[inline]
    pub fn rgb_model(
        mut self,
        value: VideoEncodeRgbModelConversionFlagBitsVALVE,
    ) -> Self {
        self.inner.rgb_model = value;
        self
    }
    #[inline]
    pub fn rgb_range(
        mut self,
        value: VideoEncodeRgbRangeCompressionFlagBitsVALVE,
    ) -> Self {
        self.inner.rgb_range = value;
        self
    }
    #[inline]
    pub fn x_chroma_offset(
        mut self,
        value: VideoEncodeRgbChromaOffsetFlagBitsVALVE,
    ) -> Self {
        self.inner.x_chroma_offset = value;
        self
    }
    #[inline]
    pub fn y_chroma_offset(
        mut self,
        value: VideoEncodeRgbChromaOffsetFlagBitsVALVE,
    ) -> Self {
        self.inner.y_chroma_offset = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`VideoEncodeSessionRgbConversionCreateInfoVALVE`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsVideoEncodeSessionRgbConversionCreateInfoVALVE>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for VideoEncodeSessionRgbConversionCreateInfoVALVEBuilder<'a> {
    type Target = VideoEncodeSessionRgbConversionCreateInfoVALVE;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for VideoEncodeSessionRgbConversionCreateInfoVALVEBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceShader64BitIndexingFeaturesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceShader64BitIndexingFeaturesEXTBuilder<'a> {
    inner: PhysicalDeviceShader64BitIndexingFeaturesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceShader64BitIndexingFeaturesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceShader64BitIndexingFeaturesEXTBuilder<'a> {
        PhysicalDeviceShader64BitIndexingFeaturesEXTBuilder {
            inner: PhysicalDeviceShader64BitIndexingFeaturesEXT {
                s_type: StructureType::from_raw(1000627000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceShader64BitIndexingFeaturesEXTBuilder<'a> {
    #[inline]
    pub fn shader64_bit_indexing(mut self, value: bool) -> Self {
        self.inner.shader64_bit_indexing = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceShader64BitIndexingFeaturesEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceShader64BitIndexingFeaturesEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceShader64BitIndexingFeaturesEXTBuilder<'a> {
    type Target = PhysicalDeviceShader64BitIndexingFeaturesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceShader64BitIndexingFeaturesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`NativeBufferUsageOHOS`] with lifetime-tied pNext safety.
pub struct NativeBufferUsageOHOSBuilder<'a> {
    inner: NativeBufferUsageOHOS,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl NativeBufferUsageOHOS {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> NativeBufferUsageOHOSBuilder<'a> {
        NativeBufferUsageOHOSBuilder {
            inner: NativeBufferUsageOHOS {
                s_type: StructureType::from_raw(1000452000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> NativeBufferUsageOHOSBuilder<'a> {
    #[inline]
    pub fn ohos_native_buffer_usage(mut self, value: u64) -> Self {
        self.inner.ohos_native_buffer_usage = value;
        self
    }
}
impl<'a> core::ops::Deref for NativeBufferUsageOHOSBuilder<'a> {
    type Target = NativeBufferUsageOHOS;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for NativeBufferUsageOHOSBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`NativeBufferPropertiesOHOS`] with lifetime-tied pNext safety.
pub struct NativeBufferPropertiesOHOSBuilder<'a> {
    inner: NativeBufferPropertiesOHOS,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl NativeBufferPropertiesOHOS {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> NativeBufferPropertiesOHOSBuilder<'a> {
        NativeBufferPropertiesOHOSBuilder {
            inner: NativeBufferPropertiesOHOS {
                s_type: StructureType::from_raw(1000452001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> NativeBufferPropertiesOHOSBuilder<'a> {
    #[inline]
    pub fn allocation_size(mut self, value: u64) -> Self {
        self.inner.allocation_size = value;
        self
    }
    #[inline]
    pub fn memory_type_bits(mut self, value: u32) -> Self {
        self.inner.memory_type_bits = value;
        self
    }
}
impl<'a> core::ops::Deref for NativeBufferPropertiesOHOSBuilder<'a> {
    type Target = NativeBufferPropertiesOHOS;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for NativeBufferPropertiesOHOSBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`NativeBufferFormatPropertiesOHOS`] with lifetime-tied pNext safety.
pub struct NativeBufferFormatPropertiesOHOSBuilder<'a> {
    inner: NativeBufferFormatPropertiesOHOS,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl NativeBufferFormatPropertiesOHOS {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> NativeBufferFormatPropertiesOHOSBuilder<'a> {
        NativeBufferFormatPropertiesOHOSBuilder {
            inner: NativeBufferFormatPropertiesOHOS {
                s_type: StructureType::from_raw(1000452002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> NativeBufferFormatPropertiesOHOSBuilder<'a> {
    #[inline]
    pub fn format(mut self, value: Format) -> Self {
        self.inner.format = value;
        self
    }
    #[inline]
    pub fn external_format(mut self, value: u64) -> Self {
        self.inner.external_format = value;
        self
    }
    #[inline]
    pub fn format_features(mut self, value: FormatFeatureFlags) -> Self {
        self.inner.format_features = value;
        self
    }
    #[inline]
    pub fn sampler_ycbcr_conversion_components(
        mut self,
        value: ComponentMapping,
    ) -> Self {
        self.inner.sampler_ycbcr_conversion_components = value;
        self
    }
    #[inline]
    pub fn suggested_ycbcr_model(mut self, value: SamplerYcbcrModelConversion) -> Self {
        self.inner.suggested_ycbcr_model = value;
        self
    }
    #[inline]
    pub fn suggested_ycbcr_range(mut self, value: SamplerYcbcrRange) -> Self {
        self.inner.suggested_ycbcr_range = value;
        self
    }
    #[inline]
    pub fn suggested_x_chroma_offset(mut self, value: ChromaLocation) -> Self {
        self.inner.suggested_x_chroma_offset = value;
        self
    }
    #[inline]
    pub fn suggested_y_chroma_offset(mut self, value: ChromaLocation) -> Self {
        self.inner.suggested_y_chroma_offset = value;
        self
    }
}
impl<'a> core::ops::Deref for NativeBufferFormatPropertiesOHOSBuilder<'a> {
    type Target = NativeBufferFormatPropertiesOHOS;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for NativeBufferFormatPropertiesOHOSBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ImportNativeBufferInfoOHOS`] with lifetime-tied pNext safety.
pub struct ImportNativeBufferInfoOHOSBuilder<'a> {
    inner: ImportNativeBufferInfoOHOS,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ImportNativeBufferInfoOHOS {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ImportNativeBufferInfoOHOSBuilder<'a> {
        ImportNativeBufferInfoOHOSBuilder {
            inner: ImportNativeBufferInfoOHOS {
                s_type: StructureType::from_raw(1000452003i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ImportNativeBufferInfoOHOSBuilder<'a> {
    #[inline]
    pub fn buffer(mut self, value: *mut core::ffi::c_void) -> Self {
        self.inner.buffer = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`ImportNativeBufferInfoOHOS`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsImportNativeBufferInfoOHOS>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for ImportNativeBufferInfoOHOSBuilder<'a> {
    type Target = ImportNativeBufferInfoOHOS;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ImportNativeBufferInfoOHOSBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`MemoryGetNativeBufferInfoOHOS`] with lifetime-tied pNext safety.
pub struct MemoryGetNativeBufferInfoOHOSBuilder<'a> {
    inner: MemoryGetNativeBufferInfoOHOS,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl MemoryGetNativeBufferInfoOHOS {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> MemoryGetNativeBufferInfoOHOSBuilder<'a> {
        MemoryGetNativeBufferInfoOHOSBuilder {
            inner: MemoryGetNativeBufferInfoOHOS {
                s_type: StructureType::from_raw(1000452004i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> MemoryGetNativeBufferInfoOHOSBuilder<'a> {
    #[inline]
    pub fn memory(mut self, value: DeviceMemory) -> Self {
        self.inner.memory = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`MemoryGetNativeBufferInfoOHOS`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsMemoryGetNativeBufferInfoOHOS>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for MemoryGetNativeBufferInfoOHOSBuilder<'a> {
    type Target = MemoryGetNativeBufferInfoOHOS;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for MemoryGetNativeBufferInfoOHOSBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ExternalFormatOHOS`] with lifetime-tied pNext safety.
pub struct ExternalFormatOHOSBuilder<'a> {
    inner: ExternalFormatOHOS,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ExternalFormatOHOS {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ExternalFormatOHOSBuilder<'a> {
        ExternalFormatOHOSBuilder {
            inner: ExternalFormatOHOS {
                s_type: StructureType::from_raw(1000452005i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ExternalFormatOHOSBuilder<'a> {
    #[inline]
    pub fn external_format(mut self, value: u64) -> Self {
        self.inner.external_format = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`ExternalFormatOHOS`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsExternalFormatOHOS>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for ExternalFormatOHOSBuilder<'a> {
    type Target = ExternalFormatOHOS;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ExternalFormatOHOSBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDevicePerformanceCountersByRegionFeaturesARM`] with lifetime-tied pNext safety.
pub struct PhysicalDevicePerformanceCountersByRegionFeaturesARMBuilder<'a> {
    inner: PhysicalDevicePerformanceCountersByRegionFeaturesARM,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDevicePerformanceCountersByRegionFeaturesARM {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDevicePerformanceCountersByRegionFeaturesARMBuilder<
        'a,
    > {
        PhysicalDevicePerformanceCountersByRegionFeaturesARMBuilder {
            inner: PhysicalDevicePerformanceCountersByRegionFeaturesARM {
                s_type: StructureType::from_raw(1000605000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDevicePerformanceCountersByRegionFeaturesARMBuilder<'a> {
    #[inline]
    pub fn performance_counters_by_region(mut self, value: bool) -> Self {
        self.inner.performance_counters_by_region = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDevicePerformanceCountersByRegionFeaturesARM`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDevicePerformanceCountersByRegionFeaturesARM>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDevicePerformanceCountersByRegionFeaturesARMBuilder<'a> {
    type Target = PhysicalDevicePerformanceCountersByRegionFeaturesARM;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDevicePerformanceCountersByRegionFeaturesARMBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDevicePerformanceCountersByRegionPropertiesARM`] with lifetime-tied pNext safety.
pub struct PhysicalDevicePerformanceCountersByRegionPropertiesARMBuilder<'a> {
    inner: PhysicalDevicePerformanceCountersByRegionPropertiesARM,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDevicePerformanceCountersByRegionPropertiesARM {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDevicePerformanceCountersByRegionPropertiesARMBuilder<
        'a,
    > {
        PhysicalDevicePerformanceCountersByRegionPropertiesARMBuilder {
            inner: PhysicalDevicePerformanceCountersByRegionPropertiesARM {
                s_type: StructureType::from_raw(1000605001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDevicePerformanceCountersByRegionPropertiesARMBuilder<'a> {
    #[inline]
    pub fn max_per_region_performance_counters(mut self, value: u32) -> Self {
        self.inner.max_per_region_performance_counters = value;
        self
    }
    #[inline]
    pub fn performance_counter_region_size(mut self, value: Extent2D) -> Self {
        self.inner.performance_counter_region_size = value;
        self
    }
    #[inline]
    pub fn row_stride_alignment(mut self, value: u32) -> Self {
        self.inner.row_stride_alignment = value;
        self
    }
    #[inline]
    pub fn region_alignment(mut self, value: u32) -> Self {
        self.inner.region_alignment = value;
        self
    }
    #[inline]
    pub fn identity_transform_order(mut self, value: bool) -> Self {
        self.inner.identity_transform_order = value as u32;
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDevicePerformanceCountersByRegionPropertiesARMBuilder<'a> {
    type Target = PhysicalDevicePerformanceCountersByRegionPropertiesARM;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDevicePerformanceCountersByRegionPropertiesARMBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PerformanceCounterARM`] with lifetime-tied pNext safety.
pub struct PerformanceCounterARMBuilder<'a> {
    inner: PerformanceCounterARM,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PerformanceCounterARM {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PerformanceCounterARMBuilder<'a> {
        PerformanceCounterARMBuilder {
            inner: PerformanceCounterARM {
                s_type: StructureType::from_raw(1000605002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PerformanceCounterARMBuilder<'a> {
    #[inline]
    pub fn counter_id(mut self, value: u32) -> Self {
        self.inner.counter_id = value;
        self
    }
}
impl<'a> core::ops::Deref for PerformanceCounterARMBuilder<'a> {
    type Target = PerformanceCounterARM;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PerformanceCounterARMBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PerformanceCounterDescriptionARM`] with lifetime-tied pNext safety.
pub struct PerformanceCounterDescriptionARMBuilder<'a> {
    inner: PerformanceCounterDescriptionARM,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PerformanceCounterDescriptionARM {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PerformanceCounterDescriptionARMBuilder<'a> {
        PerformanceCounterDescriptionARMBuilder {
            inner: PerformanceCounterDescriptionARM {
                s_type: StructureType::from_raw(1000605003i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PerformanceCounterDescriptionARMBuilder<'a> {
    #[inline]
    pub fn flags(mut self, value: PerformanceCounterDescriptionFlagsARM) -> Self {
        self.inner.flags = value;
        self
    }
    #[inline]
    pub fn name(
        mut self,
        value: crate::StringArray<{ MAX_DESCRIPTION_SIZE as usize }>,
    ) -> Self {
        self.inner.name = value;
        self
    }
}
impl<'a> core::ops::Deref for PerformanceCounterDescriptionARMBuilder<'a> {
    type Target = PerformanceCounterDescriptionARM;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PerformanceCounterDescriptionARMBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`RenderPassPerformanceCountersByRegionBeginInfoARM`] with lifetime-tied pNext safety.
pub struct RenderPassPerformanceCountersByRegionBeginInfoARMBuilder<'a> {
    inner: RenderPassPerformanceCountersByRegionBeginInfoARM,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl RenderPassPerformanceCountersByRegionBeginInfoARM {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> RenderPassPerformanceCountersByRegionBeginInfoARMBuilder<
        'a,
    > {
        RenderPassPerformanceCountersByRegionBeginInfoARMBuilder {
            inner: RenderPassPerformanceCountersByRegionBeginInfoARM {
                s_type: StructureType::from_raw(1000605004i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> RenderPassPerformanceCountersByRegionBeginInfoARMBuilder<'a> {
    #[inline]
    pub fn counter_addresses(mut self, slice: &'a [u64]) -> Self {
        self.inner.counter_address_count = slice.len() as u32;
        self.inner.p_counter_addresses = slice.as_ptr();
        self
    }
    #[inline]
    pub fn serialize_regions(mut self, value: bool) -> Self {
        self.inner.serialize_regions = value as u32;
        self
    }
    #[inline]
    pub fn counter_indices(mut self, slice: &'a mut [u32]) -> Self {
        self.inner.counter_index_count = slice.len() as u32;
        self.inner.p_counter_indices = slice.as_mut_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`RenderPassPerformanceCountersByRegionBeginInfoARM`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsRenderPassPerformanceCountersByRegionBeginInfoARM>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref
for RenderPassPerformanceCountersByRegionBeginInfoARMBuilder<'a> {
    type Target = RenderPassPerformanceCountersByRegionBeginInfoARM;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for RenderPassPerformanceCountersByRegionBeginInfoARMBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ComputeOccupancyPriorityParametersNV`] with lifetime-tied pNext safety.
pub struct ComputeOccupancyPriorityParametersNVBuilder<'a> {
    inner: ComputeOccupancyPriorityParametersNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ComputeOccupancyPriorityParametersNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ComputeOccupancyPriorityParametersNVBuilder<'a> {
        ComputeOccupancyPriorityParametersNVBuilder {
            inner: ComputeOccupancyPriorityParametersNV {
                s_type: StructureType::from_raw(1000645000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ComputeOccupancyPriorityParametersNVBuilder<'a> {
    #[inline]
    pub fn occupancy_priority(mut self, value: f32) -> Self {
        self.inner.occupancy_priority = value;
        self
    }
    #[inline]
    pub fn occupancy_throttling(mut self, value: f32) -> Self {
        self.inner.occupancy_throttling = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`ComputeOccupancyPriorityParametersNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsComputeOccupancyPriorityParametersNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for ComputeOccupancyPriorityParametersNVBuilder<'a> {
    type Target = ComputeOccupancyPriorityParametersNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ComputeOccupancyPriorityParametersNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceComputeOccupancyPriorityFeaturesNV`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceComputeOccupancyPriorityFeaturesNVBuilder<'a> {
    inner: PhysicalDeviceComputeOccupancyPriorityFeaturesNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceComputeOccupancyPriorityFeaturesNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceComputeOccupancyPriorityFeaturesNVBuilder<'a> {
        PhysicalDeviceComputeOccupancyPriorityFeaturesNVBuilder {
            inner: PhysicalDeviceComputeOccupancyPriorityFeaturesNV {
                s_type: StructureType::from_raw(1000645001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceComputeOccupancyPriorityFeaturesNVBuilder<'a> {
    #[inline]
    pub fn compute_occupancy_priority(mut self, value: bool) -> Self {
        self.inner.compute_occupancy_priority = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceComputeOccupancyPriorityFeaturesNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceComputeOccupancyPriorityFeaturesNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDeviceComputeOccupancyPriorityFeaturesNVBuilder<'a> {
    type Target = PhysicalDeviceComputeOccupancyPriorityFeaturesNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceComputeOccupancyPriorityFeaturesNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceShaderLongVectorFeaturesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceShaderLongVectorFeaturesEXTBuilder<'a> {
    inner: PhysicalDeviceShaderLongVectorFeaturesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceShaderLongVectorFeaturesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceShaderLongVectorFeaturesEXTBuilder<'a> {
        PhysicalDeviceShaderLongVectorFeaturesEXTBuilder {
            inner: PhysicalDeviceShaderLongVectorFeaturesEXT {
                s_type: StructureType::from_raw(1000635000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceShaderLongVectorFeaturesEXTBuilder<'a> {
    #[inline]
    pub fn long_vector(mut self, value: bool) -> Self {
        self.inner.long_vector = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceShaderLongVectorFeaturesEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceShaderLongVectorFeaturesEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceShaderLongVectorFeaturesEXTBuilder<'a> {
    type Target = PhysicalDeviceShaderLongVectorFeaturesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceShaderLongVectorFeaturesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceShaderLongVectorPropertiesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceShaderLongVectorPropertiesEXTBuilder<'a> {
    inner: PhysicalDeviceShaderLongVectorPropertiesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceShaderLongVectorPropertiesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceShaderLongVectorPropertiesEXTBuilder<'a> {
        PhysicalDeviceShaderLongVectorPropertiesEXTBuilder {
            inner: PhysicalDeviceShaderLongVectorPropertiesEXT {
                s_type: StructureType::from_raw(1000635001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceShaderLongVectorPropertiesEXTBuilder<'a> {
    #[inline]
    pub fn max_vector_components(mut self, value: u32) -> Self {
        self.inner.max_vector_components = value;
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceShaderLongVectorPropertiesEXTBuilder<'a> {
    type Target = PhysicalDeviceShaderLongVectorPropertiesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceShaderLongVectorPropertiesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceTextureCompressionASTC3DFeaturesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceTextureCompressionASTC3DFeaturesEXTBuilder<'a> {
    inner: PhysicalDeviceTextureCompressionASTC3DFeaturesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceTextureCompressionASTC3DFeaturesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceTextureCompressionASTC3DFeaturesEXTBuilder<
        'a,
    > {
        PhysicalDeviceTextureCompressionASTC3DFeaturesEXTBuilder {
            inner: PhysicalDeviceTextureCompressionASTC3DFeaturesEXT {
                s_type: StructureType::from_raw(1000288000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceTextureCompressionASTC3DFeaturesEXTBuilder<'a> {
    #[inline]
    pub fn texture_compression_astc_3d(mut self, value: bool) -> Self {
        self.inner.texture_compression_astc_3d = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceTextureCompressionASTC3DFeaturesEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceTextureCompressionASTC3DFeaturesEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDeviceTextureCompressionASTC3DFeaturesEXTBuilder<'a> {
    type Target = PhysicalDeviceTextureCompressionASTC3DFeaturesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceTextureCompressionASTC3DFeaturesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceShaderSubgroupPartitionedFeaturesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceShaderSubgroupPartitionedFeaturesEXTBuilder<'a> {
    inner: PhysicalDeviceShaderSubgroupPartitionedFeaturesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceShaderSubgroupPartitionedFeaturesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceShaderSubgroupPartitionedFeaturesEXTBuilder<
        'a,
    > {
        PhysicalDeviceShaderSubgroupPartitionedFeaturesEXTBuilder {
            inner: PhysicalDeviceShaderSubgroupPartitionedFeaturesEXT {
                s_type: StructureType::from_raw(1000662000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceShaderSubgroupPartitionedFeaturesEXTBuilder<'a> {
    #[inline]
    pub fn shader_subgroup_partitioned(mut self, value: bool) -> Self {
        self.inner.shader_subgroup_partitioned = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceShaderSubgroupPartitionedFeaturesEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDeviceShaderSubgroupPartitionedFeaturesEXTBuilder<'a> {
    type Target = PhysicalDeviceShaderSubgroupPartitionedFeaturesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceShaderSubgroupPartitionedFeaturesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`HostAddressRangeEXT`].
pub struct HostAddressRangeEXTBuilder<'a> {
    inner: HostAddressRangeEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl HostAddressRangeEXT {
    /// Start building this struct.
    #[inline]
    pub fn builder<'a>() -> HostAddressRangeEXTBuilder<'a> {
        HostAddressRangeEXTBuilder {
            inner: HostAddressRangeEXT {
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> HostAddressRangeEXTBuilder<'a> {
    #[inline]
    pub fn address(mut self, slice: &'a mut [core::ffi::c_void]) -> Self {
        self.inner.size = slice.len();
        self.inner.address = slice.as_mut_ptr();
        self
    }
}
impl<'a> core::ops::Deref for HostAddressRangeEXTBuilder<'a> {
    type Target = HostAddressRangeEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for HostAddressRangeEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`HostAddressRangeConstEXT`].
pub struct HostAddressRangeConstEXTBuilder<'a> {
    inner: HostAddressRangeConstEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl HostAddressRangeConstEXT {
    /// Start building this struct.
    #[inline]
    pub fn builder<'a>() -> HostAddressRangeConstEXTBuilder<'a> {
        HostAddressRangeConstEXTBuilder {
            inner: HostAddressRangeConstEXT {
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> HostAddressRangeConstEXTBuilder<'a> {
    #[inline]
    pub fn address(mut self, slice: &'a [core::ffi::c_void]) -> Self {
        self.inner.size = slice.len();
        self.inner.address = slice.as_ptr();
        self
    }
}
impl<'a> core::ops::Deref for HostAddressRangeConstEXTBuilder<'a> {
    type Target = HostAddressRangeConstEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for HostAddressRangeConstEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`TexelBufferDescriptorInfoEXT`] with lifetime-tied pNext safety.
pub struct TexelBufferDescriptorInfoEXTBuilder<'a> {
    inner: TexelBufferDescriptorInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl TexelBufferDescriptorInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> TexelBufferDescriptorInfoEXTBuilder<'a> {
        TexelBufferDescriptorInfoEXTBuilder {
            inner: TexelBufferDescriptorInfoEXT {
                s_type: StructureType::from_raw(1000135000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> TexelBufferDescriptorInfoEXTBuilder<'a> {
    #[inline]
    pub fn format(mut self, value: Format) -> Self {
        self.inner.format = value;
        self
    }
    #[inline]
    pub fn address_range(mut self, value: DeviceAddressRangeEXT) -> Self {
        self.inner.address_range = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`TexelBufferDescriptorInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsTexelBufferDescriptorInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for TexelBufferDescriptorInfoEXTBuilder<'a> {
    type Target = TexelBufferDescriptorInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for TexelBufferDescriptorInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ImageDescriptorInfoEXT`] with lifetime-tied pNext safety.
pub struct ImageDescriptorInfoEXTBuilder<'a> {
    inner: ImageDescriptorInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ImageDescriptorInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ImageDescriptorInfoEXTBuilder<'a> {
        ImageDescriptorInfoEXTBuilder {
            inner: ImageDescriptorInfoEXT {
                s_type: StructureType::from_raw(1000135001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ImageDescriptorInfoEXTBuilder<'a> {
    #[inline]
    pub fn view(mut self, value: &'a ImageViewCreateInfo) -> Self {
        self.inner.p_view = value;
        self
    }
    #[inline]
    pub fn layout(mut self, value: ImageLayout) -> Self {
        self.inner.layout = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`ImageDescriptorInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsImageDescriptorInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for ImageDescriptorInfoEXTBuilder<'a> {
    type Target = ImageDescriptorInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ImageDescriptorInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ResourceDescriptorInfoEXT`] with lifetime-tied pNext safety.
pub struct ResourceDescriptorInfoEXTBuilder<'a> {
    inner: ResourceDescriptorInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ResourceDescriptorInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ResourceDescriptorInfoEXTBuilder<'a> {
        ResourceDescriptorInfoEXTBuilder {
            inner: ResourceDescriptorInfoEXT {
                s_type: StructureType::from_raw(1000135002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ResourceDescriptorInfoEXTBuilder<'a> {
    #[inline]
    pub fn r#type(mut self, value: DescriptorType) -> Self {
        self.inner.r#type = value;
        self
    }
    #[inline]
    pub fn data(mut self, value: ResourceDescriptorDataEXT) -> Self {
        self.inner.data = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`ResourceDescriptorInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsResourceDescriptorInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for ResourceDescriptorInfoEXTBuilder<'a> {
    type Target = ResourceDescriptorInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ResourceDescriptorInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`BindHeapInfoEXT`] with lifetime-tied pNext safety.
pub struct BindHeapInfoEXTBuilder<'a> {
    inner: BindHeapInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl BindHeapInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> BindHeapInfoEXTBuilder<'a> {
        BindHeapInfoEXTBuilder {
            inner: BindHeapInfoEXT {
                s_type: StructureType::from_raw(1000135003i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> BindHeapInfoEXTBuilder<'a> {
    #[inline]
    pub fn heap_range(mut self, value: DeviceAddressRangeEXT) -> Self {
        self.inner.heap_range = value;
        self
    }
    #[inline]
    pub fn reserved_range_offset(mut self, value: u64) -> Self {
        self.inner.reserved_range_offset = value;
        self
    }
    #[inline]
    pub fn reserved_range_size(mut self, value: u64) -> Self {
        self.inner.reserved_range_size = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`BindHeapInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsBindHeapInfoEXT>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for BindHeapInfoEXTBuilder<'a> {
    type Target = BindHeapInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for BindHeapInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PushDataInfoEXT`] with lifetime-tied pNext safety.
pub struct PushDataInfoEXTBuilder<'a> {
    inner: PushDataInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PushDataInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PushDataInfoEXTBuilder<'a> {
        PushDataInfoEXTBuilder {
            inner: PushDataInfoEXT {
                s_type: StructureType::from_raw(1000135004i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PushDataInfoEXTBuilder<'a> {
    #[inline]
    pub fn offset(mut self, value: u32) -> Self {
        self.inner.offset = value;
        self
    }
    #[inline]
    pub fn data(mut self, value: HostAddressRangeConstEXT) -> Self {
        self.inner.data = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PushDataInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPushDataInfoEXT>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for PushDataInfoEXTBuilder<'a> {
    type Target = PushDataInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PushDataInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DescriptorMappingSourceConstantOffsetEXT`].
pub struct DescriptorMappingSourceConstantOffsetEXTBuilder<'a> {
    inner: DescriptorMappingSourceConstantOffsetEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DescriptorMappingSourceConstantOffsetEXT {
    /// Start building this struct.
    #[inline]
    pub fn builder<'a>() -> DescriptorMappingSourceConstantOffsetEXTBuilder<'a> {
        DescriptorMappingSourceConstantOffsetEXTBuilder {
            inner: DescriptorMappingSourceConstantOffsetEXT {
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DescriptorMappingSourceConstantOffsetEXTBuilder<'a> {
    #[inline]
    pub fn heap_offset(mut self, value: u32) -> Self {
        self.inner.heap_offset = value;
        self
    }
    #[inline]
    pub fn heap_array_stride(mut self, value: u32) -> Self {
        self.inner.heap_array_stride = value;
        self
    }
    #[inline]
    pub fn embedded_sampler(mut self, value: &'a SamplerCreateInfo) -> Self {
        self.inner.p_embedded_sampler = value;
        self
    }
    #[inline]
    pub fn sampler_heap_offset(mut self, value: u32) -> Self {
        self.inner.sampler_heap_offset = value;
        self
    }
    #[inline]
    pub fn sampler_heap_array_stride(mut self, value: u32) -> Self {
        self.inner.sampler_heap_array_stride = value;
        self
    }
}
impl<'a> core::ops::Deref for DescriptorMappingSourceConstantOffsetEXTBuilder<'a> {
    type Target = DescriptorMappingSourceConstantOffsetEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for DescriptorMappingSourceConstantOffsetEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DescriptorMappingSourcePushIndexEXT`].
pub struct DescriptorMappingSourcePushIndexEXTBuilder<'a> {
    inner: DescriptorMappingSourcePushIndexEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DescriptorMappingSourcePushIndexEXT {
    /// Start building this struct.
    #[inline]
    pub fn builder<'a>() -> DescriptorMappingSourcePushIndexEXTBuilder<'a> {
        DescriptorMappingSourcePushIndexEXTBuilder {
            inner: DescriptorMappingSourcePushIndexEXT {
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DescriptorMappingSourcePushIndexEXTBuilder<'a> {
    #[inline]
    pub fn heap_offset(mut self, value: u32) -> Self {
        self.inner.heap_offset = value;
        self
    }
    #[inline]
    pub fn push_offset(mut self, value: u32) -> Self {
        self.inner.push_offset = value;
        self
    }
    #[inline]
    pub fn heap_index_stride(mut self, value: u32) -> Self {
        self.inner.heap_index_stride = value;
        self
    }
    #[inline]
    pub fn heap_array_stride(mut self, value: u32) -> Self {
        self.inner.heap_array_stride = value;
        self
    }
    #[inline]
    pub fn embedded_sampler(mut self, value: &'a SamplerCreateInfo) -> Self {
        self.inner.p_embedded_sampler = value;
        self
    }
    #[inline]
    pub fn use_combined_image_sampler_index(mut self, value: bool) -> Self {
        self.inner.use_combined_image_sampler_index = value as u32;
        self
    }
    #[inline]
    pub fn sampler_heap_offset(mut self, value: u32) -> Self {
        self.inner.sampler_heap_offset = value;
        self
    }
    #[inline]
    pub fn sampler_push_offset(mut self, value: u32) -> Self {
        self.inner.sampler_push_offset = value;
        self
    }
    #[inline]
    pub fn sampler_heap_index_stride(mut self, value: u32) -> Self {
        self.inner.sampler_heap_index_stride = value;
        self
    }
    #[inline]
    pub fn sampler_heap_array_stride(mut self, value: u32) -> Self {
        self.inner.sampler_heap_array_stride = value;
        self
    }
}
impl<'a> core::ops::Deref for DescriptorMappingSourcePushIndexEXTBuilder<'a> {
    type Target = DescriptorMappingSourcePushIndexEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for DescriptorMappingSourcePushIndexEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DescriptorMappingSourceIndirectIndexEXT`].
pub struct DescriptorMappingSourceIndirectIndexEXTBuilder<'a> {
    inner: DescriptorMappingSourceIndirectIndexEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DescriptorMappingSourceIndirectIndexEXT {
    /// Start building this struct.
    #[inline]
    pub fn builder<'a>() -> DescriptorMappingSourceIndirectIndexEXTBuilder<'a> {
        DescriptorMappingSourceIndirectIndexEXTBuilder {
            inner: DescriptorMappingSourceIndirectIndexEXT {
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DescriptorMappingSourceIndirectIndexEXTBuilder<'a> {
    #[inline]
    pub fn heap_offset(mut self, value: u32) -> Self {
        self.inner.heap_offset = value;
        self
    }
    #[inline]
    pub fn push_offset(mut self, value: u32) -> Self {
        self.inner.push_offset = value;
        self
    }
    #[inline]
    pub fn address_offset(mut self, value: u32) -> Self {
        self.inner.address_offset = value;
        self
    }
    #[inline]
    pub fn heap_index_stride(mut self, value: u32) -> Self {
        self.inner.heap_index_stride = value;
        self
    }
    #[inline]
    pub fn heap_array_stride(mut self, value: u32) -> Self {
        self.inner.heap_array_stride = value;
        self
    }
    #[inline]
    pub fn embedded_sampler(mut self, value: &'a SamplerCreateInfo) -> Self {
        self.inner.p_embedded_sampler = value;
        self
    }
    #[inline]
    pub fn use_combined_image_sampler_index(mut self, value: bool) -> Self {
        self.inner.use_combined_image_sampler_index = value as u32;
        self
    }
    #[inline]
    pub fn sampler_heap_offset(mut self, value: u32) -> Self {
        self.inner.sampler_heap_offset = value;
        self
    }
    #[inline]
    pub fn sampler_push_offset(mut self, value: u32) -> Self {
        self.inner.sampler_push_offset = value;
        self
    }
    #[inline]
    pub fn sampler_address_offset(mut self, value: u32) -> Self {
        self.inner.sampler_address_offset = value;
        self
    }
    #[inline]
    pub fn sampler_heap_index_stride(mut self, value: u32) -> Self {
        self.inner.sampler_heap_index_stride = value;
        self
    }
    #[inline]
    pub fn sampler_heap_array_stride(mut self, value: u32) -> Self {
        self.inner.sampler_heap_array_stride = value;
        self
    }
}
impl<'a> core::ops::Deref for DescriptorMappingSourceIndirectIndexEXTBuilder<'a> {
    type Target = DescriptorMappingSourceIndirectIndexEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for DescriptorMappingSourceIndirectIndexEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DescriptorMappingSourceIndirectIndexArrayEXT`].
pub struct DescriptorMappingSourceIndirectIndexArrayEXTBuilder<'a> {
    inner: DescriptorMappingSourceIndirectIndexArrayEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DescriptorMappingSourceIndirectIndexArrayEXT {
    /// Start building this struct.
    #[inline]
    pub fn builder<'a>() -> DescriptorMappingSourceIndirectIndexArrayEXTBuilder<'a> {
        DescriptorMappingSourceIndirectIndexArrayEXTBuilder {
            inner: DescriptorMappingSourceIndirectIndexArrayEXT {
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DescriptorMappingSourceIndirectIndexArrayEXTBuilder<'a> {
    #[inline]
    pub fn heap_offset(mut self, value: u32) -> Self {
        self.inner.heap_offset = value;
        self
    }
    #[inline]
    pub fn push_offset(mut self, value: u32) -> Self {
        self.inner.push_offset = value;
        self
    }
    #[inline]
    pub fn address_offset(mut self, value: u32) -> Self {
        self.inner.address_offset = value;
        self
    }
    #[inline]
    pub fn heap_index_stride(mut self, value: u32) -> Self {
        self.inner.heap_index_stride = value;
        self
    }
    #[inline]
    pub fn embedded_sampler(mut self, value: &'a SamplerCreateInfo) -> Self {
        self.inner.p_embedded_sampler = value;
        self
    }
    #[inline]
    pub fn use_combined_image_sampler_index(mut self, value: bool) -> Self {
        self.inner.use_combined_image_sampler_index = value as u32;
        self
    }
    #[inline]
    pub fn sampler_heap_offset(mut self, value: u32) -> Self {
        self.inner.sampler_heap_offset = value;
        self
    }
    #[inline]
    pub fn sampler_push_offset(mut self, value: u32) -> Self {
        self.inner.sampler_push_offset = value;
        self
    }
    #[inline]
    pub fn sampler_address_offset(mut self, value: u32) -> Self {
        self.inner.sampler_address_offset = value;
        self
    }
    #[inline]
    pub fn sampler_heap_index_stride(mut self, value: u32) -> Self {
        self.inner.sampler_heap_index_stride = value;
        self
    }
}
impl<'a> core::ops::Deref for DescriptorMappingSourceIndirectIndexArrayEXTBuilder<'a> {
    type Target = DescriptorMappingSourceIndirectIndexArrayEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for DescriptorMappingSourceIndirectIndexArrayEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DescriptorMappingSourceHeapDataEXT`].
pub struct DescriptorMappingSourceHeapDataEXTBuilder {
    inner: DescriptorMappingSourceHeapDataEXT,
}
impl DescriptorMappingSourceHeapDataEXT {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> DescriptorMappingSourceHeapDataEXTBuilder {
        DescriptorMappingSourceHeapDataEXTBuilder {
            inner: DescriptorMappingSourceHeapDataEXT {
                ..Default::default()
            },
        }
    }
}
impl DescriptorMappingSourceHeapDataEXTBuilder {
    #[inline]
    pub fn heap_offset(mut self, value: u32) -> Self {
        self.inner.heap_offset = value;
        self
    }
    #[inline]
    pub fn push_offset(mut self, value: u32) -> Self {
        self.inner.push_offset = value;
        self
    }
}
impl core::ops::Deref for DescriptorMappingSourceHeapDataEXTBuilder {
    type Target = DescriptorMappingSourceHeapDataEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for DescriptorMappingSourceHeapDataEXTBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DescriptorMappingSourceShaderRecordIndexEXT`].
pub struct DescriptorMappingSourceShaderRecordIndexEXTBuilder<'a> {
    inner: DescriptorMappingSourceShaderRecordIndexEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DescriptorMappingSourceShaderRecordIndexEXT {
    /// Start building this struct.
    #[inline]
    pub fn builder<'a>() -> DescriptorMappingSourceShaderRecordIndexEXTBuilder<'a> {
        DescriptorMappingSourceShaderRecordIndexEXTBuilder {
            inner: DescriptorMappingSourceShaderRecordIndexEXT {
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DescriptorMappingSourceShaderRecordIndexEXTBuilder<'a> {
    #[inline]
    pub fn heap_offset(mut self, value: u32) -> Self {
        self.inner.heap_offset = value;
        self
    }
    #[inline]
    pub fn shader_record_offset(mut self, value: u32) -> Self {
        self.inner.shader_record_offset = value;
        self
    }
    #[inline]
    pub fn heap_index_stride(mut self, value: u32) -> Self {
        self.inner.heap_index_stride = value;
        self
    }
    #[inline]
    pub fn heap_array_stride(mut self, value: u32) -> Self {
        self.inner.heap_array_stride = value;
        self
    }
    #[inline]
    pub fn embedded_sampler(mut self, value: &'a SamplerCreateInfo) -> Self {
        self.inner.p_embedded_sampler = value;
        self
    }
    #[inline]
    pub fn use_combined_image_sampler_index(mut self, value: bool) -> Self {
        self.inner.use_combined_image_sampler_index = value as u32;
        self
    }
    #[inline]
    pub fn sampler_heap_offset(mut self, value: u32) -> Self {
        self.inner.sampler_heap_offset = value;
        self
    }
    #[inline]
    pub fn sampler_shader_record_offset(mut self, value: u32) -> Self {
        self.inner.sampler_shader_record_offset = value;
        self
    }
    #[inline]
    pub fn sampler_heap_index_stride(mut self, value: u32) -> Self {
        self.inner.sampler_heap_index_stride = value;
        self
    }
    #[inline]
    pub fn sampler_heap_array_stride(mut self, value: u32) -> Self {
        self.inner.sampler_heap_array_stride = value;
        self
    }
}
impl<'a> core::ops::Deref for DescriptorMappingSourceShaderRecordIndexEXTBuilder<'a> {
    type Target = DescriptorMappingSourceShaderRecordIndexEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for DescriptorMappingSourceShaderRecordIndexEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DescriptorMappingSourceIndirectAddressEXT`].
pub struct DescriptorMappingSourceIndirectAddressEXTBuilder {
    inner: DescriptorMappingSourceIndirectAddressEXT,
}
impl DescriptorMappingSourceIndirectAddressEXT {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> DescriptorMappingSourceIndirectAddressEXTBuilder {
        DescriptorMappingSourceIndirectAddressEXTBuilder {
            inner: DescriptorMappingSourceIndirectAddressEXT {
                ..Default::default()
            },
        }
    }
}
impl DescriptorMappingSourceIndirectAddressEXTBuilder {
    #[inline]
    pub fn push_offset(mut self, value: u32) -> Self {
        self.inner.push_offset = value;
        self
    }
    #[inline]
    pub fn address_offset(mut self, value: u32) -> Self {
        self.inner.address_offset = value;
        self
    }
}
impl core::ops::Deref for DescriptorMappingSourceIndirectAddressEXTBuilder {
    type Target = DescriptorMappingSourceIndirectAddressEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for DescriptorMappingSourceIndirectAddressEXTBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DescriptorSetAndBindingMappingEXT`] with lifetime-tied pNext safety.
pub struct DescriptorSetAndBindingMappingEXTBuilder<'a> {
    inner: DescriptorSetAndBindingMappingEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DescriptorSetAndBindingMappingEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> DescriptorSetAndBindingMappingEXTBuilder<'a> {
        DescriptorSetAndBindingMappingEXTBuilder {
            inner: DescriptorSetAndBindingMappingEXT {
                s_type: StructureType::from_raw(1000135005i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DescriptorSetAndBindingMappingEXTBuilder<'a> {
    #[inline]
    pub fn descriptor_set(mut self, value: u32) -> Self {
        self.inner.descriptor_set = value;
        self
    }
    #[inline]
    pub fn first_binding(mut self, value: u32) -> Self {
        self.inner.first_binding = value;
        self
    }
    #[inline]
    pub fn binding_count(mut self, value: u32) -> Self {
        self.inner.binding_count = value;
        self
    }
    #[inline]
    pub fn resource_mask(mut self, value: SpirvResourceTypeFlagsEXT) -> Self {
        self.inner.resource_mask = value;
        self
    }
    #[inline]
    pub fn source(mut self, value: DescriptorMappingSourceEXT) -> Self {
        self.inner.source = value;
        self
    }
    #[inline]
    pub fn source_data(mut self, value: DescriptorMappingSourceDataEXT) -> Self {
        self.inner.source_data = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`DescriptorSetAndBindingMappingEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsDescriptorSetAndBindingMappingEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for DescriptorSetAndBindingMappingEXTBuilder<'a> {
    type Target = DescriptorSetAndBindingMappingEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for DescriptorSetAndBindingMappingEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ShaderDescriptorSetAndBindingMappingInfoEXT`] with lifetime-tied pNext safety.
pub struct ShaderDescriptorSetAndBindingMappingInfoEXTBuilder<'a> {
    inner: ShaderDescriptorSetAndBindingMappingInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ShaderDescriptorSetAndBindingMappingInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ShaderDescriptorSetAndBindingMappingInfoEXTBuilder<'a> {
        ShaderDescriptorSetAndBindingMappingInfoEXTBuilder {
            inner: ShaderDescriptorSetAndBindingMappingInfoEXT {
                s_type: StructureType::from_raw(1000135006i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ShaderDescriptorSetAndBindingMappingInfoEXTBuilder<'a> {
    #[inline]
    pub fn mappings(mut self, slice: &'a [DescriptorSetAndBindingMappingEXT]) -> Self {
        self.inner.mapping_count = slice.len() as u32;
        self.inner.p_mappings = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`ShaderDescriptorSetAndBindingMappingInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsShaderDescriptorSetAndBindingMappingInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for ShaderDescriptorSetAndBindingMappingInfoEXTBuilder<'a> {
    type Target = ShaderDescriptorSetAndBindingMappingInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ShaderDescriptorSetAndBindingMappingInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`SamplerCustomBorderColorIndexCreateInfoEXT`] with lifetime-tied pNext safety.
pub struct SamplerCustomBorderColorIndexCreateInfoEXTBuilder<'a> {
    inner: SamplerCustomBorderColorIndexCreateInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl SamplerCustomBorderColorIndexCreateInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> SamplerCustomBorderColorIndexCreateInfoEXTBuilder<'a> {
        SamplerCustomBorderColorIndexCreateInfoEXTBuilder {
            inner: SamplerCustomBorderColorIndexCreateInfoEXT {
                s_type: StructureType::from_raw(1000135011i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> SamplerCustomBorderColorIndexCreateInfoEXTBuilder<'a> {
    #[inline]
    pub fn index(mut self, value: u32) -> Self {
        self.inner.index = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`SamplerCustomBorderColorIndexCreateInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsSamplerCustomBorderColorIndexCreateInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for SamplerCustomBorderColorIndexCreateInfoEXTBuilder<'a> {
    type Target = SamplerCustomBorderColorIndexCreateInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for SamplerCustomBorderColorIndexCreateInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`OpaqueCaptureDataCreateInfoEXT`] with lifetime-tied pNext safety.
pub struct OpaqueCaptureDataCreateInfoEXTBuilder<'a> {
    inner: OpaqueCaptureDataCreateInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl OpaqueCaptureDataCreateInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> OpaqueCaptureDataCreateInfoEXTBuilder<'a> {
        OpaqueCaptureDataCreateInfoEXTBuilder {
            inner: OpaqueCaptureDataCreateInfoEXT {
                s_type: StructureType::from_raw(1000135007i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> OpaqueCaptureDataCreateInfoEXTBuilder<'a> {
    #[inline]
    pub fn data(mut self, value: &'a HostAddressRangeConstEXT) -> Self {
        self.inner.p_data = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`OpaqueCaptureDataCreateInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsOpaqueCaptureDataCreateInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for OpaqueCaptureDataCreateInfoEXTBuilder<'a> {
    type Target = OpaqueCaptureDataCreateInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for OpaqueCaptureDataCreateInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`IndirectCommandsLayoutPushDataTokenNV`] with lifetime-tied pNext safety.
pub struct IndirectCommandsLayoutPushDataTokenNVBuilder<'a> {
    inner: IndirectCommandsLayoutPushDataTokenNV,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl IndirectCommandsLayoutPushDataTokenNV {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> IndirectCommandsLayoutPushDataTokenNVBuilder<'a> {
        IndirectCommandsLayoutPushDataTokenNVBuilder {
            inner: IndirectCommandsLayoutPushDataTokenNV {
                s_type: StructureType::from_raw(1000135012i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> IndirectCommandsLayoutPushDataTokenNVBuilder<'a> {
    #[inline]
    pub fn push_data_offset(mut self, value: u32) -> Self {
        self.inner.push_data_offset = value;
        self
    }
    #[inline]
    pub fn push_data_size(mut self, value: u32) -> Self {
        self.inner.push_data_size = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`IndirectCommandsLayoutPushDataTokenNV`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsIndirectCommandsLayoutPushDataTokenNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for IndirectCommandsLayoutPushDataTokenNVBuilder<'a> {
    type Target = IndirectCommandsLayoutPushDataTokenNV;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for IndirectCommandsLayoutPushDataTokenNVBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`SubsampledImageFormatPropertiesEXT`] with lifetime-tied pNext safety.
pub struct SubsampledImageFormatPropertiesEXTBuilder<'a> {
    inner: SubsampledImageFormatPropertiesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl SubsampledImageFormatPropertiesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> SubsampledImageFormatPropertiesEXTBuilder<'a> {
        SubsampledImageFormatPropertiesEXTBuilder {
            inner: SubsampledImageFormatPropertiesEXT {
                s_type: StructureType::from_raw(1000135013i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> SubsampledImageFormatPropertiesEXTBuilder<'a> {
    #[inline]
    pub fn subsampled_image_descriptor_count(mut self, value: u32) -> Self {
        self.inner.subsampled_image_descriptor_count = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`SubsampledImageFormatPropertiesEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsSubsampledImageFormatPropertiesEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for SubsampledImageFormatPropertiesEXTBuilder<'a> {
    type Target = SubsampledImageFormatPropertiesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for SubsampledImageFormatPropertiesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceDescriptorHeapFeaturesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceDescriptorHeapFeaturesEXTBuilder<'a> {
    inner: PhysicalDeviceDescriptorHeapFeaturesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceDescriptorHeapFeaturesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceDescriptorHeapFeaturesEXTBuilder<'a> {
        PhysicalDeviceDescriptorHeapFeaturesEXTBuilder {
            inner: PhysicalDeviceDescriptorHeapFeaturesEXT {
                s_type: StructureType::from_raw(1000135009i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceDescriptorHeapFeaturesEXTBuilder<'a> {
    #[inline]
    pub fn descriptor_heap(mut self, value: bool) -> Self {
        self.inner.descriptor_heap = value as u32;
        self
    }
    #[inline]
    pub fn descriptor_heap_capture_replay(mut self, value: bool) -> Self {
        self.inner.descriptor_heap_capture_replay = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceDescriptorHeapFeaturesEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceDescriptorHeapFeaturesEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceDescriptorHeapFeaturesEXTBuilder<'a> {
    type Target = PhysicalDeviceDescriptorHeapFeaturesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceDescriptorHeapFeaturesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceDescriptorHeapPropertiesEXT`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceDescriptorHeapPropertiesEXTBuilder<'a> {
    inner: PhysicalDeviceDescriptorHeapPropertiesEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceDescriptorHeapPropertiesEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceDescriptorHeapPropertiesEXTBuilder<'a> {
        PhysicalDeviceDescriptorHeapPropertiesEXTBuilder {
            inner: PhysicalDeviceDescriptorHeapPropertiesEXT {
                s_type: StructureType::from_raw(1000135008i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceDescriptorHeapPropertiesEXTBuilder<'a> {
    #[inline]
    pub fn sampler_heap_alignment(mut self, value: u64) -> Self {
        self.inner.sampler_heap_alignment = value;
        self
    }
    #[inline]
    pub fn resource_heap_alignment(mut self, value: u64) -> Self {
        self.inner.resource_heap_alignment = value;
        self
    }
    #[inline]
    pub fn max_sampler_heap_size(mut self, value: u64) -> Self {
        self.inner.max_sampler_heap_size = value;
        self
    }
    #[inline]
    pub fn max_resource_heap_size(mut self, value: u64) -> Self {
        self.inner.max_resource_heap_size = value;
        self
    }
    #[inline]
    pub fn min_sampler_heap_reserved_range(mut self, value: u64) -> Self {
        self.inner.min_sampler_heap_reserved_range = value;
        self
    }
    #[inline]
    pub fn min_sampler_heap_reserved_range_with_embedded(mut self, value: u64) -> Self {
        self.inner.min_sampler_heap_reserved_range_with_embedded = value;
        self
    }
    #[inline]
    pub fn min_resource_heap_reserved_range(mut self, value: u64) -> Self {
        self.inner.min_resource_heap_reserved_range = value;
        self
    }
    #[inline]
    pub fn sampler_descriptor_size(mut self, value: u64) -> Self {
        self.inner.sampler_descriptor_size = value;
        self
    }
    #[inline]
    pub fn image_descriptor_size(mut self, value: u64) -> Self {
        self.inner.image_descriptor_size = value;
        self
    }
    #[inline]
    pub fn buffer_descriptor_size(mut self, value: u64) -> Self {
        self.inner.buffer_descriptor_size = value;
        self
    }
    #[inline]
    pub fn sampler_descriptor_alignment(mut self, value: u64) -> Self {
        self.inner.sampler_descriptor_alignment = value;
        self
    }
    #[inline]
    pub fn image_descriptor_alignment(mut self, value: u64) -> Self {
        self.inner.image_descriptor_alignment = value;
        self
    }
    #[inline]
    pub fn buffer_descriptor_alignment(mut self, value: u64) -> Self {
        self.inner.buffer_descriptor_alignment = value;
        self
    }
    #[inline]
    pub fn max_push_data_size(mut self, value: u64) -> Self {
        self.inner.max_push_data_size = value;
        self
    }
    #[inline]
    pub fn image_capture_replay_opaque_data_size(mut self, value: usize) -> Self {
        self.inner.image_capture_replay_opaque_data_size = value;
        self
    }
    #[inline]
    pub fn max_descriptor_heap_embedded_samplers(mut self, value: u32) -> Self {
        self.inner.max_descriptor_heap_embedded_samplers = value;
        self
    }
    #[inline]
    pub fn sampler_ycbcr_conversion_count(mut self, value: u32) -> Self {
        self.inner.sampler_ycbcr_conversion_count = value;
        self
    }
    #[inline]
    pub fn sparse_descriptor_heaps(mut self, value: bool) -> Self {
        self.inner.sparse_descriptor_heaps = value as u32;
        self
    }
    #[inline]
    pub fn protected_descriptor_heaps(mut self, value: bool) -> Self {
        self.inner.protected_descriptor_heaps = value as u32;
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceDescriptorHeapPropertiesEXTBuilder<'a> {
    type Target = PhysicalDeviceDescriptorHeapPropertiesEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceDescriptorHeapPropertiesEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`CommandBufferInheritanceDescriptorHeapInfoEXT`] with lifetime-tied pNext safety.
pub struct CommandBufferInheritanceDescriptorHeapInfoEXTBuilder<'a> {
    inner: CommandBufferInheritanceDescriptorHeapInfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl CommandBufferInheritanceDescriptorHeapInfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> CommandBufferInheritanceDescriptorHeapInfoEXTBuilder<'a> {
        CommandBufferInheritanceDescriptorHeapInfoEXTBuilder {
            inner: CommandBufferInheritanceDescriptorHeapInfoEXT {
                s_type: StructureType::from_raw(1000135010i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> CommandBufferInheritanceDescriptorHeapInfoEXTBuilder<'a> {
    #[inline]
    pub fn sampler_heap_bind_info(mut self, value: &'a BindHeapInfoEXT) -> Self {
        self.inner.p_sampler_heap_bind_info = value;
        self
    }
    #[inline]
    pub fn resource_heap_bind_info(mut self, value: &'a BindHeapInfoEXT) -> Self {
        self.inner.p_resource_heap_bind_info = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`CommandBufferInheritanceDescriptorHeapInfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsCommandBufferInheritanceDescriptorHeapInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for CommandBufferInheritanceDescriptorHeapInfoEXTBuilder<'a> {
    type Target = CommandBufferInheritanceDescriptorHeapInfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for CommandBufferInheritanceDescriptorHeapInfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceDescriptorHeapTensorPropertiesARM`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceDescriptorHeapTensorPropertiesARMBuilder<'a> {
    inner: PhysicalDeviceDescriptorHeapTensorPropertiesARM,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceDescriptorHeapTensorPropertiesARM {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceDescriptorHeapTensorPropertiesARMBuilder<'a> {
        PhysicalDeviceDescriptorHeapTensorPropertiesARMBuilder {
            inner: PhysicalDeviceDescriptorHeapTensorPropertiesARM {
                s_type: StructureType::from_raw(1000135014i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceDescriptorHeapTensorPropertiesARMBuilder<'a> {
    #[inline]
    pub fn tensor_descriptor_size(mut self, value: u64) -> Self {
        self.inner.tensor_descriptor_size = value;
        self
    }
    #[inline]
    pub fn tensor_descriptor_alignment(mut self, value: u64) -> Self {
        self.inner.tensor_descriptor_alignment = value;
        self
    }
    #[inline]
    pub fn tensor_capture_replay_opaque_data_size(mut self, value: usize) -> Self {
        self.inner.tensor_capture_replay_opaque_data_size = value;
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDeviceDescriptorHeapTensorPropertiesARMBuilder<'a> {
    type Target = PhysicalDeviceDescriptorHeapTensorPropertiesARM;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceDescriptorHeapTensorPropertiesARMBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceShaderInstrumentationFeaturesARM`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceShaderInstrumentationFeaturesARMBuilder<'a> {
    inner: PhysicalDeviceShaderInstrumentationFeaturesARM,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceShaderInstrumentationFeaturesARM {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceShaderInstrumentationFeaturesARMBuilder<'a> {
        PhysicalDeviceShaderInstrumentationFeaturesARMBuilder {
            inner: PhysicalDeviceShaderInstrumentationFeaturesARM {
                s_type: StructureType::from_raw(1000607000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceShaderInstrumentationFeaturesARMBuilder<'a> {
    #[inline]
    pub fn shader_instrumentation(mut self, value: bool) -> Self {
        self.inner.shader_instrumentation = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceShaderInstrumentationFeaturesARM`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceShaderInstrumentationFeaturesARM>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceShaderInstrumentationFeaturesARMBuilder<'a> {
    type Target = PhysicalDeviceShaderInstrumentationFeaturesARM;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceShaderInstrumentationFeaturesARMBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceShaderInstrumentationPropertiesARM`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceShaderInstrumentationPropertiesARMBuilder<'a> {
    inner: PhysicalDeviceShaderInstrumentationPropertiesARM,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceShaderInstrumentationPropertiesARM {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceShaderInstrumentationPropertiesARMBuilder<'a> {
        PhysicalDeviceShaderInstrumentationPropertiesARMBuilder {
            inner: PhysicalDeviceShaderInstrumentationPropertiesARM {
                s_type: StructureType::from_raw(1000607001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceShaderInstrumentationPropertiesARMBuilder<'a> {
    #[inline]
    pub fn num_metrics(mut self, value: u32) -> Self {
        self.inner.num_metrics = value;
        self
    }
    #[inline]
    pub fn per_basic_block_granularity(mut self, value: bool) -> Self {
        self.inner.per_basic_block_granularity = value as u32;
        self
    }
}
impl<'a> core::ops::Deref
for PhysicalDeviceShaderInstrumentationPropertiesARMBuilder<'a> {
    type Target = PhysicalDeviceShaderInstrumentationPropertiesARM;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceShaderInstrumentationPropertiesARMBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ShaderInstrumentationCreateInfoARM`] with lifetime-tied pNext safety.
pub struct ShaderInstrumentationCreateInfoARMBuilder<'a> {
    inner: ShaderInstrumentationCreateInfoARM,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ShaderInstrumentationCreateInfoARM {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ShaderInstrumentationCreateInfoARMBuilder<'a> {
        ShaderInstrumentationCreateInfoARMBuilder {
            inner: ShaderInstrumentationCreateInfoARM {
                s_type: StructureType::from_raw(1000607002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ShaderInstrumentationCreateInfoARMBuilder<'a> {
    ///Prepend a struct to the pNext chain. See [`ShaderInstrumentationCreateInfoARM`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsShaderInstrumentationCreateInfoARM>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for ShaderInstrumentationCreateInfoARMBuilder<'a> {
    type Target = ShaderInstrumentationCreateInfoARM;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ShaderInstrumentationCreateInfoARMBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ShaderInstrumentationMetricDescriptionARM`] with lifetime-tied pNext safety.
pub struct ShaderInstrumentationMetricDescriptionARMBuilder<'a> {
    inner: ShaderInstrumentationMetricDescriptionARM,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ShaderInstrumentationMetricDescriptionARM {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ShaderInstrumentationMetricDescriptionARMBuilder<'a> {
        ShaderInstrumentationMetricDescriptionARMBuilder {
            inner: ShaderInstrumentationMetricDescriptionARM {
                s_type: StructureType::from_raw(1000607003i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ShaderInstrumentationMetricDescriptionARMBuilder<'a> {
    #[inline]
    pub fn name(
        mut self,
        value: crate::StringArray<{ MAX_DESCRIPTION_SIZE as usize }>,
    ) -> Self {
        self.inner.name = value;
        self
    }
    #[inline]
    pub fn description(
        mut self,
        value: crate::StringArray<{ MAX_DESCRIPTION_SIZE as usize }>,
    ) -> Self {
        self.inner.description = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`ShaderInstrumentationMetricDescriptionARM`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsShaderInstrumentationMetricDescriptionARM>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for ShaderInstrumentationMetricDescriptionARMBuilder<'a> {
    type Target = ShaderInstrumentationMetricDescriptionARM;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ShaderInstrumentationMetricDescriptionARMBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ShaderInstrumentationMetricDataHeaderARM`].
pub struct ShaderInstrumentationMetricDataHeaderARMBuilder {
    inner: ShaderInstrumentationMetricDataHeaderARM,
}
impl ShaderInstrumentationMetricDataHeaderARM {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> ShaderInstrumentationMetricDataHeaderARMBuilder {
        ShaderInstrumentationMetricDataHeaderARMBuilder {
            inner: ShaderInstrumentationMetricDataHeaderARM {
                ..Default::default()
            },
        }
    }
}
impl ShaderInstrumentationMetricDataHeaderARMBuilder {
    #[inline]
    pub fn result_index(mut self, value: u32) -> Self {
        self.inner.result_index = value;
        self
    }
    #[inline]
    pub fn result_sub_index(mut self, value: u32) -> Self {
        self.inner.result_sub_index = value;
        self
    }
    #[inline]
    pub fn stages(mut self, value: ShaderStageFlags) -> Self {
        self.inner.stages = value;
        self
    }
    #[inline]
    pub fn basic_block_index(mut self, value: u32) -> Self {
        self.inner.basic_block_index = value;
        self
    }
}
impl core::ops::Deref for ShaderInstrumentationMetricDataHeaderARMBuilder {
    type Target = ShaderInstrumentationMetricDataHeaderARM;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for ShaderInstrumentationMetricDataHeaderARMBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DeviceAddressRangeKHR`].
pub struct DeviceAddressRangeKHRBuilder {
    inner: DeviceAddressRangeKHR,
}
impl DeviceAddressRangeKHR {
    /// Start building this struct.
    #[inline]
    pub fn builder() -> DeviceAddressRangeKHRBuilder {
        DeviceAddressRangeKHRBuilder {
            inner: DeviceAddressRangeKHR {
                ..Default::default()
            },
        }
    }
}
impl DeviceAddressRangeKHRBuilder {
    #[inline]
    pub fn address(mut self, value: u64) -> Self {
        self.inner.address = value;
        self
    }
    #[inline]
    pub fn size(mut self, value: u64) -> Self {
        self.inner.size = value;
        self
    }
}
impl core::ops::Deref for DeviceAddressRangeKHRBuilder {
    type Target = DeviceAddressRangeKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl core::ops::DerefMut for DeviceAddressRangeKHRBuilder {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DeviceMemoryCopyKHR`] with lifetime-tied pNext safety.
pub struct DeviceMemoryCopyKHRBuilder<'a> {
    inner: DeviceMemoryCopyKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DeviceMemoryCopyKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> DeviceMemoryCopyKHRBuilder<'a> {
        DeviceMemoryCopyKHRBuilder {
            inner: DeviceMemoryCopyKHR {
                s_type: StructureType::from_raw(1000318000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DeviceMemoryCopyKHRBuilder<'a> {
    #[inline]
    pub fn src_range(mut self, value: DeviceAddressRangeKHR) -> Self {
        self.inner.src_range = value;
        self
    }
    #[inline]
    pub fn src_flags(mut self, value: AddressCommandFlagsKHR) -> Self {
        self.inner.src_flags = value;
        self
    }
    #[inline]
    pub fn dst_range(mut self, value: DeviceAddressRangeKHR) -> Self {
        self.inner.dst_range = value;
        self
    }
    #[inline]
    pub fn dst_flags(mut self, value: AddressCommandFlagsKHR) -> Self {
        self.inner.dst_flags = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`DeviceMemoryCopyKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsDeviceMemoryCopyKHR>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for DeviceMemoryCopyKHRBuilder<'a> {
    type Target = DeviceMemoryCopyKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for DeviceMemoryCopyKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`CopyDeviceMemoryInfoKHR`] with lifetime-tied pNext safety.
pub struct CopyDeviceMemoryInfoKHRBuilder<'a> {
    inner: CopyDeviceMemoryInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl CopyDeviceMemoryInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> CopyDeviceMemoryInfoKHRBuilder<'a> {
        CopyDeviceMemoryInfoKHRBuilder {
            inner: CopyDeviceMemoryInfoKHR {
                s_type: StructureType::from_raw(1000318001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> CopyDeviceMemoryInfoKHRBuilder<'a> {
    #[inline]
    pub fn regions(mut self, slice: &'a [DeviceMemoryCopyKHR]) -> Self {
        self.inner.region_count = slice.len() as u32;
        self.inner.p_regions = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`CopyDeviceMemoryInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsCopyDeviceMemoryInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for CopyDeviceMemoryInfoKHRBuilder<'a> {
    type Target = CopyDeviceMemoryInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for CopyDeviceMemoryInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DeviceMemoryImageCopyKHR`] with lifetime-tied pNext safety.
pub struct DeviceMemoryImageCopyKHRBuilder<'a> {
    inner: DeviceMemoryImageCopyKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DeviceMemoryImageCopyKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> DeviceMemoryImageCopyKHRBuilder<'a> {
        DeviceMemoryImageCopyKHRBuilder {
            inner: DeviceMemoryImageCopyKHR {
                s_type: StructureType::from_raw(1000318002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DeviceMemoryImageCopyKHRBuilder<'a> {
    #[inline]
    pub fn address_range(mut self, value: DeviceAddressRangeKHR) -> Self {
        self.inner.address_range = value;
        self
    }
    #[inline]
    pub fn address_flags(mut self, value: AddressCommandFlagsKHR) -> Self {
        self.inner.address_flags = value;
        self
    }
    #[inline]
    pub fn address_row_length(mut self, value: u32) -> Self {
        self.inner.address_row_length = value;
        self
    }
    #[inline]
    pub fn address_image_height(mut self, value: u32) -> Self {
        self.inner.address_image_height = value;
        self
    }
    #[inline]
    pub fn image_subresource(mut self, value: ImageSubresourceLayers) -> Self {
        self.inner.image_subresource = value;
        self
    }
    #[inline]
    pub fn image_layout(mut self, value: ImageLayout) -> Self {
        self.inner.image_layout = value;
        self
    }
    #[inline]
    pub fn image_offset(mut self, value: Offset3D) -> Self {
        self.inner.image_offset = value;
        self
    }
    #[inline]
    pub fn image_extent(mut self, value: Extent3D) -> Self {
        self.inner.image_extent = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`DeviceMemoryImageCopyKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsDeviceMemoryImageCopyKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for DeviceMemoryImageCopyKHRBuilder<'a> {
    type Target = DeviceMemoryImageCopyKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for DeviceMemoryImageCopyKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`CopyDeviceMemoryImageInfoKHR`] with lifetime-tied pNext safety.
pub struct CopyDeviceMemoryImageInfoKHRBuilder<'a> {
    inner: CopyDeviceMemoryImageInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl CopyDeviceMemoryImageInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> CopyDeviceMemoryImageInfoKHRBuilder<'a> {
        CopyDeviceMemoryImageInfoKHRBuilder {
            inner: CopyDeviceMemoryImageInfoKHR {
                s_type: StructureType::from_raw(1000318003i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> CopyDeviceMemoryImageInfoKHRBuilder<'a> {
    #[inline]
    pub fn image(mut self, value: Image) -> Self {
        self.inner.image = value;
        self
    }
    #[inline]
    pub fn regions(mut self, slice: &'a [DeviceMemoryImageCopyKHR]) -> Self {
        self.inner.region_count = slice.len() as u32;
        self.inner.p_regions = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`CopyDeviceMemoryImageInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsCopyDeviceMemoryImageInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for CopyDeviceMemoryImageInfoKHRBuilder<'a> {
    type Target = CopyDeviceMemoryImageInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for CopyDeviceMemoryImageInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`MemoryRangeBarriersInfoKHR`] with lifetime-tied pNext safety.
pub struct MemoryRangeBarriersInfoKHRBuilder<'a> {
    inner: MemoryRangeBarriersInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl MemoryRangeBarriersInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> MemoryRangeBarriersInfoKHRBuilder<'a> {
        MemoryRangeBarriersInfoKHRBuilder {
            inner: MemoryRangeBarriersInfoKHR {
                s_type: StructureType::from_raw(1000318004i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> MemoryRangeBarriersInfoKHRBuilder<'a> {
    #[inline]
    pub fn memory_range_barriers(mut self, slice: &'a [MemoryRangeBarrierKHR]) -> Self {
        self.inner.memory_range_barrier_count = slice.len() as u32;
        self.inner.p_memory_range_barriers = slice.as_ptr();
        self
    }
    ///Prepend a struct to the pNext chain. See [`MemoryRangeBarriersInfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsMemoryRangeBarriersInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for MemoryRangeBarriersInfoKHRBuilder<'a> {
    type Target = MemoryRangeBarriersInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for MemoryRangeBarriersInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`MemoryRangeBarrierKHR`] with lifetime-tied pNext safety.
pub struct MemoryRangeBarrierKHRBuilder<'a> {
    inner: MemoryRangeBarrierKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl MemoryRangeBarrierKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> MemoryRangeBarrierKHRBuilder<'a> {
        MemoryRangeBarrierKHRBuilder {
            inner: MemoryRangeBarrierKHR {
                s_type: StructureType::from_raw(1000318005i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> MemoryRangeBarrierKHRBuilder<'a> {
    #[inline]
    pub fn src_stage_mask(mut self, value: PipelineStageFlags2) -> Self {
        self.inner.src_stage_mask = value;
        self
    }
    #[inline]
    pub fn src_access_mask(mut self, value: AccessFlags2) -> Self {
        self.inner.src_access_mask = value;
        self
    }
    #[inline]
    pub fn dst_stage_mask(mut self, value: PipelineStageFlags2) -> Self {
        self.inner.dst_stage_mask = value;
        self
    }
    #[inline]
    pub fn dst_access_mask(mut self, value: AccessFlags2) -> Self {
        self.inner.dst_access_mask = value;
        self
    }
    #[inline]
    pub fn src_queue_family_index(mut self, value: u32) -> Self {
        self.inner.src_queue_family_index = value;
        self
    }
    #[inline]
    pub fn dst_queue_family_index(mut self, value: u32) -> Self {
        self.inner.dst_queue_family_index = value;
        self
    }
    #[inline]
    pub fn address_range(mut self, value: DeviceAddressRangeKHR) -> Self {
        self.inner.address_range = value;
        self
    }
    #[inline]
    pub fn address_flags(mut self, value: AddressCommandFlagsKHR) -> Self {
        self.inner.address_flags = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`MemoryRangeBarrierKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsMemoryRangeBarrierKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for MemoryRangeBarrierKHRBuilder<'a> {
    type Target = MemoryRangeBarrierKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for MemoryRangeBarrierKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceDeviceAddressCommandsFeaturesKHR`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceDeviceAddressCommandsFeaturesKHRBuilder<'a> {
    inner: PhysicalDeviceDeviceAddressCommandsFeaturesKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceDeviceAddressCommandsFeaturesKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceDeviceAddressCommandsFeaturesKHRBuilder<'a> {
        PhysicalDeviceDeviceAddressCommandsFeaturesKHRBuilder {
            inner: PhysicalDeviceDeviceAddressCommandsFeaturesKHR {
                s_type: StructureType::from_raw(1000318006i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceDeviceAddressCommandsFeaturesKHRBuilder<'a> {
    #[inline]
    pub fn device_address_commands(mut self, value: bool) -> Self {
        self.inner.device_address_commands = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceDeviceAddressCommandsFeaturesKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceDeviceAddressCommandsFeaturesKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceDeviceAddressCommandsFeaturesKHRBuilder<'a> {
    type Target = PhysicalDeviceDeviceAddressCommandsFeaturesKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut
for PhysicalDeviceDeviceAddressCommandsFeaturesKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`ConditionalRenderingBeginInfo2EXT`] with lifetime-tied pNext safety.
pub struct ConditionalRenderingBeginInfo2EXTBuilder<'a> {
    inner: ConditionalRenderingBeginInfo2EXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl ConditionalRenderingBeginInfo2EXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> ConditionalRenderingBeginInfo2EXTBuilder<'a> {
        ConditionalRenderingBeginInfo2EXTBuilder {
            inner: ConditionalRenderingBeginInfo2EXT {
                s_type: StructureType::from_raw(1000318012i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> ConditionalRenderingBeginInfo2EXTBuilder<'a> {
    #[inline]
    pub fn address_range(mut self, value: DeviceAddressRangeKHR) -> Self {
        self.inner.address_range = value;
        self
    }
    #[inline]
    pub fn address_flags(mut self, value: AddressCommandFlagsKHR) -> Self {
        self.inner.address_flags = value;
        self
    }
    #[inline]
    pub fn flags(mut self, value: ConditionalRenderingFlagsEXT) -> Self {
        self.inner.flags = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`ConditionalRenderingBeginInfo2EXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsConditionalRenderingBeginInfo2EXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for ConditionalRenderingBeginInfo2EXTBuilder<'a> {
    type Target = ConditionalRenderingBeginInfo2EXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for ConditionalRenderingBeginInfo2EXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`AccelerationStructureCreateInfo2KHR`] with lifetime-tied pNext safety.
pub struct AccelerationStructureCreateInfo2KHRBuilder<'a> {
    inner: AccelerationStructureCreateInfo2KHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl AccelerationStructureCreateInfo2KHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> AccelerationStructureCreateInfo2KHRBuilder<'a> {
        AccelerationStructureCreateInfo2KHRBuilder {
            inner: AccelerationStructureCreateInfo2KHR {
                s_type: StructureType::from_raw(1000318015i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> AccelerationStructureCreateInfo2KHRBuilder<'a> {
    #[inline]
    pub fn create_flags(mut self, value: AccelerationStructureCreateFlagsKHR) -> Self {
        self.inner.create_flags = value;
        self
    }
    #[inline]
    pub fn address_range(mut self, value: DeviceAddressRangeKHR) -> Self {
        self.inner.address_range = value;
        self
    }
    #[inline]
    pub fn address_flags(mut self, value: AddressCommandFlagsKHR) -> Self {
        self.inner.address_flags = value;
        self
    }
    #[inline]
    pub fn r#type(mut self, value: AccelerationStructureTypeKHR) -> Self {
        self.inner.r#type = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`AccelerationStructureCreateInfo2KHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsAccelerationStructureCreateInfo2KHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for AccelerationStructureCreateInfo2KHRBuilder<'a> {
    type Target = AccelerationStructureCreateInfo2KHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for AccelerationStructureCreateInfo2KHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`BindIndexBuffer3InfoKHR`] with lifetime-tied pNext safety.
pub struct BindIndexBuffer3InfoKHRBuilder<'a> {
    inner: BindIndexBuffer3InfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl BindIndexBuffer3InfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> BindIndexBuffer3InfoKHRBuilder<'a> {
        BindIndexBuffer3InfoKHRBuilder {
            inner: BindIndexBuffer3InfoKHR {
                s_type: StructureType::from_raw(1000318007i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> BindIndexBuffer3InfoKHRBuilder<'a> {
    #[inline]
    pub fn address_range(mut self, value: DeviceAddressRangeKHR) -> Self {
        self.inner.address_range = value;
        self
    }
    #[inline]
    pub fn address_flags(mut self, value: AddressCommandFlagsKHR) -> Self {
        self.inner.address_flags = value;
        self
    }
    #[inline]
    pub fn index_type(mut self, value: IndexType) -> Self {
        self.inner.index_type = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`BindIndexBuffer3InfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsBindIndexBuffer3InfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for BindIndexBuffer3InfoKHRBuilder<'a> {
    type Target = BindIndexBuffer3InfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for BindIndexBuffer3InfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`BindVertexBuffer3InfoKHR`] with lifetime-tied pNext safety.
pub struct BindVertexBuffer3InfoKHRBuilder<'a> {
    inner: BindVertexBuffer3InfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl BindVertexBuffer3InfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> BindVertexBuffer3InfoKHRBuilder<'a> {
        BindVertexBuffer3InfoKHRBuilder {
            inner: BindVertexBuffer3InfoKHR {
                s_type: StructureType::from_raw(1000318008i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> BindVertexBuffer3InfoKHRBuilder<'a> {
    #[inline]
    pub fn set_stride(mut self, value: bool) -> Self {
        self.inner.set_stride = value as u32;
        self
    }
    #[inline]
    pub fn address_range(mut self, value: StridedDeviceAddressRangeKHR) -> Self {
        self.inner.address_range = value;
        self
    }
    #[inline]
    pub fn address_flags(mut self, value: AddressCommandFlagsKHR) -> Self {
        self.inner.address_flags = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`BindVertexBuffer3InfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsBindVertexBuffer3InfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for BindVertexBuffer3InfoKHRBuilder<'a> {
    type Target = BindVertexBuffer3InfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for BindVertexBuffer3InfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DrawIndirect2InfoKHR`] with lifetime-tied pNext safety.
pub struct DrawIndirect2InfoKHRBuilder<'a> {
    inner: DrawIndirect2InfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DrawIndirect2InfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> DrawIndirect2InfoKHRBuilder<'a> {
        DrawIndirect2InfoKHRBuilder {
            inner: DrawIndirect2InfoKHR {
                s_type: StructureType::from_raw(1000318009i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DrawIndirect2InfoKHRBuilder<'a> {
    #[inline]
    pub fn address_range(mut self, value: StridedDeviceAddressRangeKHR) -> Self {
        self.inner.address_range = value;
        self
    }
    #[inline]
    pub fn address_flags(mut self, value: AddressCommandFlagsKHR) -> Self {
        self.inner.address_flags = value;
        self
    }
    #[inline]
    pub fn draw_count(mut self, value: u32) -> Self {
        self.inner.draw_count = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`DrawIndirect2InfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsDrawIndirect2InfoKHR>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for DrawIndirect2InfoKHRBuilder<'a> {
    type Target = DrawIndirect2InfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for DrawIndirect2InfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DrawIndirectCount2InfoKHR`] with lifetime-tied pNext safety.
pub struct DrawIndirectCount2InfoKHRBuilder<'a> {
    inner: DrawIndirectCount2InfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DrawIndirectCount2InfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> DrawIndirectCount2InfoKHRBuilder<'a> {
        DrawIndirectCount2InfoKHRBuilder {
            inner: DrawIndirectCount2InfoKHR {
                s_type: StructureType::from_raw(1000318010i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DrawIndirectCount2InfoKHRBuilder<'a> {
    #[inline]
    pub fn address_range(mut self, value: StridedDeviceAddressRangeKHR) -> Self {
        self.inner.address_range = value;
        self
    }
    #[inline]
    pub fn address_flags(mut self, value: AddressCommandFlagsKHR) -> Self {
        self.inner.address_flags = value;
        self
    }
    #[inline]
    pub fn count_address_range(mut self, value: DeviceAddressRangeKHR) -> Self {
        self.inner.count_address_range = value;
        self
    }
    #[inline]
    pub fn count_address_flags(mut self, value: AddressCommandFlagsKHR) -> Self {
        self.inner.count_address_flags = value;
        self
    }
    #[inline]
    pub fn max_draw_count(mut self, value: u32) -> Self {
        self.inner.max_draw_count = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`DrawIndirectCount2InfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsDrawIndirectCount2InfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for DrawIndirectCount2InfoKHRBuilder<'a> {
    type Target = DrawIndirectCount2InfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for DrawIndirectCount2InfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DispatchIndirect2InfoKHR`] with lifetime-tied pNext safety.
pub struct DispatchIndirect2InfoKHRBuilder<'a> {
    inner: DispatchIndirect2InfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DispatchIndirect2InfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> DispatchIndirect2InfoKHRBuilder<'a> {
        DispatchIndirect2InfoKHRBuilder {
            inner: DispatchIndirect2InfoKHR {
                s_type: StructureType::from_raw(1000318011i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DispatchIndirect2InfoKHRBuilder<'a> {
    #[inline]
    pub fn address_range(mut self, value: DeviceAddressRangeKHR) -> Self {
        self.inner.address_range = value;
        self
    }
    #[inline]
    pub fn address_flags(mut self, value: AddressCommandFlagsKHR) -> Self {
        self.inner.address_flags = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`DispatchIndirect2InfoKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsDispatchIndirect2InfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for DispatchIndirect2InfoKHRBuilder<'a> {
    type Target = DispatchIndirect2InfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for DispatchIndirect2InfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`BindTransformFeedbackBuffer2InfoEXT`] with lifetime-tied pNext safety.
pub struct BindTransformFeedbackBuffer2InfoEXTBuilder<'a> {
    inner: BindTransformFeedbackBuffer2InfoEXT,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl BindTransformFeedbackBuffer2InfoEXT {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> BindTransformFeedbackBuffer2InfoEXTBuilder<'a> {
        BindTransformFeedbackBuffer2InfoEXTBuilder {
            inner: BindTransformFeedbackBuffer2InfoEXT {
                s_type: StructureType::from_raw(1000318013i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> BindTransformFeedbackBuffer2InfoEXTBuilder<'a> {
    #[inline]
    pub fn address_range(mut self, value: DeviceAddressRangeKHR) -> Self {
        self.inner.address_range = value;
        self
    }
    #[inline]
    pub fn address_flags(mut self, value: AddressCommandFlagsKHR) -> Self {
        self.inner.address_flags = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`BindTransformFeedbackBuffer2InfoEXT`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsBindTransformFeedbackBuffer2InfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for BindTransformFeedbackBuffer2InfoEXTBuilder<'a> {
    type Target = BindTransformFeedbackBuffer2InfoEXT;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for BindTransformFeedbackBuffer2InfoEXTBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`MemoryMarkerInfoAMD`] with lifetime-tied pNext safety.
pub struct MemoryMarkerInfoAMDBuilder<'a> {
    inner: MemoryMarkerInfoAMD,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl MemoryMarkerInfoAMD {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> MemoryMarkerInfoAMDBuilder<'a> {
        MemoryMarkerInfoAMDBuilder {
            inner: MemoryMarkerInfoAMD {
                s_type: StructureType::from_raw(1000318014i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> MemoryMarkerInfoAMDBuilder<'a> {
    #[inline]
    pub fn stage(mut self, value: PipelineStageFlags2KHR) -> Self {
        self.inner.stage = value;
        self
    }
    #[inline]
    pub fn dst_range(mut self, value: DeviceAddressRangeKHR) -> Self {
        self.inner.dst_range = value;
        self
    }
    #[inline]
    pub fn dst_flags(mut self, value: AddressCommandFlagsKHR) -> Self {
        self.inner.dst_flags = value;
        self
    }
    #[inline]
    pub fn marker(mut self, value: u32) -> Self {
        self.inner.marker = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`MemoryMarkerInfoAMD`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsMemoryMarkerInfoAMD>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr) as *const _;
        }
        self
    }
}
impl<'a> core::ops::Deref for MemoryMarkerInfoAMDBuilder<'a> {
    type Target = MemoryMarkerInfoAMD;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for MemoryMarkerInfoAMDBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceShaderConstantDataFeaturesKHR`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceShaderConstantDataFeaturesKHRBuilder<'a> {
    inner: PhysicalDeviceShaderConstantDataFeaturesKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceShaderConstantDataFeaturesKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceShaderConstantDataFeaturesKHRBuilder<'a> {
        PhysicalDeviceShaderConstantDataFeaturesKHRBuilder {
            inner: PhysicalDeviceShaderConstantDataFeaturesKHR {
                s_type: StructureType::from_raw(1000231000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceShaderConstantDataFeaturesKHRBuilder<'a> {
    #[inline]
    pub fn shader_constant_data(mut self, value: bool) -> Self {
        self.inner.shader_constant_data = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceShaderConstantDataFeaturesKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceShaderConstantDataFeaturesKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceShaderConstantDataFeaturesKHRBuilder<'a> {
    type Target = PhysicalDeviceShaderConstantDataFeaturesKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceShaderConstantDataFeaturesKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceShaderAbortFeaturesKHR`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceShaderAbortFeaturesKHRBuilder<'a> {
    inner: PhysicalDeviceShaderAbortFeaturesKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceShaderAbortFeaturesKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceShaderAbortFeaturesKHRBuilder<'a> {
        PhysicalDeviceShaderAbortFeaturesKHRBuilder {
            inner: PhysicalDeviceShaderAbortFeaturesKHR {
                s_type: StructureType::from_raw(1000233000i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceShaderAbortFeaturesKHRBuilder<'a> {
    #[inline]
    pub fn shader_abort(mut self, value: bool) -> Self {
        self.inner.shader_abort = value as u32;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceShaderAbortFeaturesKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceShaderAbortFeaturesKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceShaderAbortFeaturesKHRBuilder<'a> {
    type Target = PhysicalDeviceShaderAbortFeaturesKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceShaderAbortFeaturesKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`PhysicalDeviceShaderAbortPropertiesKHR`] with lifetime-tied pNext safety.
pub struct PhysicalDeviceShaderAbortPropertiesKHRBuilder<'a> {
    inner: PhysicalDeviceShaderAbortPropertiesKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl PhysicalDeviceShaderAbortPropertiesKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> PhysicalDeviceShaderAbortPropertiesKHRBuilder<'a> {
        PhysicalDeviceShaderAbortPropertiesKHRBuilder {
            inner: PhysicalDeviceShaderAbortPropertiesKHR {
                s_type: StructureType::from_raw(1000233002i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> PhysicalDeviceShaderAbortPropertiesKHRBuilder<'a> {
    #[inline]
    pub fn max_shader_abort_message_size(mut self, value: u64) -> Self {
        self.inner.max_shader_abort_message_size = value;
        self
    }
    ///Prepend a struct to the pNext chain. See [`PhysicalDeviceShaderAbortPropertiesKHR`]'s **Extended By** section for valid types.
    #[inline]
    pub fn push_next<T: ExtendsPhysicalDeviceShaderAbortPropertiesKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_ptr = <*mut T>::cast::<BaseOutStructure>(next);
            (*next_ptr).p_next = self.inner.p_next as *mut _;
            self.inner.p_next = <*mut BaseOutStructure>::cast::<
                core::ffi::c_void,
            >(next_ptr);
        }
        self
    }
}
impl<'a> core::ops::Deref for PhysicalDeviceShaderAbortPropertiesKHRBuilder<'a> {
    type Target = PhysicalDeviceShaderAbortPropertiesKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for PhysicalDeviceShaderAbortPropertiesKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}
///Builder for [`DeviceFaultShaderAbortMessageInfoKHR`] with lifetime-tied pNext safety.
pub struct DeviceFaultShaderAbortMessageInfoKHRBuilder<'a> {
    inner: DeviceFaultShaderAbortMessageInfoKHR,
    _marker: core::marker::PhantomData<&'a ()>,
}
impl DeviceFaultShaderAbortMessageInfoKHR {
    /// Start building this struct; `s_type` is already set to the correct variant.
    #[inline]
    pub fn builder<'a>() -> DeviceFaultShaderAbortMessageInfoKHRBuilder<'a> {
        DeviceFaultShaderAbortMessageInfoKHRBuilder {
            inner: DeviceFaultShaderAbortMessageInfoKHR {
                s_type: StructureType::from_raw(1000233001i32),
                ..Default::default()
            },
            _marker: core::marker::PhantomData,
        }
    }
}
impl<'a> DeviceFaultShaderAbortMessageInfoKHRBuilder<'a> {
    #[inline]
    pub fn message_data_size(mut self, value: u64) -> Self {
        self.inner.message_data_size = value;
        self
    }
    #[inline]
    pub fn message_data(mut self, value: *mut core::ffi::c_void) -> Self {
        self.inner.p_message_data = value;
        self
    }
}
impl<'a> core::ops::Deref for DeviceFaultShaderAbortMessageInfoKHRBuilder<'a> {
    type Target = DeviceFaultShaderAbortMessageInfoKHR;
    #[inline]
    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl<'a> core::ops::DerefMut for DeviceFaultShaderAbortMessageInfoKHRBuilder<'a> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}