// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
// Auto generated from pyronyx-gen — vk/types.rs
// Do not Edit! Execute `cargo run pyronyx-gen`
// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

#![allow(non_camel_case_types)]

use super::bitflags::*;
use super::constants::*;
use super::enums::*;
use super::platform_types::*;
use crate::video::*;
use core::ffi::{c_char, c_int, c_void};
use core::marker::PhantomData;
use core::{fmt, mem, ptr};

pub type ANativeWindow = u32;
pub type AHardwareBuffer = u32;
pub type CAMetalLayer = u32;
pub type MTLDevice_id = u32;
pub type MTLCommandQueue_id = u32;
pub type MTLBuffer_id = u32;
pub type MTLTexture_id = u32;
pub type MTLSharedEvent_id = u32;
pub type IOSurfaceRef = u32;
pub type SampleMask = u32;
pub type Bool32 = u32;
pub type Flags = u32;
pub type Flags64 = u64;
pub type DeviceSize = u64;
pub type DeviceAddress = u64;
pub type OHNativeWindow = u32;
pub type OH_NativeBuffer = u32;
pub type MemoryUnmapFlagsKHR = MemoryUnmapFlags;
pub type GeometryFlagsNV = GeometryFlagsKHR;
pub type GeometryInstanceFlagsNV = GeometryInstanceFlagsKHR;
pub type BuildAccelerationStructureFlagsNV = BuildAccelerationStructureFlagsKHR;
pub type PrivateDataSlotCreateFlagsEXT = PrivateDataSlotCreateFlags;
pub type DescriptorUpdateTemplateCreateFlagsKHR = DescriptorUpdateTemplateCreateFlags;
pub type PipelineCreationFeedbackFlagsEXT = PipelineCreationFeedbackFlags;
pub type SemaphoreWaitFlagsKHR = SemaphoreWaitFlags;
pub type AccessFlags2KHR = AccessFlags2;
pub type PipelineStageFlags2KHR = PipelineStageFlags2;
pub type FormatFeatureFlags2KHR = FormatFeatureFlags2;
pub type MemoryDecompressionMethodFlagsNV = MemoryDecompressionMethodFlagsEXT;
pub type RenderingFlagsKHR = RenderingFlags;
pub type PipelineCreateFlags2KHR = PipelineCreateFlags2;
pub type BufferUsageFlags2KHR = BufferUsageFlags2;
pub type PeerMemoryFeatureFlagsKHR = PeerMemoryFeatureFlags;
pub type MemoryAllocateFlagsKHR = MemoryAllocateFlags;
pub type CommandPoolTrimFlagsKHR = CommandPoolTrimFlags;
pub type ExternalMemoryHandleTypeFlagsKHR = ExternalMemoryHandleTypeFlags;
pub type ExternalMemoryFeatureFlagsKHR = ExternalMemoryFeatureFlags;
pub type ExternalSemaphoreHandleTypeFlagsKHR = ExternalSemaphoreHandleTypeFlags;
pub type ExternalSemaphoreFeatureFlagsKHR = ExternalSemaphoreFeatureFlags;
pub type SemaphoreImportFlagsKHR = SemaphoreImportFlags;
pub type ExternalFenceHandleTypeFlagsKHR = ExternalFenceHandleTypeFlags;
pub type ExternalFenceFeatureFlagsKHR = ExternalFenceFeatureFlags;
pub type FenceImportFlagsKHR = FenceImportFlags;
pub type DescriptorBindingFlagsEXT = DescriptorBindingFlags;
pub type ResolveModeFlagsKHR = ResolveModeFlags;
pub type ToolPurposeFlagsEXT = ToolPurposeFlags;
pub type SubmitFlagsKHR = SubmitFlags;
pub type HostImageCopyFlagsEXT = HostImageCopyFlags;
pub type PresentScalingFlagsEXT = PresentScalingFlagsKHR;
pub type PresentGravityFlagsEXT = PresentGravityFlagsKHR;
#[repr(transparent)]
#[derive(Debug, Default)]
pub struct vkInstance(*mut u8);
impl vkInstance {
    #[inline]
    pub const fn null() -> Self {
        Self(ptr::null_mut())
    }
    #[inline]
    pub const fn is_null(self) -> bool {
        self.0.is_null()
    }
}
impl Copy for vkInstance {}
impl Clone for vkInstance {
    fn clone(&self) -> Self {
        *self
    }
}
unsafe impl Send for vkInstance {}
unsafe impl Sync for vkInstance {}

#[repr(transparent)]
#[derive(Debug, Default)]
pub struct vkPhysicalDevice(*mut u8);
impl vkPhysicalDevice {
    #[inline]
    pub const fn null() -> Self {
        Self(ptr::null_mut())
    }
    #[inline]
    pub const fn is_null(self) -> bool {
        self.0.is_null()
    }
}
impl Copy for vkPhysicalDevice {}
impl Clone for vkPhysicalDevice {
    fn clone(&self) -> Self {
        *self
    }
}
unsafe impl Send for vkPhysicalDevice {}
unsafe impl Sync for vkPhysicalDevice {}

#[repr(transparent)]
#[derive(Debug, Default)]
pub struct vkDevice(*mut u8);
impl vkDevice {
    #[inline]
    pub const fn null() -> Self {
        Self(ptr::null_mut())
    }
    #[inline]
    pub const fn is_null(self) -> bool {
        self.0.is_null()
    }
}
impl Copy for vkDevice {}
impl Clone for vkDevice {
    fn clone(&self) -> Self {
        *self
    }
}
unsafe impl Send for vkDevice {}
unsafe impl Sync for vkDevice {}

#[repr(transparent)]
#[derive(Debug, Default)]
pub struct vkQueue(*mut u8);
impl vkQueue {
    #[inline]
    pub const fn null() -> Self {
        Self(ptr::null_mut())
    }
    #[inline]
    pub const fn is_null(self) -> bool {
        self.0.is_null()
    }
}
impl Copy for vkQueue {}
impl Clone for vkQueue {
    fn clone(&self) -> Self {
        *self
    }
}
unsafe impl Send for vkQueue {}
unsafe impl Sync for vkQueue {}

#[repr(transparent)]
#[derive(Debug, Default)]
pub struct vkCommandBuffer(*mut u8);
impl vkCommandBuffer {
    #[inline]
    pub const fn null() -> Self {
        Self(ptr::null_mut())
    }
    #[inline]
    pub const fn is_null(self) -> bool {
        self.0.is_null()
    }
}
impl Copy for vkCommandBuffer {}
impl Clone for vkCommandBuffer {
    fn clone(&self) -> Self {
        *self
    }
}
unsafe impl Send for vkCommandBuffer {}
unsafe impl Sync for vkCommandBuffer {}

#[repr(transparent)]
#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
pub struct DeviceMemory(pub u64);
impl DeviceMemory {
    #[inline]
    pub const fn null() -> Self {
        Self(0)
    }
    #[inline]
    pub const fn is_null(self) -> bool {
        self.0 == 0
    }
}
impl fmt::Debug for DeviceMemory {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "DeviceMemory(0x{:x})", self.0)
    }
}
impl fmt::Pointer for DeviceMemory {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        fmt::Debug::fmt(&self, f)
    }
}

#[repr(transparent)]
#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
pub struct CommandPool(pub u64);
impl CommandPool {
    #[inline]
    pub const fn null() -> Self {
        Self(0)
    }
    #[inline]
    pub const fn is_null(self) -> bool {
        self.0 == 0
    }
}
impl fmt::Debug for CommandPool {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "CommandPool(0x{:x})", self.0)
    }
}
impl fmt::Pointer for CommandPool {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        fmt::Debug::fmt(&self, f)
    }
}

#[repr(transparent)]
#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
pub struct Buffer(pub u64);
impl Buffer {
    #[inline]
    pub const fn null() -> Self {
        Self(0)
    }
    #[inline]
    pub const fn is_null(self) -> bool {
        self.0 == 0
    }
}
impl fmt::Debug for Buffer {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "Buffer(0x{:x})", self.0)
    }
}
impl fmt::Pointer for Buffer {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        fmt::Debug::fmt(&self, f)
    }
}

#[repr(transparent)]
#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
pub struct BufferView(pub u64);
impl BufferView {
    #[inline]
    pub const fn null() -> Self {
        Self(0)
    }
    #[inline]
    pub const fn is_null(self) -> bool {
        self.0 == 0
    }
}
impl fmt::Debug for BufferView {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "BufferView(0x{:x})", self.0)
    }
}
impl fmt::Pointer for BufferView {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        fmt::Debug::fmt(&self, f)
    }
}

#[repr(transparent)]
#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
pub struct Image(pub u64);
impl Image {
    #[inline]
    pub const fn null() -> Self {
        Self(0)
    }
    #[inline]
    pub const fn is_null(self) -> bool {
        self.0 == 0
    }
}
impl fmt::Debug for Image {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "Image(0x{:x})", self.0)
    }
}
impl fmt::Pointer for Image {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        fmt::Debug::fmt(&self, f)
    }
}

#[repr(transparent)]
#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
pub struct ImageView(pub u64);
impl ImageView {
    #[inline]
    pub const fn null() -> Self {
        Self(0)
    }
    #[inline]
    pub const fn is_null(self) -> bool {
        self.0 == 0
    }
}
impl fmt::Debug for ImageView {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "ImageView(0x{:x})", self.0)
    }
}
impl fmt::Pointer for ImageView {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        fmt::Debug::fmt(&self, f)
    }
}

#[repr(transparent)]
#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
pub struct ShaderModule(pub u64);
impl ShaderModule {
    #[inline]
    pub const fn null() -> Self {
        Self(0)
    }
    #[inline]
    pub const fn is_null(self) -> bool {
        self.0 == 0
    }
}
impl fmt::Debug for ShaderModule {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "ShaderModule(0x{:x})", self.0)
    }
}
impl fmt::Pointer for ShaderModule {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        fmt::Debug::fmt(&self, f)
    }
}

#[repr(transparent)]
#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
pub struct Pipeline(pub u64);
impl Pipeline {
    #[inline]
    pub const fn null() -> Self {
        Self(0)
    }
    #[inline]
    pub const fn is_null(self) -> bool {
        self.0 == 0
    }
}
impl fmt::Debug for Pipeline {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "Pipeline(0x{:x})", self.0)
    }
}
impl fmt::Pointer for Pipeline {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        fmt::Debug::fmt(&self, f)
    }
}

#[repr(transparent)]
#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
pub struct PipelineLayout(pub u64);
impl PipelineLayout {
    #[inline]
    pub const fn null() -> Self {
        Self(0)
    }
    #[inline]
    pub const fn is_null(self) -> bool {
        self.0 == 0
    }
}
impl fmt::Debug for PipelineLayout {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "PipelineLayout(0x{:x})", self.0)
    }
}
impl fmt::Pointer for PipelineLayout {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        fmt::Debug::fmt(&self, f)
    }
}

#[repr(transparent)]
#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
pub struct Sampler(pub u64);
impl Sampler {
    #[inline]
    pub const fn null() -> Self {
        Self(0)
    }
    #[inline]
    pub const fn is_null(self) -> bool {
        self.0 == 0
    }
}
impl fmt::Debug for Sampler {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "Sampler(0x{:x})", self.0)
    }
}
impl fmt::Pointer for Sampler {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        fmt::Debug::fmt(&self, f)
    }
}

#[repr(transparent)]
#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
pub struct DescriptorSet(pub u64);
impl DescriptorSet {
    #[inline]
    pub const fn null() -> Self {
        Self(0)
    }
    #[inline]
    pub const fn is_null(self) -> bool {
        self.0 == 0
    }
}
impl fmt::Debug for DescriptorSet {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "DescriptorSet(0x{:x})", self.0)
    }
}
impl fmt::Pointer for DescriptorSet {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        fmt::Debug::fmt(&self, f)
    }
}

#[repr(transparent)]
#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
pub struct DescriptorSetLayout(pub u64);
impl DescriptorSetLayout {
    #[inline]
    pub const fn null() -> Self {
        Self(0)
    }
    #[inline]
    pub const fn is_null(self) -> bool {
        self.0 == 0
    }
}
impl fmt::Debug for DescriptorSetLayout {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "DescriptorSetLayout(0x{:x})", self.0)
    }
}
impl fmt::Pointer for DescriptorSetLayout {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        fmt::Debug::fmt(&self, f)
    }
}

#[repr(transparent)]
#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
pub struct DescriptorPool(pub u64);
impl DescriptorPool {
    #[inline]
    pub const fn null() -> Self {
        Self(0)
    }
    #[inline]
    pub const fn is_null(self) -> bool {
        self.0 == 0
    }
}
impl fmt::Debug for DescriptorPool {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "DescriptorPool(0x{:x})", self.0)
    }
}
impl fmt::Pointer for DescriptorPool {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        fmt::Debug::fmt(&self, f)
    }
}

#[repr(transparent)]
#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
pub struct Fence(pub u64);
impl Fence {
    #[inline]
    pub const fn null() -> Self {
        Self(0)
    }
    #[inline]
    pub const fn is_null(self) -> bool {
        self.0 == 0
    }
}
impl fmt::Debug for Fence {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "Fence(0x{:x})", self.0)
    }
}
impl fmt::Pointer for Fence {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        fmt::Debug::fmt(&self, f)
    }
}

#[repr(transparent)]
#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
pub struct Semaphore(pub u64);
impl Semaphore {
    #[inline]
    pub const fn null() -> Self {
        Self(0)
    }
    #[inline]
    pub const fn is_null(self) -> bool {
        self.0 == 0
    }
}
impl fmt::Debug for Semaphore {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "Semaphore(0x{:x})", self.0)
    }
}
impl fmt::Pointer for Semaphore {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        fmt::Debug::fmt(&self, f)
    }
}

#[repr(transparent)]
#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
pub struct Event(pub u64);
impl Event {
    #[inline]
    pub const fn null() -> Self {
        Self(0)
    }
    #[inline]
    pub const fn is_null(self) -> bool {
        self.0 == 0
    }
}
impl fmt::Debug for Event {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "Event(0x{:x})", self.0)
    }
}
impl fmt::Pointer for Event {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        fmt::Debug::fmt(&self, f)
    }
}

#[repr(transparent)]
#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
pub struct QueryPool(pub u64);
impl QueryPool {
    #[inline]
    pub const fn null() -> Self {
        Self(0)
    }
    #[inline]
    pub const fn is_null(self) -> bool {
        self.0 == 0
    }
}
impl fmt::Debug for QueryPool {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "QueryPool(0x{:x})", self.0)
    }
}
impl fmt::Pointer for QueryPool {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        fmt::Debug::fmt(&self, f)
    }
}

#[repr(transparent)]
#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
pub struct Framebuffer(pub u64);
impl Framebuffer {
    #[inline]
    pub const fn null() -> Self {
        Self(0)
    }
    #[inline]
    pub const fn is_null(self) -> bool {
        self.0 == 0
    }
}
impl fmt::Debug for Framebuffer {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "Framebuffer(0x{:x})", self.0)
    }
}
impl fmt::Pointer for Framebuffer {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        fmt::Debug::fmt(&self, f)
    }
}

#[repr(transparent)]
#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
pub struct RenderPass(pub u64);
impl RenderPass {
    #[inline]
    pub const fn null() -> Self {
        Self(0)
    }
    #[inline]
    pub const fn is_null(self) -> bool {
        self.0 == 0
    }
}
impl fmt::Debug for RenderPass {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "RenderPass(0x{:x})", self.0)
    }
}
impl fmt::Pointer for RenderPass {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        fmt::Debug::fmt(&self, f)
    }
}

#[repr(transparent)]
#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
pub struct PipelineCache(pub u64);
impl PipelineCache {
    #[inline]
    pub const fn null() -> Self {
        Self(0)
    }
    #[inline]
    pub const fn is_null(self) -> bool {
        self.0 == 0
    }
}
impl fmt::Debug for PipelineCache {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "PipelineCache(0x{:x})", self.0)
    }
}
impl fmt::Pointer for PipelineCache {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        fmt::Debug::fmt(&self, f)
    }
}

#[repr(transparent)]
#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
pub struct PipelineBinaryKHR(pub u64);
impl PipelineBinaryKHR {
    #[inline]
    pub const fn null() -> Self {
        Self(0)
    }
    #[inline]
    pub const fn is_null(self) -> bool {
        self.0 == 0
    }
}
impl fmt::Debug for PipelineBinaryKHR {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "PipelineBinaryKHR(0x{:x})", self.0)
    }
}
impl fmt::Pointer for PipelineBinaryKHR {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        fmt::Debug::fmt(&self, f)
    }
}

#[repr(transparent)]
#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
pub struct IndirectCommandsLayoutNV(pub u64);
impl IndirectCommandsLayoutNV {
    #[inline]
    pub const fn null() -> Self {
        Self(0)
    }
    #[inline]
    pub const fn is_null(self) -> bool {
        self.0 == 0
    }
}
impl fmt::Debug for IndirectCommandsLayoutNV {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "IndirectCommandsLayoutNV(0x{:x})", self.0)
    }
}
impl fmt::Pointer for IndirectCommandsLayoutNV {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        fmt::Debug::fmt(&self, f)
    }
}

#[repr(transparent)]
#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
pub struct IndirectCommandsLayoutEXT(pub u64);
impl IndirectCommandsLayoutEXT {
    #[inline]
    pub const fn null() -> Self {
        Self(0)
    }
    #[inline]
    pub const fn is_null(self) -> bool {
        self.0 == 0
    }
}
impl fmt::Debug for IndirectCommandsLayoutEXT {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "IndirectCommandsLayoutEXT(0x{:x})", self.0)
    }
}
impl fmt::Pointer for IndirectCommandsLayoutEXT {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        fmt::Debug::fmt(&self, f)
    }
}

#[repr(transparent)]
#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
pub struct IndirectExecutionSetEXT(pub u64);
impl IndirectExecutionSetEXT {
    #[inline]
    pub const fn null() -> Self {
        Self(0)
    }
    #[inline]
    pub const fn is_null(self) -> bool {
        self.0 == 0
    }
}
impl fmt::Debug for IndirectExecutionSetEXT {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "IndirectExecutionSetEXT(0x{:x})", self.0)
    }
}
impl fmt::Pointer for IndirectExecutionSetEXT {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        fmt::Debug::fmt(&self, f)
    }
}

#[repr(transparent)]
#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
pub struct DescriptorUpdateTemplate(pub u64);
impl DescriptorUpdateTemplate {
    #[inline]
    pub const fn null() -> Self {
        Self(0)
    }
    #[inline]
    pub const fn is_null(self) -> bool {
        self.0 == 0
    }
}
impl fmt::Debug for DescriptorUpdateTemplate {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "DescriptorUpdateTemplate(0x{:x})", self.0)
    }
}
impl fmt::Pointer for DescriptorUpdateTemplate {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        fmt::Debug::fmt(&self, f)
    }
}

pub type DescriptorUpdateTemplateKHR = DescriptorUpdateTemplate;
#[repr(transparent)]
#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
pub struct SamplerYcbcrConversion(pub u64);
impl SamplerYcbcrConversion {
    #[inline]
    pub const fn null() -> Self {
        Self(0)
    }
    #[inline]
    pub const fn is_null(self) -> bool {
        self.0 == 0
    }
}
impl fmt::Debug for SamplerYcbcrConversion {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "SamplerYcbcrConversion(0x{:x})", self.0)
    }
}
impl fmt::Pointer for SamplerYcbcrConversion {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        fmt::Debug::fmt(&self, f)
    }
}

pub type SamplerYcbcrConversionKHR = SamplerYcbcrConversion;
#[repr(transparent)]
#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
pub struct ValidationCacheEXT(pub u64);
impl ValidationCacheEXT {
    #[inline]
    pub const fn null() -> Self {
        Self(0)
    }
    #[inline]
    pub const fn is_null(self) -> bool {
        self.0 == 0
    }
}
impl fmt::Debug for ValidationCacheEXT {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "ValidationCacheEXT(0x{:x})", self.0)
    }
}
impl fmt::Pointer for ValidationCacheEXT {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        fmt::Debug::fmt(&self, f)
    }
}

#[repr(transparent)]
#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
pub struct AccelerationStructureKHR(pub u64);
impl AccelerationStructureKHR {
    #[inline]
    pub const fn null() -> Self {
        Self(0)
    }
    #[inline]
    pub const fn is_null(self) -> bool {
        self.0 == 0
    }
}
impl fmt::Debug for AccelerationStructureKHR {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "AccelerationStructureKHR(0x{:x})", self.0)
    }
}
impl fmt::Pointer for AccelerationStructureKHR {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        fmt::Debug::fmt(&self, f)
    }
}

#[repr(transparent)]
#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
pub struct AccelerationStructureNV(pub u64);
impl AccelerationStructureNV {
    #[inline]
    pub const fn null() -> Self {
        Self(0)
    }
    #[inline]
    pub const fn is_null(self) -> bool {
        self.0 == 0
    }
}
impl fmt::Debug for AccelerationStructureNV {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "AccelerationStructureNV(0x{:x})", self.0)
    }
}
impl fmt::Pointer for AccelerationStructureNV {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        fmt::Debug::fmt(&self, f)
    }
}

#[repr(transparent)]
#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
pub struct PerformanceConfigurationINTEL(pub u64);
impl PerformanceConfigurationINTEL {
    #[inline]
    pub const fn null() -> Self {
        Self(0)
    }
    #[inline]
    pub const fn is_null(self) -> bool {
        self.0 == 0
    }
}
impl fmt::Debug for PerformanceConfigurationINTEL {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "PerformanceConfigurationINTEL(0x{:x})", self.0)
    }
}
impl fmt::Pointer for PerformanceConfigurationINTEL {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        fmt::Debug::fmt(&self, f)
    }
}

#[repr(transparent)]
#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
pub struct BufferCollectionFUCHSIA(pub u64);
impl BufferCollectionFUCHSIA {
    #[inline]
    pub const fn null() -> Self {
        Self(0)
    }
    #[inline]
    pub const fn is_null(self) -> bool {
        self.0 == 0
    }
}
impl fmt::Debug for BufferCollectionFUCHSIA {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "BufferCollectionFUCHSIA(0x{:x})", self.0)
    }
}
impl fmt::Pointer for BufferCollectionFUCHSIA {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        fmt::Debug::fmt(&self, f)
    }
}

#[repr(transparent)]
#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
pub struct DeferredOperationKHR(pub u64);
impl DeferredOperationKHR {
    #[inline]
    pub const fn null() -> Self {
        Self(0)
    }
    #[inline]
    pub const fn is_null(self) -> bool {
        self.0 == 0
    }
}
impl fmt::Debug for DeferredOperationKHR {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "DeferredOperationKHR(0x{:x})", self.0)
    }
}
impl fmt::Pointer for DeferredOperationKHR {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        fmt::Debug::fmt(&self, f)
    }
}

#[repr(transparent)]
#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
pub struct PrivateDataSlot(pub u64);
impl PrivateDataSlot {
    #[inline]
    pub const fn null() -> Self {
        Self(0)
    }
    #[inline]
    pub const fn is_null(self) -> bool {
        self.0 == 0
    }
}
impl fmt::Debug for PrivateDataSlot {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "PrivateDataSlot(0x{:x})", self.0)
    }
}
impl fmt::Pointer for PrivateDataSlot {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        fmt::Debug::fmt(&self, f)
    }
}

pub type PrivateDataSlotEXT = PrivateDataSlot;
#[repr(transparent)]
#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
pub struct CuModuleNVX(pub u64);
impl CuModuleNVX {
    #[inline]
    pub const fn null() -> Self {
        Self(0)
    }
    #[inline]
    pub const fn is_null(self) -> bool {
        self.0 == 0
    }
}
impl fmt::Debug for CuModuleNVX {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "CuModuleNVX(0x{:x})", self.0)
    }
}
impl fmt::Pointer for CuModuleNVX {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        fmt::Debug::fmt(&self, f)
    }
}

#[repr(transparent)]
#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
pub struct CuFunctionNVX(pub u64);
impl CuFunctionNVX {
    #[inline]
    pub const fn null() -> Self {
        Self(0)
    }
    #[inline]
    pub const fn is_null(self) -> bool {
        self.0 == 0
    }
}
impl fmt::Debug for CuFunctionNVX {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "CuFunctionNVX(0x{:x})", self.0)
    }
}
impl fmt::Pointer for CuFunctionNVX {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        fmt::Debug::fmt(&self, f)
    }
}

#[repr(transparent)]
#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
pub struct OpticalFlowSessionNV(pub u64);
impl OpticalFlowSessionNV {
    #[inline]
    pub const fn null() -> Self {
        Self(0)
    }
    #[inline]
    pub const fn is_null(self) -> bool {
        self.0 == 0
    }
}
impl fmt::Debug for OpticalFlowSessionNV {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "OpticalFlowSessionNV(0x{:x})", self.0)
    }
}
impl fmt::Pointer for OpticalFlowSessionNV {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        fmt::Debug::fmt(&self, f)
    }
}

#[repr(transparent)]
#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
pub struct MicromapEXT(pub u64);
impl MicromapEXT {
    #[inline]
    pub const fn null() -> Self {
        Self(0)
    }
    #[inline]
    pub const fn is_null(self) -> bool {
        self.0 == 0
    }
}
impl fmt::Debug for MicromapEXT {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "MicromapEXT(0x{:x})", self.0)
    }
}
impl fmt::Pointer for MicromapEXT {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        fmt::Debug::fmt(&self, f)
    }
}

#[repr(transparent)]
#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
pub struct ShaderEXT(pub u64);
impl ShaderEXT {
    #[inline]
    pub const fn null() -> Self {
        Self(0)
    }
    #[inline]
    pub const fn is_null(self) -> bool {
        self.0 == 0
    }
}
impl fmt::Debug for ShaderEXT {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "ShaderEXT(0x{:x})", self.0)
    }
}
impl fmt::Pointer for ShaderEXT {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        fmt::Debug::fmt(&self, f)
    }
}

#[repr(transparent)]
#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
pub struct TensorARM(pub u64);
impl TensorARM {
    #[inline]
    pub const fn null() -> Self {
        Self(0)
    }
    #[inline]
    pub const fn is_null(self) -> bool {
        self.0 == 0
    }
}
impl fmt::Debug for TensorARM {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "TensorARM(0x{:x})", self.0)
    }
}
impl fmt::Pointer for TensorARM {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        fmt::Debug::fmt(&self, f)
    }
}

#[repr(transparent)]
#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
pub struct TensorViewARM(pub u64);
impl TensorViewARM {
    #[inline]
    pub const fn null() -> Self {
        Self(0)
    }
    #[inline]
    pub const fn is_null(self) -> bool {
        self.0 == 0
    }
}
impl fmt::Debug for TensorViewARM {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "TensorViewARM(0x{:x})", self.0)
    }
}
impl fmt::Pointer for TensorViewARM {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        fmt::Debug::fmt(&self, f)
    }
}

#[repr(transparent)]
#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
pub struct DataGraphPipelineSessionARM(pub u64);
impl DataGraphPipelineSessionARM {
    #[inline]
    pub const fn null() -> Self {
        Self(0)
    }
    #[inline]
    pub const fn is_null(self) -> bool {
        self.0 == 0
    }
}
impl fmt::Debug for DataGraphPipelineSessionARM {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "DataGraphPipelineSessionARM(0x{:x})", self.0)
    }
}
impl fmt::Pointer for DataGraphPipelineSessionARM {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        fmt::Debug::fmt(&self, f)
    }
}

#[repr(transparent)]
#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
pub struct DisplayKHR(pub u64);
impl DisplayKHR {
    #[inline]
    pub const fn null() -> Self {
        Self(0)
    }
    #[inline]
    pub const fn is_null(self) -> bool {
        self.0 == 0
    }
}
impl fmt::Debug for DisplayKHR {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "DisplayKHR(0x{:x})", self.0)
    }
}
impl fmt::Pointer for DisplayKHR {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        fmt::Debug::fmt(&self, f)
    }
}

#[repr(transparent)]
#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
pub struct DisplayModeKHR(pub u64);
impl DisplayModeKHR {
    #[inline]
    pub const fn null() -> Self {
        Self(0)
    }
    #[inline]
    pub const fn is_null(self) -> bool {
        self.0 == 0
    }
}
impl fmt::Debug for DisplayModeKHR {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "DisplayModeKHR(0x{:x})", self.0)
    }
}
impl fmt::Pointer for DisplayModeKHR {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        fmt::Debug::fmt(&self, f)
    }
}

#[repr(transparent)]
#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
pub struct SurfaceKHR(pub u64);
impl SurfaceKHR {
    #[inline]
    pub const fn null() -> Self {
        Self(0)
    }
    #[inline]
    pub const fn is_null(self) -> bool {
        self.0 == 0
    }
}
impl fmt::Debug for SurfaceKHR {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "SurfaceKHR(0x{:x})", self.0)
    }
}
impl fmt::Pointer for SurfaceKHR {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        fmt::Debug::fmt(&self, f)
    }
}

#[repr(transparent)]
#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
pub struct SwapchainKHR(pub u64);
impl SwapchainKHR {
    #[inline]
    pub const fn null() -> Self {
        Self(0)
    }
    #[inline]
    pub const fn is_null(self) -> bool {
        self.0 == 0
    }
}
impl fmt::Debug for SwapchainKHR {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "SwapchainKHR(0x{:x})", self.0)
    }
}
impl fmt::Pointer for SwapchainKHR {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        fmt::Debug::fmt(&self, f)
    }
}

#[repr(transparent)]
#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
pub struct DebugReportCallbackEXT(pub u64);
impl DebugReportCallbackEXT {
    #[inline]
    pub const fn null() -> Self {
        Self(0)
    }
    #[inline]
    pub const fn is_null(self) -> bool {
        self.0 == 0
    }
}
impl fmt::Debug for DebugReportCallbackEXT {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "DebugReportCallbackEXT(0x{:x})", self.0)
    }
}
impl fmt::Pointer for DebugReportCallbackEXT {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        fmt::Debug::fmt(&self, f)
    }
}

#[repr(transparent)]
#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
pub struct DebugUtilsMessengerEXT(pub u64);
impl DebugUtilsMessengerEXT {
    #[inline]
    pub const fn null() -> Self {
        Self(0)
    }
    #[inline]
    pub const fn is_null(self) -> bool {
        self.0 == 0
    }
}
impl fmt::Debug for DebugUtilsMessengerEXT {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "DebugUtilsMessengerEXT(0x{:x})", self.0)
    }
}
impl fmt::Pointer for DebugUtilsMessengerEXT {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        fmt::Debug::fmt(&self, f)
    }
}

#[repr(transparent)]
#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
pub struct VideoSessionKHR(pub u64);
impl VideoSessionKHR {
    #[inline]
    pub const fn null() -> Self {
        Self(0)
    }
    #[inline]
    pub const fn is_null(self) -> bool {
        self.0 == 0
    }
}
impl fmt::Debug for VideoSessionKHR {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "VideoSessionKHR(0x{:x})", self.0)
    }
}
impl fmt::Pointer for VideoSessionKHR {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        fmt::Debug::fmt(&self, f)
    }
}

#[repr(transparent)]
#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
pub struct VideoSessionParametersKHR(pub u64);
impl VideoSessionParametersKHR {
    #[inline]
    pub const fn null() -> Self {
        Self(0)
    }
    #[inline]
    pub const fn is_null(self) -> bool {
        self.0 == 0
    }
}
impl fmt::Debug for VideoSessionParametersKHR {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "VideoSessionParametersKHR(0x{:x})", self.0)
    }
}
impl fmt::Pointer for VideoSessionParametersKHR {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        fmt::Debug::fmt(&self, f)
    }
}

#[repr(transparent)]
#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
pub struct SemaphoreSciSyncPoolNV(pub u64);
impl SemaphoreSciSyncPoolNV {
    #[inline]
    pub const fn null() -> Self {
        Self(0)
    }
    #[inline]
    pub const fn is_null(self) -> bool {
        self.0 == 0
    }
}
impl fmt::Debug for SemaphoreSciSyncPoolNV {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "SemaphoreSciSyncPoolNV(0x{:x})", self.0)
    }
}
impl fmt::Pointer for SemaphoreSciSyncPoolNV {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        fmt::Debug::fmt(&self, f)
    }
}

pub type RayTracingInvocationReorderModeNV = RayTracingInvocationReorderModeEXT;
pub type DescriptorUpdateTemplateTypeKHR = DescriptorUpdateTemplateType;
pub type PointClippingBehaviorKHR = PointClippingBehavior;
pub type QueueGlobalPriorityKHR = QueueGlobalPriority;
pub type QueueGlobalPriorityEXT = QueueGlobalPriority;
pub type TimeDomainEXT = TimeDomainKHR;
pub type SemaphoreTypeKHR = SemaphoreType;
pub type CopyAccelerationStructureModeNV = CopyAccelerationStructureModeKHR;
pub type AccelerationStructureTypeNV = AccelerationStructureTypeKHR;
pub type GeometryTypeNV = GeometryTypeKHR;
pub type RayTracingShaderGroupTypeNV = RayTracingShaderGroupTypeKHR;
pub type LineRasterizationModeKHR = LineRasterizationMode;
pub type LineRasterizationModeEXT = LineRasterizationMode;
pub type PipelineRobustnessBufferBehaviorEXT = PipelineRobustnessBufferBehavior;
pub type PipelineRobustnessImageBehaviorEXT = PipelineRobustnessImageBehavior;
pub type ScopeNV = ScopeKHR;
pub type ComponentTypeNV = ComponentTypeKHR;
pub type TessellationDomainOriginKHR = TessellationDomainOrigin;
pub type SamplerYcbcrModelConversionKHR = SamplerYcbcrModelConversion;
pub type SamplerYcbcrRangeKHR = SamplerYcbcrRange;
pub type ChromaLocationKHR = ChromaLocation;
pub type SamplerReductionModeEXT = SamplerReductionMode;
pub type ShaderFloatControlsIndependenceKHR = ShaderFloatControlsIndependence;
pub type DriverIdKHR = DriverId;
pub type PFN_vkInternalAllocationNotification = Option<
    extern "system" fn(
        user_data: *mut c_void,
        size: usize,
        allocation_type: InternalAllocationType,
        allocation_scope: SystemAllocationScope,
    ),
>;

pub type PFN_vkInternalFreeNotification = Option<
    extern "system" fn(
        user_data: *mut c_void,
        size: usize,
        allocation_type: InternalAllocationType,
        allocation_scope: SystemAllocationScope,
    ),
>;

pub type PFN_vkReallocationFunction = Option<
    extern "system" fn(
        user_data: *mut c_void,
        original: *mut c_void,
        size: usize,
        alignment: usize,
        allocation_scope: SystemAllocationScope,
    ),
>;

pub type PFN_vkAllocationFunction = Option<
    extern "system" fn(
        user_data: *mut c_void,
        size: usize,
        alignment: usize,
        allocation_scope: SystemAllocationScope,
    ),
>;

pub type PFN_vkFreeFunction =
    Option<extern "system" fn(user_data: *mut c_void, memory: *mut c_void)>;

pub type PFN_vkVoidFunction = Option<extern "system" fn()>;

pub type PFN_vkDebugReportCallbackEXT = Option<
    extern "system" fn(
        flags: DebugReportFlagsEXT,
        object_type: DebugReportObjectTypeEXT,
        object: u64,
        location: usize,
        message_code: i32,
        layer_prefix: *const c_char,
        message: *const c_char,
        user_data: *mut c_void,
    ) -> Bool32,
>;

pub type PFN_vkDebugUtilsMessengerCallbackEXT = Option<
    extern "system" fn(
        message_severity: DebugUtilsMessageSeverityFlagsEXT,
        message_types: DebugUtilsMessageTypeFlagsEXT,
        callback_data: *const DebugUtilsMessengerCallbackDataEXT,
        user_data: *mut c_void,
    ) -> Bool32,
>;

pub type PFN_vkFaultCallbackFunction = Option<
    extern "system" fn(unrecorded_faults: Bool32, fault_count: u32, faults: *const FaultData),
>;

pub type PFN_vkDeviceMemoryReportCallbackEXT = Option<
    extern "system" fn(
        callback_data: *const DeviceMemoryReportCallbackDataEXT,
        user_data: *mut c_void,
    ),
>;

pub type PFN_vkGetInstanceProcAddrLUNARG =
    Option<extern "system" fn(instance: vkInstance, name: *const c_char) -> PFN_vkVoidFunction>;

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct BaseOutStructure<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut BaseOutStructure<'a>,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for BaseOutStructure<'_> {
    fn default() -> Self {
        Self {
            s_type: unsafe { mem::zeroed() },
            next: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct BaseInStructure<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const BaseInStructure<'a>,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for BaseInStructure<'_> {
    fn default() -> Self {
        Self {
            s_type: unsafe { mem::zeroed() },
            next: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)]
pub struct Offset2D {
    pub x: i32,
    pub y: i32,
}
impl Default for Offset2D {
    fn default() -> Self {
        Self { x: 0, y: 0 }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)]
pub struct Offset3D {
    pub x: i32,
    pub y: i32,
    pub z: i32,
}
impl Default for Offset3D {
    fn default() -> Self {
        Self { x: 0, y: 0, z: 0 }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)]
pub struct Extent2D {
    pub width: u32,
    pub height: u32,
}
impl Default for Extent2D {
    fn default() -> Self {
        Self {
            width: 0,
            height: 0,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)]
pub struct Extent3D {
    pub width: u32,
    pub height: u32,
    pub depth: u32,
}
impl Default for Extent3D {
    fn default() -> Self {
        Self {
            width: 0,
            height: 0,
            depth: 0,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct Viewport {
    pub x: f32,
    pub y: f32,
    pub width: f32,
    pub height: f32,
    pub min_depth: f32,
    pub max_depth: f32,
}
impl Default for Viewport {
    fn default() -> Self {
        Self {
            x: 0.0,
            y: 0.0,
            width: 0.0,
            height: 0.0,
            min_depth: 0.0,
            max_depth: 0.0,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)]
pub struct Rect2D {
    pub offset: Offset2D,
    pub extent: Extent2D,
}
impl Default for Rect2D {
    fn default() -> Self {
        Self {
            offset: Default::default(),
            extent: Default::default(),
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)]
pub struct ClearRect {
    pub rect: Rect2D,
    pub base_array_layer: u32,
    pub layer_count: u32,
}
impl Default for ClearRect {
    fn default() -> Self {
        Self {
            rect: Default::default(),
            base_array_layer: 0,
            layer_count: 0,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ComponentMapping {
    pub r: ComponentSwizzle,
    pub g: ComponentSwizzle,
    pub b: ComponentSwizzle,
    pub a: ComponentSwizzle,
}
impl Default for ComponentMapping {
    fn default() -> Self {
        Self {
            r: Default::default(),
            g: Default::default(),
            b: Default::default(),
            a: Default::default(),
        }
    }
}

/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceProperties {
    pub api_version: u32,
    pub driver_version: u32,
    pub vendor_id: u32,
    pub device_id: u32,
    pub device_type: PhysicalDeviceType,
    /// Len: null-terminated
    pub device_name: [c_char; MAX_PHYSICAL_DEVICE_NAME_SIZE as usize],
    pub pipeline_cache_uuid: [u8; UUID_SIZE as usize],
    pub limits: PhysicalDeviceLimits,
    pub sparse_properties: PhysicalDeviceSparseProperties,
}
impl Default for PhysicalDeviceProperties {
    fn default() -> Self {
        Self {
            api_version: 0,
            driver_version: 0,
            vendor_id: 0,
            device_id: 0,
            device_type: Default::default(),
            device_name: unsafe { mem::zeroed() },
            pipeline_cache_uuid: unsafe { mem::zeroed() },
            limits: Default::default(),
            sparse_properties: Default::default(),
        }
    }
}

/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ExtensionProperties {
    /// extension name
    /// Len: null-terminated
    pub extension_name: [c_char; MAX_EXTENSION_NAME_SIZE as usize],
    /// version of the extension specification implemented
    pub spec_version: u32,
}
impl Default for ExtensionProperties {
    fn default() -> Self {
        Self {
            extension_name: unsafe { mem::zeroed() },
            spec_version: 0,
        }
    }
}

/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct LayerProperties {
    /// layer name
    /// Len: null-terminated
    pub layer_name: [c_char; MAX_EXTENSION_NAME_SIZE as usize],
    /// version of the layer specification implemented
    pub spec_version: u32,
    /// build or release version of the layer's library
    pub implementation_version: u32,
    /// Free-form description of the layer
    /// Len: null-terminated
    pub description: [c_char; MAX_DESCRIPTION_SIZE as usize],
}
impl Default for LayerProperties {
    fn default() -> Self {
        Self {
            layer_name: unsafe { mem::zeroed() },
            spec_version: 0,
            implementation_version: 0,
            description: unsafe { mem::zeroed() },
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ApplicationInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    /// Nullable
    /// Len: null-terminated
    pub application_name: *const c_char,
    pub application_version: u32,
    /// Nullable
    /// Len: null-terminated
    pub engine_name: *const c_char,
    pub engine_version: u32,
    pub api_version: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ApplicationInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ApplicationInfo,
            next: ptr::null_mut(),
            application_name: ptr::null_mut(),
            application_version: 0,
            engine_name: ptr::null_mut(),
            engine_version: 0,
            api_version: 0,
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsApplicationInfo {}
impl<'a> ApplicationInfo<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsApplicationInfo>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct AllocationCallbacks<'a> {
    /// Nullable
    pub user_data: *mut c_void,
    pub pfn_allocation: PFN_vkAllocationFunction,
    pub pfn_reallocation: PFN_vkReallocationFunction,
    pub pfn_free: PFN_vkFreeFunction,
    pub pfn_internal_allocation: PFN_vkInternalAllocationNotification,
    pub pfn_internal_free: PFN_vkInternalFreeNotification,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for AllocationCallbacks<'_> {
    fn default() -> Self {
        Self {
            user_data: ptr::null_mut(),
            pfn_allocation: Default::default(),
            pfn_reallocation: Default::default(),
            pfn_free: Default::default(),
            pfn_internal_allocation: Default::default(),
            pfn_internal_free: Default::default(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DeviceQueueCreateInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub flags: DeviceQueueCreateFlags,
    pub queue_family_index: u32,
    pub queue_count: u32,
    /// Len: `queue_count`
    pub queue_priorities: *const f32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for DeviceQueueCreateInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::DeviceQueueCreateInfo,
            next: ptr::null_mut(),
            flags: Default::default(),
            queue_family_index: 0,
            queue_count: 0,
            queue_priorities: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsDeviceQueueCreateInfo {}
impl<'a> DeviceQueueCreateInfo<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsDeviceQueueCreateInfo>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DeviceCreateInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub flags: DeviceCreateFlags,
    pub queue_create_info_count: u32,
    /// Len: `queue_create_info_count`
    pub queue_create_infos: *const DeviceQueueCreateInfo<'a>,
    pub enabled_layer_count: u32,
    /// Ordered list of layer names to be enabled
    /// Len: `enabled_layer_count`, null-terminated
    pub enabled_layer_names: *const *const c_char,
    pub enabled_extension_count: u32,
    /// Len: `enabled_extension_count`, null-terminated
    pub enabled_extension_names: *const *const c_char,
    /// Nullable
    pub enabled_features: *const PhysicalDeviceFeatures,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for DeviceCreateInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::DeviceCreateInfo,
            next: ptr::null_mut(),
            flags: Default::default(),
            queue_create_info_count: 0,
            queue_create_infos: ptr::null_mut(),
            enabled_layer_count: 0,
            enabled_layer_names: ptr::null_mut(),
            enabled_extension_count: 0,
            enabled_extension_names: ptr::null_mut(),
            enabled_features: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsDeviceCreateInfo {}
impl<'a> DeviceCreateInfo<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsDeviceCreateInfo>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct InstanceCreateInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub flags: InstanceCreateFlags,
    /// Nullable
    pub application_info: *const ApplicationInfo<'a>,
    pub enabled_layer_count: u32,
    /// Ordered list of layer names to be enabled
    /// Len: `enabled_layer_count`, null-terminated
    pub enabled_layer_names: *const *const c_char,
    pub enabled_extension_count: u32,
    /// Extension names to be enabled
    /// Len: `enabled_extension_count`, null-terminated
    pub enabled_extension_names: *const *const c_char,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for InstanceCreateInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::InstanceCreateInfo,
            next: ptr::null_mut(),
            flags: Default::default(),
            application_info: ptr::null_mut(),
            enabled_layer_count: 0,
            enabled_layer_names: ptr::null_mut(),
            enabled_extension_count: 0,
            enabled_extension_names: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsInstanceCreateInfo {}
impl<'a> InstanceCreateInfo<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsInstanceCreateInfo>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct QueueFamilyProperties {
    /// Queue flags
    pub queue_flags: QueueFlags,
    pub queue_count: u32,
    pub timestamp_valid_bits: u32,
    /// Minimum alignment requirement for image transfers
    pub min_image_transfer_granularity: Extent3D,
}
impl Default for QueueFamilyProperties {
    fn default() -> Self {
        Self {
            queue_flags: Default::default(),
            queue_count: 0,
            timestamp_valid_bits: 0,
            min_image_transfer_granularity: Default::default(),
        }
    }
}

/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceMemoryProperties {
    pub memory_type_count: u32,
    /// Len: `memory_type_count`
    pub memory_types: [MemoryType; MAX_MEMORY_TYPES as usize],
    pub memory_heap_count: u32,
    /// Len: `memory_heap_count`
    pub memory_heaps: [MemoryHeap; MAX_MEMORY_HEAPS as usize],
}
impl Default for PhysicalDeviceMemoryProperties {
    fn default() -> Self {
        Self {
            memory_type_count: 0,
            memory_types: unsafe { mem::zeroed() },
            memory_heap_count: 0,
            memory_heaps: unsafe { mem::zeroed() },
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct MemoryAllocateInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    /// Size of memory allocation
    pub allocation_size: DeviceSize,
    /// Index of the of the memory type to allocate from
    pub memory_type_index: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for MemoryAllocateInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::MemoryAllocateInfo,
            next: ptr::null_mut(),
            allocation_size: Default::default(),
            memory_type_index: 0,
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsMemoryAllocateInfo {}
impl<'a> MemoryAllocateInfo<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsMemoryAllocateInfo>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct MemoryRequirements {
    /// Specified in bytes
    pub size: DeviceSize,
    /// Specified in bytes
    pub alignment: DeviceSize,
    /// Bitmask of the allowed memory type indices into memoryTypes[] for this object
    pub memory_type_bits: u32,
}
impl Default for MemoryRequirements {
    fn default() -> Self {
        Self {
            size: Default::default(),
            alignment: Default::default(),
            memory_type_bits: 0,
        }
    }
}

/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct SparseImageFormatProperties {
    pub aspect_mask: ImageAspectFlags,
    pub image_granularity: Extent3D,
    pub flags: SparseImageFormatFlags,
}
impl Default for SparseImageFormatProperties {
    fn default() -> Self {
        Self {
            aspect_mask: Default::default(),
            image_granularity: Default::default(),
            flags: Default::default(),
        }
    }
}

/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct SparseImageMemoryRequirements {
    pub format_properties: SparseImageFormatProperties,
    pub image_mip_tail_first_lod: u32,
    /// Specified in bytes, must be a multiple of sparse block size in bytes / alignment
    pub image_mip_tail_size: DeviceSize,
    /// Specified in bytes, must be a multiple of sparse block size in bytes / alignment
    pub image_mip_tail_offset: DeviceSize,
    /// Specified in bytes, must be a multiple of sparse block size in bytes / alignment
    pub image_mip_tail_stride: DeviceSize,
}
impl Default for SparseImageMemoryRequirements {
    fn default() -> Self {
        Self {
            format_properties: Default::default(),
            image_mip_tail_first_lod: 0,
            image_mip_tail_size: Default::default(),
            image_mip_tail_offset: Default::default(),
            image_mip_tail_stride: Default::default(),
        }
    }
}

/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct MemoryType {
    /// Memory properties of this memory type
    pub property_flags: MemoryPropertyFlags,
    /// Index of the memory heap allocations of this memory type are taken from
    pub heap_index: u32,
}
impl Default for MemoryType {
    fn default() -> Self {
        Self {
            property_flags: Default::default(),
            heap_index: 0,
        }
    }
}

/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct MemoryHeap {
    /// Available memory in the heap
    pub size: DeviceSize,
    /// Flags for the heap
    pub flags: MemoryHeapFlags,
}
impl Default for MemoryHeap {
    fn default() -> Self {
        Self {
            size: Default::default(),
            flags: Default::default(),
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct MappedMemoryRange<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    /// Mapped memory object
    pub memory: DeviceMemory,
    /// Offset within the memory object where the range starts
    pub offset: DeviceSize,
    /// Size of the range within the memory object
    pub size: DeviceSize,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for MappedMemoryRange<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::MappedMemoryRange,
            next: ptr::null_mut(),
            memory: Default::default(),
            offset: Default::default(),
            size: Default::default(),
            _marker: PhantomData,
        }
    }
}

/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct FormatProperties {
    /// Format features in case of linear tiling
    pub linear_tiling_features: FormatFeatureFlags,
    /// Format features in case of optimal tiling
    pub optimal_tiling_features: FormatFeatureFlags,
    /// Format features supported by buffers
    pub buffer_features: FormatFeatureFlags,
}
impl Default for FormatProperties {
    fn default() -> Self {
        Self {
            linear_tiling_features: Default::default(),
            optimal_tiling_features: Default::default(),
            buffer_features: Default::default(),
        }
    }
}

/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ImageFormatProperties {
    /// max image dimensions for this resource type
    pub max_extent: Extent3D,
    /// max number of mipmap levels for this resource type
    pub max_mip_levels: u32,
    /// max array size for this resource type
    pub max_array_layers: u32,
    /// supported sample counts for this resource type
    pub sample_counts: SampleCountFlags,
    /// max size (in bytes) of this resource type
    pub max_resource_size: DeviceSize,
}
impl Default for ImageFormatProperties {
    fn default() -> Self {
        Self {
            max_extent: Default::default(),
            max_mip_levels: 0,
            max_array_layers: 0,
            sample_counts: Default::default(),
            max_resource_size: Default::default(),
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DescriptorBufferInfo {
    /// Buffer used for this descriptor slot.
    pub buffer: Buffer,
    /// Base offset from buffer start in bytes to update in the descriptor set.
    pub offset: DeviceSize,
    /// Size in bytes of the buffer resource for this descriptor update.
    pub range: DeviceSize,
}
impl Default for DescriptorBufferInfo {
    fn default() -> Self {
        Self {
            buffer: Default::default(),
            offset: Default::default(),
            range: Default::default(),
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DescriptorImageInfo {
    /// Sampler to write to the descriptor in case it is a SAMPLER or COMBINED_IMAGE_SAMPLER descriptor. Ignored otherwise.
    pub sampler: Sampler,
    /// Image view to write to the descriptor in case it is a SAMPLED_IMAGE, STORAGE_IMAGE, COMBINED_IMAGE_SAMPLER, or INPUT_ATTACHMENT descriptor. Ignored otherwise.
    pub image_view: ImageView,
    /// Layout the image is expected to be in when accessed using this descriptor (only used if imageView is not VK_NULL_HANDLE).
    pub image_layout: ImageLayout,
}
impl Default for DescriptorImageInfo {
    fn default() -> Self {
        Self {
            sampler: Default::default(),
            image_view: Default::default(),
            image_layout: Default::default(),
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct WriteDescriptorSet<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    /// Destination descriptor set
    pub dst_set: DescriptorSet,
    /// Binding within the destination descriptor set to write
    pub dst_binding: u32,
    /// Array element within the destination binding to write
    pub dst_array_element: u32,
    /// Number of descriptors to write (determines the size of the array pointed by pDescriptors)
    pub descriptor_count: u32,
    /// Descriptor type to write (determines which members of the array pointed by pDescriptors are going to be used)
    pub descriptor_type: DescriptorType,
    /// Sampler, image view, and layout for SAMPLER, COMBINED_IMAGE_SAMPLER, {SAMPLED,STORAGE}_IMAGE, and INPUT_ATTACHMENT descriptor types.
    /// Len: `descriptor_count`
    pub image_info: *const DescriptorImageInfo,
    /// Raw buffer, size, and offset for {UNIFORM,STORAGE}_BUFFER[_DYNAMIC] descriptor types.
    /// Len: `descriptor_count`
    pub buffer_info: *const DescriptorBufferInfo,
    /// Buffer view to write to the descriptor for {UNIFORM,STORAGE}_TEXEL_BUFFER descriptor types.
    /// Len: `descriptor_count`
    pub texel_buffer_view: *const BufferView,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for WriteDescriptorSet<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::WriteDescriptorSet,
            next: ptr::null_mut(),
            dst_set: Default::default(),
            dst_binding: 0,
            dst_array_element: 0,
            descriptor_count: 0,
            descriptor_type: Default::default(),
            image_info: ptr::null_mut(),
            buffer_info: ptr::null_mut(),
            texel_buffer_view: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsWriteDescriptorSet {}
impl<'a> WriteDescriptorSet<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsWriteDescriptorSet>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct CopyDescriptorSet<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    /// Source descriptor set
    pub src_set: DescriptorSet,
    /// Binding within the source descriptor set to copy from
    pub src_binding: u32,
    /// Array element within the source binding to copy from
    pub src_array_element: u32,
    /// Destination descriptor set
    pub dst_set: DescriptorSet,
    /// Binding within the destination descriptor set to copy to
    pub dst_binding: u32,
    /// Array element within the destination binding to copy to
    pub dst_array_element: u32,
    /// Number of descriptors to write (determines the size of the array pointed by pDescriptors)
    pub descriptor_count: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for CopyDescriptorSet<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::CopyDescriptorSet,
            next: ptr::null_mut(),
            src_set: Default::default(),
            src_binding: 0,
            src_array_element: 0,
            dst_set: Default::default(),
            dst_binding: 0,
            dst_array_element: 0,
            descriptor_count: 0,
            _marker: PhantomData,
        }
    }
}

/// Extends: `BufferViewCreateInfo`, `BufferCreateInfo`, `PhysicalDeviceExternalBufferInfo`, `DescriptorBufferBindingInfoEXT`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct BufferUsageFlags2CreateInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub usage: BufferUsageFlags2,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for BufferUsageFlags2CreateInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::BufferUsageFlags2CreateInfo,
            next: ptr::null_mut(),
            usage: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsBufferViewCreateInfo for BufferUsageFlags2CreateInfo<'_> {}
impl ExtendsBufferCreateInfo for BufferUsageFlags2CreateInfo<'_> {}
impl ExtendsPhysicalDeviceExternalBufferInfo for BufferUsageFlags2CreateInfo<'_> {}
impl ExtendsDescriptorBufferBindingInfoEXT for BufferUsageFlags2CreateInfo<'_> {}

pub type BufferUsageFlags2CreateInfoKHR<'a> = BufferUsageFlags2CreateInfo<'a>;
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct BufferCreateInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    /// Buffer creation flags
    pub flags: BufferCreateFlags,
    /// Specified in bytes
    pub size: DeviceSize,
    /// Buffer usage flags
    pub usage: BufferUsageFlags,
    pub sharing_mode: SharingMode,
    pub queue_family_index_count: u32,
    /// Len: `queue_family_index_count`
    pub queue_family_indices: *const u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for BufferCreateInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::BufferCreateInfo,
            next: ptr::null_mut(),
            flags: Default::default(),
            size: Default::default(),
            usage: Default::default(),
            sharing_mode: Default::default(),
            queue_family_index_count: 0,
            queue_family_indices: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsBufferCreateInfo {}
impl<'a> BufferCreateInfo<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsBufferCreateInfo>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct BufferViewCreateInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub flags: BufferViewCreateFlags,
    pub buffer: Buffer,
    /// Optionally specifies format of elements
    pub format: Format,
    /// Specified in bytes
    pub offset: DeviceSize,
    /// View size specified in bytes
    pub range: DeviceSize,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for BufferViewCreateInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::BufferViewCreateInfo,
            next: ptr::null_mut(),
            flags: Default::default(),
            buffer: Default::default(),
            format: Default::default(),
            offset: Default::default(),
            range: Default::default(),
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsBufferViewCreateInfo {}
impl<'a> BufferViewCreateInfo<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsBufferViewCreateInfo>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ImageSubresource {
    pub aspect_mask: ImageAspectFlags,
    pub mip_level: u32,
    pub array_layer: u32,
}
impl Default for ImageSubresource {
    fn default() -> Self {
        Self {
            aspect_mask: Default::default(),
            mip_level: 0,
            array_layer: 0,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ImageSubresourceLayers {
    pub aspect_mask: ImageAspectFlags,
    pub mip_level: u32,
    pub base_array_layer: u32,
    pub layer_count: u32,
}
impl Default for ImageSubresourceLayers {
    fn default() -> Self {
        Self {
            aspect_mask: Default::default(),
            mip_level: 0,
            base_array_layer: 0,
            layer_count: 0,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ImageSubresourceRange {
    pub aspect_mask: ImageAspectFlags,
    pub base_mip_level: u32,
    pub level_count: u32,
    pub base_array_layer: u32,
    pub layer_count: u32,
}
impl Default for ImageSubresourceRange {
    fn default() -> Self {
        Self {
            aspect_mask: Default::default(),
            base_mip_level: 0,
            level_count: 0,
            base_array_layer: 0,
            layer_count: 0,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct MemoryBarrier<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    /// Memory accesses from the source of the dependency to synchronize
    pub src_access_mask: AccessFlags,
    /// Memory accesses from the destination of the dependency to synchronize
    pub dst_access_mask: AccessFlags,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for MemoryBarrier<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::MemoryBarrier,
            next: ptr::null_mut(),
            src_access_mask: Default::default(),
            dst_access_mask: Default::default(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct BufferMemoryBarrier<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    /// Memory accesses from the source of the dependency to synchronize
    pub src_access_mask: AccessFlags,
    /// Memory accesses from the destination of the dependency to synchronize
    pub dst_access_mask: AccessFlags,
    /// Queue family to transition ownership from
    pub src_queue_family_index: u32,
    /// Queue family to transition ownership to
    pub dst_queue_family_index: u32,
    /// Buffer to sync
    pub buffer: Buffer,
    /// Offset within the buffer to sync
    pub offset: DeviceSize,
    /// Amount of bytes to sync
    pub size: DeviceSize,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for BufferMemoryBarrier<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::BufferMemoryBarrier,
            next: ptr::null_mut(),
            src_access_mask: Default::default(),
            dst_access_mask: Default::default(),
            src_queue_family_index: 0,
            dst_queue_family_index: 0,
            buffer: Default::default(),
            offset: Default::default(),
            size: Default::default(),
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsBufferMemoryBarrier {}
impl<'a> BufferMemoryBarrier<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsBufferMemoryBarrier>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ImageMemoryBarrier<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    /// Memory accesses from the source of the dependency to synchronize
    pub src_access_mask: AccessFlags,
    /// Memory accesses from the destination of the dependency to synchronize
    pub dst_access_mask: AccessFlags,
    /// Current layout of the image
    pub old_layout: ImageLayout,
    /// New layout to transition the image to
    pub new_layout: ImageLayout,
    /// Queue family to transition ownership from
    pub src_queue_family_index: u32,
    /// Queue family to transition ownership to
    pub dst_queue_family_index: u32,
    /// Image to sync
    pub image: Image,
    /// Subresource range to sync
    pub subresource_range: ImageSubresourceRange,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ImageMemoryBarrier<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ImageMemoryBarrier,
            next: ptr::null_mut(),
            src_access_mask: Default::default(),
            dst_access_mask: Default::default(),
            old_layout: Default::default(),
            new_layout: Default::default(),
            src_queue_family_index: 0,
            dst_queue_family_index: 0,
            image: Default::default(),
            subresource_range: Default::default(),
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsImageMemoryBarrier {}
impl<'a> ImageMemoryBarrier<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsImageMemoryBarrier>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ImageCreateInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    /// Image creation flags
    pub flags: ImageCreateFlags,
    pub image_type: ImageType,
    pub format: Format,
    pub extent: Extent3D,
    pub mip_levels: u32,
    pub array_layers: u32,
    pub samples: SampleCountFlags,
    pub tiling: ImageTiling,
    /// Image usage flags
    pub usage: ImageUsageFlags,
    /// Cross-queue-family sharing mode
    pub sharing_mode: SharingMode,
    /// Number of queue families to share across
    pub queue_family_index_count: u32,
    /// Array of queue family indices to share across
    /// Len: `queue_family_index_count`
    pub queue_family_indices: *const u32,
    /// Initial image layout for all subresources
    pub initial_layout: ImageLayout,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ImageCreateInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ImageCreateInfo,
            next: ptr::null_mut(),
            flags: Default::default(),
            image_type: Default::default(),
            format: Default::default(),
            extent: Default::default(),
            mip_levels: 0,
            array_layers: 0,
            samples: Default::default(),
            tiling: Default::default(),
            usage: Default::default(),
            sharing_mode: Default::default(),
            queue_family_index_count: 0,
            queue_family_indices: ptr::null_mut(),
            initial_layout: Default::default(),
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsImageCreateInfo {}
impl<'a> ImageCreateInfo<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsImageCreateInfo>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct SubresourceLayout {
    /// Specified in bytes
    pub offset: DeviceSize,
    /// Specified in bytes
    pub size: DeviceSize,
    /// Specified in bytes
    pub row_pitch: DeviceSize,
    /// Specified in bytes
    pub array_pitch: DeviceSize,
    /// Specified in bytes
    pub depth_pitch: DeviceSize,
}
impl Default for SubresourceLayout {
    fn default() -> Self {
        Self {
            offset: Default::default(),
            size: Default::default(),
            row_pitch: Default::default(),
            array_pitch: Default::default(),
            depth_pitch: Default::default(),
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ImageViewCreateInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub flags: ImageViewCreateFlags,
    pub image: Image,
    pub view_type: ImageViewType,
    pub format: Format,
    pub components: ComponentMapping,
    pub subresource_range: ImageSubresourceRange,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ImageViewCreateInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ImageViewCreateInfo,
            next: ptr::null_mut(),
            flags: Default::default(),
            image: Default::default(),
            view_type: Default::default(),
            format: Default::default(),
            components: Default::default(),
            subresource_range: Default::default(),
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsImageViewCreateInfo {}
impl<'a> ImageViewCreateInfo<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsImageViewCreateInfo>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct BufferCopy {
    /// Specified in bytes
    pub src_offset: DeviceSize,
    /// Specified in bytes
    pub dst_offset: DeviceSize,
    /// Specified in bytes
    pub size: DeviceSize,
}
impl Default for BufferCopy {
    fn default() -> Self {
        Self {
            src_offset: Default::default(),
            dst_offset: Default::default(),
            size: Default::default(),
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct SparseMemoryBind {
    /// Specified in bytes
    pub resource_offset: DeviceSize,
    /// Specified in bytes
    pub size: DeviceSize,
    pub memory: DeviceMemory,
    /// Specified in bytes
    pub memory_offset: DeviceSize,
    pub flags: SparseMemoryBindFlags,
}
impl Default for SparseMemoryBind {
    fn default() -> Self {
        Self {
            resource_offset: Default::default(),
            size: Default::default(),
            memory: Default::default(),
            memory_offset: Default::default(),
            flags: Default::default(),
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct SparseImageMemoryBind {
    pub subresource: ImageSubresource,
    pub offset: Offset3D,
    pub extent: Extent3D,
    pub memory: DeviceMemory,
    /// Specified in bytes
    pub memory_offset: DeviceSize,
    pub flags: SparseMemoryBindFlags,
}
impl Default for SparseImageMemoryBind {
    fn default() -> Self {
        Self {
            subresource: Default::default(),
            offset: Default::default(),
            extent: Default::default(),
            memory: Default::default(),
            memory_offset: Default::default(),
            flags: Default::default(),
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct SparseBufferMemoryBindInfo<'a> {
    pub buffer: Buffer,
    pub bind_count: u32,
    /// Len: `bind_count`
    pub binds: *const SparseMemoryBind,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for SparseBufferMemoryBindInfo<'_> {
    fn default() -> Self {
        Self {
            buffer: Default::default(),
            bind_count: 0,
            binds: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct SparseImageOpaqueMemoryBindInfo<'a> {
    pub image: Image,
    pub bind_count: u32,
    /// Len: `bind_count`
    pub binds: *const SparseMemoryBind,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for SparseImageOpaqueMemoryBindInfo<'_> {
    fn default() -> Self {
        Self {
            image: Default::default(),
            bind_count: 0,
            binds: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct SparseImageMemoryBindInfo<'a> {
    pub image: Image,
    pub bind_count: u32,
    /// Len: `bind_count`
    pub binds: *const SparseImageMemoryBind,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for SparseImageMemoryBindInfo<'_> {
    fn default() -> Self {
        Self {
            image: Default::default(),
            bind_count: 0,
            binds: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct BindSparseInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub wait_semaphore_count: u32,
    /// Len: `wait_semaphore_count`
    pub wait_semaphores: *const Semaphore,
    pub buffer_bind_count: u32,
    /// Len: `buffer_bind_count`
    pub buffer_binds: *const SparseBufferMemoryBindInfo<'a>,
    pub image_opaque_bind_count: u32,
    /// Len: `image_opaque_bind_count`
    pub image_opaque_binds: *const SparseImageOpaqueMemoryBindInfo<'a>,
    pub image_bind_count: u32,
    /// Len: `image_bind_count`
    pub image_binds: *const SparseImageMemoryBindInfo<'a>,
    pub signal_semaphore_count: u32,
    /// Len: `signal_semaphore_count`
    pub signal_semaphores: *const Semaphore,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for BindSparseInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::BindSparseInfo,
            next: ptr::null_mut(),
            wait_semaphore_count: 0,
            wait_semaphores: ptr::null_mut(),
            buffer_bind_count: 0,
            buffer_binds: ptr::null_mut(),
            image_opaque_bind_count: 0,
            image_opaque_binds: ptr::null_mut(),
            image_bind_count: 0,
            image_binds: ptr::null_mut(),
            signal_semaphore_count: 0,
            signal_semaphores: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsBindSparseInfo {}
impl<'a> BindSparseInfo<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsBindSparseInfo>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ImageCopy {
    pub src_subresource: ImageSubresourceLayers,
    /// Specified in pixels for both compressed and uncompressed images
    pub src_offset: Offset3D,
    pub dst_subresource: ImageSubresourceLayers,
    /// Specified in pixels for both compressed and uncompressed images
    pub dst_offset: Offset3D,
    /// Specified in pixels for both compressed and uncompressed images
    pub extent: Extent3D,
}
impl Default for ImageCopy {
    fn default() -> Self {
        Self {
            src_subresource: Default::default(),
            src_offset: Default::default(),
            dst_subresource: Default::default(),
            dst_offset: Default::default(),
            extent: Default::default(),
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ImageBlit {
    pub src_subresource: ImageSubresourceLayers,
    /// Specified in pixels for both compressed and uncompressed images
    pub src_offsets: [Offset3D; 2],
    pub dst_subresource: ImageSubresourceLayers,
    /// Specified in pixels for both compressed and uncompressed images
    pub dst_offsets: [Offset3D; 2],
}
impl Default for ImageBlit {
    fn default() -> Self {
        Self {
            src_subresource: Default::default(),
            src_offsets: unsafe { mem::zeroed() },
            dst_subresource: Default::default(),
            dst_offsets: unsafe { mem::zeroed() },
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct BufferImageCopy {
    /// Specified in bytes
    pub buffer_offset: DeviceSize,
    /// Specified in texels
    pub buffer_row_length: u32,
    pub buffer_image_height: u32,
    pub image_subresource: ImageSubresourceLayers,
    /// Specified in pixels for both compressed and uncompressed images
    pub image_offset: Offset3D,
    /// Specified in pixels for both compressed and uncompressed images
    pub image_extent: Extent3D,
}
impl Default for BufferImageCopy {
    fn default() -> Self {
        Self {
            buffer_offset: Default::default(),
            buffer_row_length: 0,
            buffer_image_height: 0,
            image_subresource: Default::default(),
            image_offset: Default::default(),
            image_extent: Default::default(),
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct StridedDeviceAddressRangeKHR {
    pub address: DeviceAddress,
    pub size: DeviceSize,
    pub stride: DeviceSize,
}
impl Default for StridedDeviceAddressRangeKHR {
    fn default() -> Self {
        Self {
            address: Default::default(),
            size: Default::default(),
            stride: Default::default(),
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct CopyMemoryIndirectCommandKHR {
    pub src_address: DeviceAddress,
    pub dst_address: DeviceAddress,
    pub size: DeviceSize,
}
impl Default for CopyMemoryIndirectCommandKHR {
    fn default() -> Self {
        Self {
            src_address: Default::default(),
            dst_address: Default::default(),
            size: Default::default(),
        }
    }
}

pub type CopyMemoryIndirectCommandNV = CopyMemoryIndirectCommandKHR;
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct CopyMemoryIndirectInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub src_copy_flags: AddressCopyFlagsKHR,
    pub dst_copy_flags: AddressCopyFlagsKHR,
    pub copy_count: u32,
    pub copy_address_range: StridedDeviceAddressRangeKHR,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for CopyMemoryIndirectInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::CopyMemoryIndirectInfoKHR,
            next: ptr::null_mut(),
            src_copy_flags: Default::default(),
            dst_copy_flags: Default::default(),
            copy_count: 0,
            copy_address_range: Default::default(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct CopyMemoryToImageIndirectCommandKHR {
    pub src_address: DeviceAddress,
    pub buffer_row_length: u32,
    pub buffer_image_height: u32,
    pub image_subresource: ImageSubresourceLayers,
    pub image_offset: Offset3D,
    pub image_extent: Extent3D,
}
impl Default for CopyMemoryToImageIndirectCommandKHR {
    fn default() -> Self {
        Self {
            src_address: Default::default(),
            buffer_row_length: 0,
            buffer_image_height: 0,
            image_subresource: Default::default(),
            image_offset: Default::default(),
            image_extent: Default::default(),
        }
    }
}

pub type CopyMemoryToImageIndirectCommandNV = CopyMemoryToImageIndirectCommandKHR;
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct CopyMemoryToImageIndirectInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub src_copy_flags: AddressCopyFlagsKHR,
    pub copy_count: u32,
    pub copy_address_range: StridedDeviceAddressRangeKHR,
    pub dst_image: Image,
    pub dst_image_layout: ImageLayout,
    /// Len: `copy_count`
    pub image_subresources: *const ImageSubresourceLayers,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for CopyMemoryToImageIndirectInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::CopyMemoryToImageIndirectInfoKHR,
            next: ptr::null_mut(),
            src_copy_flags: Default::default(),
            copy_count: 0,
            copy_address_range: Default::default(),
            dst_image: Default::default(),
            dst_image_layout: Default::default(),
            image_subresources: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ImageResolve {
    pub src_subresource: ImageSubresourceLayers,
    pub src_offset: Offset3D,
    pub dst_subresource: ImageSubresourceLayers,
    pub dst_offset: Offset3D,
    pub extent: Extent3D,
}
impl Default for ImageResolve {
    fn default() -> Self {
        Self {
            src_subresource: Default::default(),
            src_offset: Default::default(),
            dst_subresource: Default::default(),
            dst_offset: Default::default(),
            extent: Default::default(),
        }
    }
}

/// Extends: `PipelineShaderStageCreateInfo`, `DataGraphPipelineCreateInfoARM`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ShaderModuleCreateInfo<'a> {
    pub s_type: StructureType,
    /// noautovalidity because this structure can be either an explicit parameter, or passed in a pNext chain
    /// Nullable
    pub next: *const c_void,
    pub flags: ShaderModuleCreateFlags,
    /// Specified in bytes
    pub code_size: usize,
    /// Binary code of size codeSize
    /// Len: code_size / 4
    pub code: *const u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ShaderModuleCreateInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ShaderModuleCreateInfo,
            next: ptr::null_mut(),
            flags: Default::default(),
            code_size: 0,
            code: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsPipelineShaderStageCreateInfo for ShaderModuleCreateInfo<'_> {}
impl ExtendsDataGraphPipelineCreateInfoARM for ShaderModuleCreateInfo<'_> {}
pub trait ExtendsShaderModuleCreateInfo {}
impl<'a> ShaderModuleCreateInfo<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsShaderModuleCreateInfo>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DescriptorSetLayoutBinding<'a> {
    /// Binding number for this entry
    pub binding: u32,
    /// Type of the descriptors in this binding
    pub descriptor_type: DescriptorType,
    /// Number of descriptors in this binding
    pub descriptor_count: u32,
    /// Shader stages this binding is visible to
    pub stage_flags: ShaderStageFlags,
    /// Immutable samplers (used if descriptor type is SAMPLER or COMBINED_IMAGE_SAMPLER, is either NULL or contains count number of elements)
    /// Nullable
    /// Len: `descriptor_count`
    pub immutable_samplers: *const Sampler,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for DescriptorSetLayoutBinding<'_> {
    fn default() -> Self {
        Self {
            binding: 0,
            descriptor_type: Default::default(),
            descriptor_count: 0,
            stage_flags: Default::default(),
            immutable_samplers: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DescriptorSetLayoutCreateInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub flags: DescriptorSetLayoutCreateFlags,
    /// Number of bindings in the descriptor set layout
    pub binding_count: u32,
    /// Array of descriptor set layout bindings
    /// Len: `binding_count`
    pub bindings: *const DescriptorSetLayoutBinding<'a>,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for DescriptorSetLayoutCreateInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::DescriptorSetLayoutCreateInfo,
            next: ptr::null_mut(),
            flags: Default::default(),
            binding_count: 0,
            bindings: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsDescriptorSetLayoutCreateInfo {}
impl<'a> DescriptorSetLayoutCreateInfo<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsDescriptorSetLayoutCreateInfo>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DescriptorPoolSize {
    pub ty: DescriptorType,
    pub descriptor_count: u32,
}
impl Default for DescriptorPoolSize {
    fn default() -> Self {
        Self {
            ty: Default::default(),
            descriptor_count: 0,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DescriptorPoolCreateInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub flags: DescriptorPoolCreateFlags,
    pub max_sets: u32,
    pub pool_size_count: u32,
    /// Len: `pool_size_count`
    pub pool_sizes: *const DescriptorPoolSize,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for DescriptorPoolCreateInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::DescriptorPoolCreateInfo,
            next: ptr::null_mut(),
            flags: Default::default(),
            max_sets: 0,
            pool_size_count: 0,
            pool_sizes: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsDescriptorPoolCreateInfo {}
impl<'a> DescriptorPoolCreateInfo<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsDescriptorPoolCreateInfo>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DescriptorSetAllocateInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub descriptor_pool: DescriptorPool,
    pub descriptor_set_count: u32,
    /// Len: `descriptor_set_count`
    pub set_layouts: *const DescriptorSetLayout,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for DescriptorSetAllocateInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::DescriptorSetAllocateInfo,
            next: ptr::null_mut(),
            descriptor_pool: Default::default(),
            descriptor_set_count: 0,
            set_layouts: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsDescriptorSetAllocateInfo {}
impl<'a> DescriptorSetAllocateInfo<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsDescriptorSetAllocateInfo>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct SpecializationMapEntry {
    /// The SpecConstant ID specified in the BIL
    pub constant_id: u32,
    /// Offset of the value in the data block
    pub offset: u32,
    /// Size in bytes of the SpecConstant
    pub size: usize,
}
impl Default for SpecializationMapEntry {
    fn default() -> Self {
        Self {
            constant_id: 0,
            offset: 0,
            size: 0,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct SpecializationInfo<'a> {
    /// Number of entries in the map
    pub map_entry_count: u32,
    /// Array of map entries
    /// Len: `map_entry_count`
    pub map_entries: *const SpecializationMapEntry,
    /// Size in bytes of pData
    pub data_size: usize,
    /// Pointer to SpecConstant data
    /// Len: `data_size`
    pub data: *const c_void,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for SpecializationInfo<'_> {
    fn default() -> Self {
        Self {
            map_entry_count: 0,
            map_entries: ptr::null_mut(),
            data_size: 0,
            data: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PipelineShaderStageCreateInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub flags: PipelineShaderStageCreateFlags,
    /// Shader stage
    pub stage: ShaderStageFlags,
    /// Module containing entry point
    pub module: ShaderModule,
    /// Null-terminated entry point name
    /// Len: null-terminated
    pub name: *const c_char,
    /// Nullable
    pub specialization_info: *const SpecializationInfo<'a>,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PipelineShaderStageCreateInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PipelineShaderStageCreateInfo,
            next: ptr::null_mut(),
            flags: Default::default(),
            stage: Default::default(),
            module: Default::default(),
            name: ptr::null_mut(),
            specialization_info: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsPipelineShaderStageCreateInfo {}
impl<'a> PipelineShaderStageCreateInfo<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsPipelineShaderStageCreateInfo>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ComputePipelineCreateInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    /// Pipeline creation flags
    pub flags: PipelineCreateFlags,
    pub stage: PipelineShaderStageCreateInfo<'a>,
    /// Interface layout of the pipeline
    pub layout: PipelineLayout,
    /// If VK_PIPELINE_CREATE_DERIVATIVE_BIT is set and this value is nonzero, it specifies the handle of the base pipeline this is a derivative of
    pub base_pipeline_handle: Pipeline,
    /// If VK_PIPELINE_CREATE_DERIVATIVE_BIT is set and this value is not -1, it specifies an index into pCreateInfos of the base pipeline this is a derivative of
    pub base_pipeline_index: i32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ComputePipelineCreateInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ComputePipelineCreateInfo,
            next: ptr::null_mut(),
            flags: Default::default(),
            stage: Default::default(),
            layout: Default::default(),
            base_pipeline_handle: Default::default(),
            base_pipeline_index: 0,
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsComputePipelineCreateInfo {}
impl<'a> ComputePipelineCreateInfo<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsComputePipelineCreateInfo>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

/// Extends: `ComputePipelineCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ComputePipelineIndirectBufferInfoNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub device_address: DeviceAddress,
    pub size: DeviceSize,
    pub pipeline_device_address_capture_replay: DeviceAddress,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ComputePipelineIndirectBufferInfoNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ComputePipelineIndirectBufferInfoNV,
            next: ptr::null_mut(),
            device_address: Default::default(),
            size: Default::default(),
            pipeline_device_address_capture_replay: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsComputePipelineCreateInfo for ComputePipelineIndirectBufferInfoNV<'_> {}

/// Extends: `ComputePipelineCreateInfo`, `GraphicsPipelineCreateInfo`, `RayTracingPipelineCreateInfoNV`, `RayTracingPipelineCreateInfoKHR`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PipelineCreateFlags2CreateInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub flags: PipelineCreateFlags2,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PipelineCreateFlags2CreateInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PipelineCreateFlags2CreateInfo,
            next: ptr::null_mut(),
            flags: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsComputePipelineCreateInfo for PipelineCreateFlags2CreateInfo<'_> {}
impl ExtendsGraphicsPipelineCreateInfo for PipelineCreateFlags2CreateInfo<'_> {}
impl ExtendsRayTracingPipelineCreateInfoNV for PipelineCreateFlags2CreateInfo<'_> {}
impl ExtendsRayTracingPipelineCreateInfoKHR for PipelineCreateFlags2CreateInfo<'_> {}

pub type PipelineCreateFlags2CreateInfoKHR<'a> = PipelineCreateFlags2CreateInfo<'a>;
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VertexInputBindingDescription {
    /// Vertex buffer binding id
    pub binding: u32,
    /// Distance between vertices in bytes (0 = no advancement)
    pub stride: u32,
    /// The rate at which the vertex data is consumed
    pub input_rate: VertexInputRate,
}
impl Default for VertexInputBindingDescription {
    fn default() -> Self {
        Self {
            binding: 0,
            stride: 0,
            input_rate: Default::default(),
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VertexInputAttributeDescription {
    /// location of the shader vertex attrib
    pub location: u32,
    /// Vertex buffer binding id
    pub binding: u32,
    /// format of source data
    pub format: Format,
    /// Offset of first element in bytes from base of vertex
    pub offset: u32,
}
impl Default for VertexInputAttributeDescription {
    fn default() -> Self {
        Self {
            location: 0,
            binding: 0,
            format: Default::default(),
            offset: 0,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PipelineVertexInputStateCreateInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub flags: PipelineVertexInputStateCreateFlags,
    /// number of bindings
    pub vertex_binding_description_count: u32,
    /// Len: `vertex_binding_description_count`
    pub vertex_binding_descriptions: *const VertexInputBindingDescription,
    /// number of attributes
    pub vertex_attribute_description_count: u32,
    /// Len: `vertex_attribute_description_count`
    pub vertex_attribute_descriptions: *const VertexInputAttributeDescription,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PipelineVertexInputStateCreateInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PipelineVertexInputStateCreateInfo,
            next: ptr::null_mut(),
            flags: Default::default(),
            vertex_binding_description_count: 0,
            vertex_binding_descriptions: ptr::null_mut(),
            vertex_attribute_description_count: 0,
            vertex_attribute_descriptions: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsPipelineVertexInputStateCreateInfo {}
impl<'a> PipelineVertexInputStateCreateInfo<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsPipelineVertexInputStateCreateInfo>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PipelineInputAssemblyStateCreateInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub flags: PipelineInputAssemblyStateCreateFlags,
    pub topology: PrimitiveTopology,
    pub primitive_restart_enable: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PipelineInputAssemblyStateCreateInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PipelineInputAssemblyStateCreateInfo,
            next: ptr::null_mut(),
            flags: Default::default(),
            topology: Default::default(),
            primitive_restart_enable: FALSE,
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PipelineTessellationStateCreateInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub flags: PipelineTessellationStateCreateFlags,
    pub patch_control_points: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PipelineTessellationStateCreateInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PipelineTessellationStateCreateInfo,
            next: ptr::null_mut(),
            flags: Default::default(),
            patch_control_points: 0,
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsPipelineTessellationStateCreateInfo {}
impl<'a> PipelineTessellationStateCreateInfo<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsPipelineTessellationStateCreateInfo>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PipelineViewportStateCreateInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub flags: PipelineViewportStateCreateFlags,
    pub viewport_count: u32,
    /// Nullable
    /// Len: `viewport_count`
    pub viewports: *const Viewport,
    pub scissor_count: u32,
    /// Nullable
    /// Len: `scissor_count`
    pub scissors: *const Rect2D,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PipelineViewportStateCreateInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PipelineViewportStateCreateInfo,
            next: ptr::null_mut(),
            flags: Default::default(),
            viewport_count: 0,
            viewports: ptr::null_mut(),
            scissor_count: 0,
            scissors: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsPipelineViewportStateCreateInfo {}
impl<'a> PipelineViewportStateCreateInfo<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsPipelineViewportStateCreateInfo>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PipelineRasterizationStateCreateInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub flags: PipelineRasterizationStateCreateFlags,
    pub depth_clamp_enable: Bool32,
    pub rasterizer_discard_enable: Bool32,
    /// optional (GL45)
    pub polygon_mode: PolygonMode,
    pub cull_mode: CullModeFlags,
    pub front_face: FrontFace,
    pub depth_bias_enable: Bool32,
    pub depth_bias_constant_factor: f32,
    pub depth_bias_clamp: f32,
    pub depth_bias_slope_factor: f32,
    pub line_width: f32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PipelineRasterizationStateCreateInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PipelineRasterizationStateCreateInfo,
            next: ptr::null_mut(),
            flags: Default::default(),
            depth_clamp_enable: FALSE,
            rasterizer_discard_enable: FALSE,
            polygon_mode: Default::default(),
            cull_mode: Default::default(),
            front_face: Default::default(),
            depth_bias_enable: FALSE,
            depth_bias_constant_factor: 0.0,
            depth_bias_clamp: 0.0,
            depth_bias_slope_factor: 0.0,
            line_width: 0.0,
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsPipelineRasterizationStateCreateInfo {}
impl<'a> PipelineRasterizationStateCreateInfo<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsPipelineRasterizationStateCreateInfo>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PipelineMultisampleStateCreateInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub flags: PipelineMultisampleStateCreateFlags,
    /// Number of samples used for rasterization
    pub rasterization_samples: SampleCountFlags,
    /// optional (GL45)
    pub sample_shading_enable: Bool32,
    /// optional (GL45)
    pub min_sample_shading: f32,
    /// Array of sampleMask words
    /// Nullable
    /// Len: (rasterization_samples / 32).ceil()
    pub sample_mask: *const SampleMask,
    pub alpha_to_coverage_enable: Bool32,
    pub alpha_to_one_enable: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PipelineMultisampleStateCreateInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PipelineMultisampleStateCreateInfo,
            next: ptr::null_mut(),
            flags: Default::default(),
            rasterization_samples: Default::default(),
            sample_shading_enable: FALSE,
            min_sample_shading: 0.0,
            sample_mask: ptr::null_mut(),
            alpha_to_coverage_enable: FALSE,
            alpha_to_one_enable: FALSE,
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsPipelineMultisampleStateCreateInfo {}
impl<'a> PipelineMultisampleStateCreateInfo<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsPipelineMultisampleStateCreateInfo>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PipelineColorBlendAttachmentState {
    pub blend_enable: Bool32,
    pub src_color_blend_factor: BlendFactor,
    pub dst_color_blend_factor: BlendFactor,
    pub color_blend_op: BlendOp,
    pub src_alpha_blend_factor: BlendFactor,
    pub dst_alpha_blend_factor: BlendFactor,
    pub alpha_blend_op: BlendOp,
    pub color_write_mask: ColorComponentFlags,
}
impl Default for PipelineColorBlendAttachmentState {
    fn default() -> Self {
        Self {
            blend_enable: FALSE,
            src_color_blend_factor: Default::default(),
            dst_color_blend_factor: Default::default(),
            color_blend_op: Default::default(),
            src_alpha_blend_factor: Default::default(),
            dst_alpha_blend_factor: Default::default(),
            alpha_blend_op: Default::default(),
            color_write_mask: Default::default(),
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PipelineColorBlendStateCreateInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub flags: PipelineColorBlendStateCreateFlags,
    pub logic_op_enable: Bool32,
    pub logic_op: LogicOp,
    /// # of pAttachments
    pub attachment_count: u32,
    /// Nullable
    /// Len: `attachment_count`
    pub attachments: *const PipelineColorBlendAttachmentState,
    pub blend_constants: [f32; 4],
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PipelineColorBlendStateCreateInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PipelineColorBlendStateCreateInfo,
            next: ptr::null_mut(),
            flags: Default::default(),
            logic_op_enable: FALSE,
            logic_op: Default::default(),
            attachment_count: 0,
            attachments: ptr::null_mut(),
            blend_constants: unsafe { mem::zeroed() },
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsPipelineColorBlendStateCreateInfo {}
impl<'a> PipelineColorBlendStateCreateInfo<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsPipelineColorBlendStateCreateInfo>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PipelineDynamicStateCreateInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub flags: PipelineDynamicStateCreateFlags,
    pub dynamic_state_count: u32,
    /// Len: `dynamic_state_count`
    pub dynamic_states: *const DynamicState,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PipelineDynamicStateCreateInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PipelineDynamicStateCreateInfo,
            next: ptr::null_mut(),
            flags: Default::default(),
            dynamic_state_count: 0,
            dynamic_states: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct StencilOpState {
    pub fail_op: StencilOp,
    pub pass_op: StencilOp,
    pub depth_fail_op: StencilOp,
    pub compare_op: CompareOp,
    pub compare_mask: u32,
    pub write_mask: u32,
    pub reference: u32,
}
impl Default for StencilOpState {
    fn default() -> Self {
        Self {
            fail_op: Default::default(),
            pass_op: Default::default(),
            depth_fail_op: Default::default(),
            compare_op: Default::default(),
            compare_mask: 0,
            write_mask: 0,
            reference: 0,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PipelineDepthStencilStateCreateInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub flags: PipelineDepthStencilStateCreateFlags,
    pub depth_test_enable: Bool32,
    pub depth_write_enable: Bool32,
    pub depth_compare_op: CompareOp,
    /// optional (depth_bounds_test)
    pub depth_bounds_test_enable: Bool32,
    pub stencil_test_enable: Bool32,
    pub front: StencilOpState,
    pub back: StencilOpState,
    pub min_depth_bounds: f32,
    pub max_depth_bounds: f32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PipelineDepthStencilStateCreateInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PipelineDepthStencilStateCreateInfo,
            next: ptr::null_mut(),
            flags: Default::default(),
            depth_test_enable: FALSE,
            depth_write_enable: FALSE,
            depth_compare_op: Default::default(),
            depth_bounds_test_enable: FALSE,
            stencil_test_enable: FALSE,
            front: Default::default(),
            back: Default::default(),
            min_depth_bounds: 0.0,
            max_depth_bounds: 0.0,
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct GraphicsPipelineCreateInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    /// Pipeline creation flags
    pub flags: PipelineCreateFlags,
    pub stage_count: u32,
    /// One entry for each active shader stage
    /// Nullable
    /// Len: `stage_count`
    pub stages: *const PipelineShaderStageCreateInfo<'a>,
    /// Nullable
    pub vertex_input_state: *const PipelineVertexInputStateCreateInfo<'a>,
    /// Nullable
    pub input_assembly_state: *const PipelineInputAssemblyStateCreateInfo<'a>,
    /// Nullable
    pub tessellation_state: *const PipelineTessellationStateCreateInfo<'a>,
    /// Nullable
    pub viewport_state: *const PipelineViewportStateCreateInfo<'a>,
    /// Nullable
    pub rasterization_state: *const PipelineRasterizationStateCreateInfo<'a>,
    /// Nullable
    pub multisample_state: *const PipelineMultisampleStateCreateInfo<'a>,
    /// Nullable
    pub depth_stencil_state: *const PipelineDepthStencilStateCreateInfo<'a>,
    /// Nullable
    pub color_blend_state: *const PipelineColorBlendStateCreateInfo<'a>,
    /// Nullable
    pub dynamic_state: *const PipelineDynamicStateCreateInfo<'a>,
    /// Interface layout of the pipeline
    pub layout: PipelineLayout,
    pub render_pass: RenderPass,
    pub subpass: u32,
    /// If VK_PIPELINE_CREATE_DERIVATIVE_BIT is set and this value is nonzero, it specifies the handle of the base pipeline this is a derivative of
    pub base_pipeline_handle: Pipeline,
    /// If VK_PIPELINE_CREATE_DERIVATIVE_BIT is set and this value is not -1, it specifies an index into pCreateInfos of the base pipeline this is a derivative of
    pub base_pipeline_index: i32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for GraphicsPipelineCreateInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::GraphicsPipelineCreateInfo,
            next: ptr::null_mut(),
            flags: Default::default(),
            stage_count: 0,
            stages: ptr::null_mut(),
            vertex_input_state: ptr::null_mut(),
            input_assembly_state: ptr::null_mut(),
            tessellation_state: ptr::null_mut(),
            viewport_state: ptr::null_mut(),
            rasterization_state: ptr::null_mut(),
            multisample_state: ptr::null_mut(),
            depth_stencil_state: ptr::null_mut(),
            color_blend_state: ptr::null_mut(),
            dynamic_state: ptr::null_mut(),
            layout: Default::default(),
            render_pass: Default::default(),
            subpass: 0,
            base_pipeline_handle: Default::default(),
            base_pipeline_index: 0,
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsGraphicsPipelineCreateInfo {}
impl<'a> GraphicsPipelineCreateInfo<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsGraphicsPipelineCreateInfo>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PipelineCacheCreateInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub flags: PipelineCacheCreateFlags,
    /// Size of initial data to populate cache, in bytes
    pub initial_data_size: usize,
    /// Initial data to populate cache
    /// Len: `initial_data_size`
    pub initial_data: *const c_void,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PipelineCacheCreateInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PipelineCacheCreateInfo,
            next: ptr::null_mut(),
            flags: Default::default(),
            initial_data_size: 0,
            initial_data: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PipelineCacheHeaderVersionOne {
    pub header_size: u32,
    pub header_version: PipelineCacheHeaderVersion,
    pub vendor_id: u32,
    pub device_id: u32,
    pub pipeline_cache_uuid: [u8; UUID_SIZE as usize],
}
impl Default for PipelineCacheHeaderVersionOne {
    fn default() -> Self {
        Self {
            header_size: 0,
            header_version: Default::default(),
            vendor_id: 0,
            device_id: 0,
            pipeline_cache_uuid: unsafe { mem::zeroed() },
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PipelineCacheStageValidationIndexEntry {
    pub code_size: u64,
    pub code_offset: u64,
}
impl Default for PipelineCacheStageValidationIndexEntry {
    fn default() -> Self {
        Self {
            code_size: 0,
            code_offset: 0,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PipelineCacheSafetyCriticalIndexEntry {
    pub pipeline_identifier: [u8; UUID_SIZE as usize],
    pub pipeline_memory_size: u64,
    pub json_size: u64,
    pub json_offset: u64,
    pub stage_index_count: u32,
    pub stage_index_stride: u32,
    pub stage_index_offset: u64,
}
impl Default for PipelineCacheSafetyCriticalIndexEntry {
    fn default() -> Self {
        Self {
            pipeline_identifier: unsafe { mem::zeroed() },
            pipeline_memory_size: 0,
            json_size: 0,
            json_offset: 0,
            stage_index_count: 0,
            stage_index_stride: 0,
            stage_index_offset: 0,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PipelineCacheHeaderVersionSafetyCriticalOne {
    pub header_version_one: PipelineCacheHeaderVersionOne,
    pub validation_version: PipelineCacheValidationVersion,
    pub implementation_data: u32,
    pub pipeline_index_count: u32,
    pub pipeline_index_stride: u32,
    pub pipeline_index_offset: u64,
}
impl Default for PipelineCacheHeaderVersionSafetyCriticalOne {
    fn default() -> Self {
        Self {
            header_version_one: Default::default(),
            validation_version: Default::default(),
            implementation_data: 0,
            pipeline_index_count: 0,
            pipeline_index_stride: 0,
            pipeline_index_offset: 0,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PipelineCacheHeaderVersionDataGraphQCOM {
    pub header_size: u32,
    pub header_version: PipelineCacheHeaderVersion,
    pub cache_type: DataGraphModelCacheTypeQCOM,
    pub cache_version: u32,
    pub toolchain_version: [u32; DATA_GRAPH_MODEL_TOOLCHAIN_VERSION_LENGTH_QCOM as usize],
}
impl Default for PipelineCacheHeaderVersionDataGraphQCOM {
    fn default() -> Self {
        Self {
            header_size: 0,
            header_version: Default::default(),
            cache_type: Default::default(),
            cache_version: 0,
            toolchain_version: unsafe { mem::zeroed() },
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PushConstantRange {
    /// Which stages use the range
    pub stage_flags: ShaderStageFlags,
    /// Start of the range, in bytes
    pub offset: u32,
    /// Size of the range, in bytes
    pub size: u32,
}
impl Default for PushConstantRange {
    fn default() -> Self {
        Self {
            stage_flags: Default::default(),
            offset: 0,
            size: 0,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PipelineBinaryCreateInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    /// Nullable
    pub keys_and_data_info: *const PipelineBinaryKeysAndDataKHR<'a>,
    pub pipeline: Pipeline,
    /// Nullable
    pub pipeline_create_info: *const PipelineCreateInfoKHR<'a>,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PipelineBinaryCreateInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PipelineBinaryCreateInfoKHR,
            next: ptr::null_mut(),
            keys_and_data_info: ptr::null_mut(),
            pipeline: Default::default(),
            pipeline_create_info: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PipelineBinaryHandlesInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub pipeline_binary_count: u32,
    /// Nullable
    /// Len: `pipeline_binary_count`
    pub pipeline_binaries: *mut PipelineBinaryKHR,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PipelineBinaryHandlesInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PipelineBinaryHandlesInfoKHR,
            next: ptr::null_mut(),
            pipeline_binary_count: 0,
            pipeline_binaries: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PipelineBinaryDataKHR<'a> {
    pub data_size: usize,
    /// Len: `data_size`
    pub data: *mut c_void,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PipelineBinaryDataKHR<'_> {
    fn default() -> Self {
        Self {
            data_size: 0,
            data: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PipelineBinaryKeysAndDataKHR<'a> {
    pub binary_count: u32,
    /// Len: `binary_count`
    pub pipeline_binary_keys: *const PipelineBinaryKeyKHR<'a>,
    /// Len: `binary_count`
    pub pipeline_binary_data: *const PipelineBinaryDataKHR<'a>,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PipelineBinaryKeysAndDataKHR<'_> {
    fn default() -> Self {
        Self {
            binary_count: 0,
            pipeline_binary_keys: ptr::null_mut(),
            pipeline_binary_data: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PipelineBinaryKeyKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub key_size: u32,
    pub key: [u8; MAX_PIPELINE_BINARY_KEY_SIZE_KHR as usize],
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PipelineBinaryKeyKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PipelineBinaryKeyKHR,
            next: ptr::null_mut(),
            key_size: 0,
            key: unsafe { mem::zeroed() },
            _marker: PhantomData,
        }
    }
}

/// Extends: `GraphicsPipelineCreateInfo`, `ComputePipelineCreateInfo`, `RayTracingPipelineCreateInfoKHR`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PipelineBinaryInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub binary_count: u32,
    /// Len: `binary_count`
    pub pipeline_binaries: *const PipelineBinaryKHR,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PipelineBinaryInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PipelineBinaryInfoKHR,
            next: ptr::null_mut(),
            binary_count: 0,
            pipeline_binaries: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsGraphicsPipelineCreateInfo for PipelineBinaryInfoKHR<'_> {}
impl ExtendsComputePipelineCreateInfo for PipelineBinaryInfoKHR<'_> {}
impl ExtendsRayTracingPipelineCreateInfoKHR for PipelineBinaryInfoKHR<'_> {}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ReleaseCapturedPipelineDataInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub pipeline: Pipeline,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ReleaseCapturedPipelineDataInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ReleaseCapturedPipelineDataInfoKHR,
            next: ptr::null_mut(),
            pipeline: Default::default(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PipelineBinaryDataInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub pipeline_binary: PipelineBinaryKHR,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PipelineBinaryDataInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PipelineBinaryDataInfoKHR,
            next: ptr::null_mut(),
            pipeline_binary: Default::default(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PipelineCreateInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PipelineCreateInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PipelineCreateInfoKHR,
            next: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

/// Extends: `BindDescriptorSetsInfo`, `PushConstantsInfo`, `PushDescriptorSetInfo`, `PushDescriptorSetWithTemplateInfo`, `SetDescriptorBufferOffsetsInfoEXT`, `BindDescriptorBufferEmbeddedSamplersInfoEXT`, `IndirectCommandsLayoutCreateInfoEXT`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PipelineLayoutCreateInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub flags: PipelineLayoutCreateFlags,
    /// Number of descriptor sets interfaced by the pipeline
    pub set_layout_count: u32,
    /// Array of setCount number of descriptor set layout objects defining the layout of the
    /// Nullable
    /// Len: `set_layout_count`
    pub set_layouts: *const DescriptorSetLayout,
    /// Number of push-constant ranges used by the pipeline
    pub push_constant_range_count: u32,
    /// Array of pushConstantRangeCount number of ranges used by various shader stages
    /// Len: `push_constant_range_count`
    pub push_constant_ranges: *const PushConstantRange,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PipelineLayoutCreateInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PipelineLayoutCreateInfo,
            next: ptr::null_mut(),
            flags: Default::default(),
            set_layout_count: 0,
            set_layouts: ptr::null_mut(),
            push_constant_range_count: 0,
            push_constant_ranges: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsBindDescriptorSetsInfo for PipelineLayoutCreateInfo<'_> {}
impl ExtendsPushConstantsInfo for PipelineLayoutCreateInfo<'_> {}
impl ExtendsPushDescriptorSetInfo for PipelineLayoutCreateInfo<'_> {}
impl ExtendsPushDescriptorSetWithTemplateInfo for PipelineLayoutCreateInfo<'_> {}
impl ExtendsSetDescriptorBufferOffsetsInfoEXT for PipelineLayoutCreateInfo<'_> {}
impl ExtendsBindDescriptorBufferEmbeddedSamplersInfoEXT for PipelineLayoutCreateInfo<'_> {}
impl ExtendsIndirectCommandsLayoutCreateInfoEXT for PipelineLayoutCreateInfo<'_> {}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct SamplerCreateInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub flags: SamplerCreateFlags,
    /// Filter mode for magnification
    pub mag_filter: Filter,
    /// Filter mode for minifiation
    pub min_filter: Filter,
    /// Mipmap selection mode
    pub mipmap_mode: SamplerMipmapMode,
    pub address_mode_u: SamplerAddressMode,
    pub address_mode_v: SamplerAddressMode,
    pub address_mode_w: SamplerAddressMode,
    pub mip_lod_bias: f32,
    pub anisotropy_enable: Bool32,
    pub max_anisotropy: f32,
    pub compare_enable: Bool32,
    pub compare_op: CompareOp,
    pub min_lod: f32,
    pub max_lod: f32,
    pub border_color: BorderColor,
    pub unnormalized_coordinates: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for SamplerCreateInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::SamplerCreateInfo,
            next: ptr::null_mut(),
            flags: Default::default(),
            mag_filter: Default::default(),
            min_filter: Default::default(),
            mipmap_mode: Default::default(),
            address_mode_u: Default::default(),
            address_mode_v: Default::default(),
            address_mode_w: Default::default(),
            mip_lod_bias: 0.0,
            anisotropy_enable: FALSE,
            max_anisotropy: 0.0,
            compare_enable: FALSE,
            compare_op: Default::default(),
            min_lod: 0.0,
            max_lod: 0.0,
            border_color: Default::default(),
            unnormalized_coordinates: FALSE,
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsSamplerCreateInfo {}
impl<'a> SamplerCreateInfo<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsSamplerCreateInfo>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct CommandPoolCreateInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    /// Command pool creation flags
    pub flags: CommandPoolCreateFlags,
    pub queue_family_index: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for CommandPoolCreateInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::CommandPoolCreateInfo,
            next: ptr::null_mut(),
            flags: Default::default(),
            queue_family_index: 0,
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsCommandPoolCreateInfo {}
impl<'a> CommandPoolCreateInfo<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsCommandPoolCreateInfo>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct CommandBufferAllocateInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub command_pool: CommandPool,
    pub level: CommandBufferLevel,
    pub command_buffer_count: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for CommandBufferAllocateInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::CommandBufferAllocateInfo,
            next: ptr::null_mut(),
            command_pool: Default::default(),
            level: Default::default(),
            command_buffer_count: 0,
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct CommandBufferInheritanceInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    /// Render pass for secondary command buffers
    pub render_pass: RenderPass,
    pub subpass: u32,
    /// Framebuffer for secondary command buffers
    pub framebuffer: Framebuffer,
    /// Whether this secondary command buffer may be executed during an occlusion query
    pub occlusion_query_enable: Bool32,
    /// Query flags used by this secondary command buffer, if executed during an occlusion query
    pub query_flags: QueryControlFlags,
    /// Pipeline statistics that may be counted for this secondary command buffer
    pub pipeline_statistics: QueryPipelineStatisticFlags,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for CommandBufferInheritanceInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::CommandBufferInheritanceInfo,
            next: ptr::null_mut(),
            render_pass: Default::default(),
            subpass: 0,
            framebuffer: Default::default(),
            occlusion_query_enable: FALSE,
            query_flags: Default::default(),
            pipeline_statistics: Default::default(),
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsCommandBufferInheritanceInfo {}
impl<'a> CommandBufferInheritanceInfo<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsCommandBufferInheritanceInfo>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct CommandBufferBeginInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    /// Command buffer usage flags
    pub flags: CommandBufferUsageFlags,
    /// Pointer to inheritance info for secondary command buffers
    /// Nullable
    pub inheritance_info: *const CommandBufferInheritanceInfo<'a>,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for CommandBufferBeginInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::CommandBufferBeginInfo,
            next: ptr::null_mut(),
            flags: Default::default(),
            inheritance_info: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsCommandBufferBeginInfo {}
impl<'a> CommandBufferBeginInfo<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsCommandBufferBeginInfo>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct RenderPassBeginInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub render_pass: RenderPass,
    pub framebuffer: Framebuffer,
    pub render_area: Rect2D,
    pub clear_value_count: u32,
    /// Len: `clear_value_count`
    pub clear_values: *const ClearValue,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for RenderPassBeginInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::RenderPassBeginInfo,
            next: ptr::null_mut(),
            render_pass: Default::default(),
            framebuffer: Default::default(),
            render_area: Default::default(),
            clear_value_count: 0,
            clear_values: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsRenderPassBeginInfo {}
impl<'a> RenderPassBeginInfo<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsRenderPassBeginInfo>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub union ClearColorValue {
    pub float32: [f32; 4],
    pub int32: [i32; 4],
    pub uint32: [u32; 4],
}
impl Default for ClearColorValue {
    fn default() -> Self {
        unsafe { mem::zeroed() }
    }
}

impl fmt::Debug for ClearColorValue {
    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
        fmt.debug_struct("ClearColorValue").finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ClearDepthStencilValue {
    pub depth: f32,
    pub stencil: u32,
}
impl Default for ClearDepthStencilValue {
    fn default() -> Self {
        Self {
            depth: 0.0,
            stencil: 0,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub union ClearValue {
    pub color: ClearColorValue,
    pub depth_stencil: ClearDepthStencilValue,
}
impl Default for ClearValue {
    fn default() -> Self {
        unsafe { mem::zeroed() }
    }
}

impl fmt::Debug for ClearValue {
    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
        fmt.debug_struct("ClearValue").finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ClearAttachment {
    pub aspect_mask: ImageAspectFlags,
    pub color_attachment: u32,
    pub clear_value: ClearValue,
}
impl Default for ClearAttachment {
    fn default() -> Self {
        Self {
            aspect_mask: Default::default(),
            color_attachment: 0,
            clear_value: Default::default(),
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct AttachmentDescription {
    pub flags: AttachmentDescriptionFlags,
    pub format: Format,
    pub samples: SampleCountFlags,
    /// Load operation for color or depth data
    pub load_op: AttachmentLoadOp,
    /// Store operation for color or depth data
    pub store_op: AttachmentStoreOp,
    /// Load operation for stencil data
    pub stencil_load_op: AttachmentLoadOp,
    /// Store operation for stencil data
    pub stencil_store_op: AttachmentStoreOp,
    pub initial_layout: ImageLayout,
    pub final_layout: ImageLayout,
}
impl Default for AttachmentDescription {
    fn default() -> Self {
        Self {
            flags: Default::default(),
            format: Default::default(),
            samples: Default::default(),
            load_op: Default::default(),
            store_op: Default::default(),
            stencil_load_op: Default::default(),
            stencil_store_op: Default::default(),
            initial_layout: Default::default(),
            final_layout: Default::default(),
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct AttachmentReference {
    pub attachment: u32,
    pub layout: ImageLayout,
}
impl Default for AttachmentReference {
    fn default() -> Self {
        Self {
            attachment: 0,
            layout: Default::default(),
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct SubpassDescription<'a> {
    pub flags: SubpassDescriptionFlags,
    /// Must be VK_PIPELINE_BIND_POINT_GRAPHICS for now
    pub pipeline_bind_point: PipelineBindPoint,
    pub input_attachment_count: u32,
    /// Len: `input_attachment_count`
    pub input_attachments: *const AttachmentReference,
    pub color_attachment_count: u32,
    /// Len: `color_attachment_count`
    pub color_attachments: *const AttachmentReference,
    /// Nullable
    /// Len: `color_attachment_count`
    pub resolve_attachments: *const AttachmentReference,
    /// Nullable
    pub depth_stencil_attachment: *const AttachmentReference,
    pub preserve_attachment_count: u32,
    /// Len: `preserve_attachment_count`
    pub preserve_attachments: *const u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for SubpassDescription<'_> {
    fn default() -> Self {
        Self {
            flags: Default::default(),
            pipeline_bind_point: Default::default(),
            input_attachment_count: 0,
            input_attachments: ptr::null_mut(),
            color_attachment_count: 0,
            color_attachments: ptr::null_mut(),
            resolve_attachments: ptr::null_mut(),
            depth_stencil_attachment: ptr::null_mut(),
            preserve_attachment_count: 0,
            preserve_attachments: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct SubpassDependency {
    pub src_subpass: u32,
    pub dst_subpass: u32,
    pub src_stage_mask: PipelineStageFlags,
    pub dst_stage_mask: PipelineStageFlags,
    /// Memory accesses from the source of the dependency to synchronize
    pub src_access_mask: AccessFlags,
    /// Memory accesses from the destination of the dependency to synchronize
    pub dst_access_mask: AccessFlags,
    pub dependency_flags: DependencyFlags,
}
impl Default for SubpassDependency {
    fn default() -> Self {
        Self {
            src_subpass: 0,
            dst_subpass: 0,
            src_stage_mask: Default::default(),
            dst_stage_mask: Default::default(),
            src_access_mask: Default::default(),
            dst_access_mask: Default::default(),
            dependency_flags: Default::default(),
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct RenderPassCreateInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub flags: RenderPassCreateFlags,
    pub attachment_count: u32,
    /// Len: `attachment_count`
    pub attachments: *const AttachmentDescription,
    pub subpass_count: u32,
    /// Len: `subpass_count`
    pub subpasses: *const SubpassDescription<'a>,
    pub dependency_count: u32,
    /// Len: `dependency_count`
    pub dependencies: *const SubpassDependency,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for RenderPassCreateInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::RenderPassCreateInfo,
            next: ptr::null_mut(),
            flags: Default::default(),
            attachment_count: 0,
            attachments: ptr::null_mut(),
            subpass_count: 0,
            subpasses: ptr::null_mut(),
            dependency_count: 0,
            dependencies: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsRenderPassCreateInfo {}
impl<'a> RenderPassCreateInfo<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsRenderPassCreateInfo>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct EventCreateInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    /// Event creation flags
    pub flags: EventCreateFlags,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for EventCreateInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::EventCreateInfo,
            next: ptr::null_mut(),
            flags: Default::default(),
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsEventCreateInfo {}
impl<'a> EventCreateInfo<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsEventCreateInfo>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct FenceCreateInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    /// Fence creation flags
    pub flags: FenceCreateFlags,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for FenceCreateInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::FenceCreateInfo,
            next: ptr::null_mut(),
            flags: Default::default(),
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsFenceCreateInfo {}
impl<'a> FenceCreateInfo<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsFenceCreateInfo>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceFeatures {
    /// out of bounds buffer accesses are well defined
    pub robust_buffer_access: Bool32,
    /// full 32-bit range of indices for indexed draw calls
    pub full_draw_index_uint32: Bool32,
    /// image views which are arrays of cube maps
    pub image_cube_array: Bool32,
    /// blending operations are controlled per-attachment
    pub independent_blend: Bool32,
    /// geometry stage
    pub geometry_shader: Bool32,
    /// tessellation control and evaluation stage
    pub tessellation_shader: Bool32,
    /// per-sample shading and interpolation
    pub sample_rate_shading: Bool32,
    /// blend operations which take two sources
    pub dual_src_blend: Bool32,
    /// logic operations
    pub logic_op: Bool32,
    /// multi draw indirect
    pub multi_draw_indirect: Bool32,
    /// indirect drawing can use non-zero firstInstance
    pub draw_indirect_first_instance: Bool32,
    /// depth clamping
    pub depth_clamp: Bool32,
    /// depth bias clamping
    pub depth_bias_clamp: Bool32,
    /// point and wireframe fill modes
    pub fill_mode_non_solid: Bool32,
    /// depth bounds test
    pub depth_bounds: Bool32,
    /// lines with width greater than 1
    pub wide_lines: Bool32,
    /// points with size greater than 1
    pub large_points: Bool32,
    /// the fragment alpha component can be forced to maximum representable alpha value
    pub alpha_to_one: Bool32,
    /// viewport arrays
    pub multi_viewport: Bool32,
    /// anisotropic sampler filtering
    pub sampler_anisotropy: Bool32,
    /// ETC texture compression formats
    pub texture_compression_etc2: Bool32,
    /// ASTC LDR texture compression formats
    pub texture_compression_astc_ldr: Bool32,
    /// BC1-7 texture compressed formats
    pub texture_compression_bc: Bool32,
    /// precise occlusion queries returning actual sample counts
    pub occlusion_query_precise: Bool32,
    /// pipeline statistics query
    pub pipeline_statistics_query: Bool32,
    /// stores and atomic ops on storage buffers and images are supported in vertex, tessellation, and geometry stages
    pub vertex_pipeline_stores_and_atomics: Bool32,
    /// stores and atomic ops on storage buffers and images are supported in the fragment stage
    pub fragment_stores_and_atomics: Bool32,
    /// tessellation and geometry stages can export point size
    pub shader_tessellation_and_geometry_point_size: Bool32,
    /// image gather with runtime values and independent offsets
    pub shader_image_gather_extended: Bool32,
    /// the extended set of formats can be used for storage images
    pub shader_storage_image_extended_formats: Bool32,
    /// multisample images can be used for storage images
    pub shader_storage_image_multisample: Bool32,
    /// read from storage image does not require format qualifier
    pub shader_storage_image_read_without_format: Bool32,
    /// write to storage image does not require format qualifier
    pub shader_storage_image_write_without_format: Bool32,
    /// arrays of uniform buffers can be accessed with dynamically uniform indices
    pub shader_uniform_buffer_array_dynamic_indexing: Bool32,
    /// arrays of sampled images can be accessed with dynamically uniform indices
    pub shader_sampled_image_array_dynamic_indexing: Bool32,
    /// arrays of storage buffers can be accessed with dynamically uniform indices
    pub shader_storage_buffer_array_dynamic_indexing: Bool32,
    /// arrays of storage images can be accessed with dynamically uniform indices
    pub shader_storage_image_array_dynamic_indexing: Bool32,
    /// clip distance in shaders
    pub shader_clip_distance: Bool32,
    /// cull distance in shaders
    pub shader_cull_distance: Bool32,
    /// 64-bit floats (doubles) in shaders
    pub shader_float64: Bool32,
    /// 64-bit integers in shaders
    pub shader_int64: Bool32,
    /// 16-bit integers in shaders
    pub shader_int16: Bool32,
    /// shader can use texture operations that return resource residency information (requires sparseNonResident support)
    pub shader_resource_residency: Bool32,
    /// shader can use texture operations that specify minimum resource LOD
    pub shader_resource_min_lod: Bool32,
    /// Sparse resources support: Resource memory can be managed at opaque page level rather than object level
    pub sparse_binding: Bool32,
    /// Sparse resources support: GPU can access partially resident buffers
    pub sparse_residency_buffer: Bool32,
    /// Sparse resources support: GPU can access partially resident 2D (non-MSAA non-depth/stencil) images
    pub sparse_residency_image2_d: Bool32,
    /// Sparse resources support: GPU can access partially resident 3D images
    pub sparse_residency_image3_d: Bool32,
    /// Sparse resources support: GPU can access partially resident MSAA 2D images with 2 samples
    pub sparse_residency2_samples: Bool32,
    /// Sparse resources support: GPU can access partially resident MSAA 2D images with 4 samples
    pub sparse_residency4_samples: Bool32,
    /// Sparse resources support: GPU can access partially resident MSAA 2D images with 8 samples
    pub sparse_residency8_samples: Bool32,
    /// Sparse resources support: GPU can access partially resident MSAA 2D images with 16 samples
    pub sparse_residency16_samples: Bool32,
    /// Sparse resources support: GPU can correctly access data aliased into multiple locations (opt-in)
    pub sparse_residency_aliased: Bool32,
    /// multisample rate must be the same for all pipelines in a subpass
    pub variable_multisample_rate: Bool32,
    /// Queries may be inherited from primary to secondary command buffers
    pub inherited_queries: Bool32,
}
impl Default for PhysicalDeviceFeatures {
    fn default() -> Self {
        Self {
            robust_buffer_access: FALSE,
            full_draw_index_uint32: FALSE,
            image_cube_array: FALSE,
            independent_blend: FALSE,
            geometry_shader: FALSE,
            tessellation_shader: FALSE,
            sample_rate_shading: FALSE,
            dual_src_blend: FALSE,
            logic_op: FALSE,
            multi_draw_indirect: FALSE,
            draw_indirect_first_instance: FALSE,
            depth_clamp: FALSE,
            depth_bias_clamp: FALSE,
            fill_mode_non_solid: FALSE,
            depth_bounds: FALSE,
            wide_lines: FALSE,
            large_points: FALSE,
            alpha_to_one: FALSE,
            multi_viewport: FALSE,
            sampler_anisotropy: FALSE,
            texture_compression_etc2: FALSE,
            texture_compression_astc_ldr: FALSE,
            texture_compression_bc: FALSE,
            occlusion_query_precise: FALSE,
            pipeline_statistics_query: FALSE,
            vertex_pipeline_stores_and_atomics: FALSE,
            fragment_stores_and_atomics: FALSE,
            shader_tessellation_and_geometry_point_size: FALSE,
            shader_image_gather_extended: FALSE,
            shader_storage_image_extended_formats: FALSE,
            shader_storage_image_multisample: FALSE,
            shader_storage_image_read_without_format: FALSE,
            shader_storage_image_write_without_format: FALSE,
            shader_uniform_buffer_array_dynamic_indexing: FALSE,
            shader_sampled_image_array_dynamic_indexing: FALSE,
            shader_storage_buffer_array_dynamic_indexing: FALSE,
            shader_storage_image_array_dynamic_indexing: FALSE,
            shader_clip_distance: FALSE,
            shader_cull_distance: FALSE,
            shader_float64: FALSE,
            shader_int64: FALSE,
            shader_int16: FALSE,
            shader_resource_residency: FALSE,
            shader_resource_min_lod: FALSE,
            sparse_binding: FALSE,
            sparse_residency_buffer: FALSE,
            sparse_residency_image2_d: FALSE,
            sparse_residency_image3_d: FALSE,
            sparse_residency2_samples: FALSE,
            sparse_residency4_samples: FALSE,
            sparse_residency8_samples: FALSE,
            sparse_residency16_samples: FALSE,
            sparse_residency_aliased: FALSE,
            variable_multisample_rate: FALSE,
            inherited_queries: FALSE,
        }
    }
}

/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceSparseProperties {
    /// Sparse resources support: GPU will access all 2D (single sample) sparse resources using the standard sparse image block shapes (based on pixel format)
    pub residency_standard2_d_block_shape: Bool32,
    /// Sparse resources support: GPU will access all 2D (multisample) sparse resources using the standard sparse image block shapes (based on pixel format)
    pub residency_standard2_d_multisample_block_shape: Bool32,
    /// Sparse resources support: GPU will access all 3D sparse resources using the standard sparse image block shapes (based on pixel format)
    pub residency_standard3_d_block_shape: Bool32,
    /// Sparse resources support: Images with mip level dimensions that are NOT a multiple of the sparse image block dimensions will be placed in the mip tail
    pub residency_aligned_mip_size: Bool32,
    /// Sparse resources support: GPU can consistently access non-resident regions of a resource, all reads return as if data is 0, writes are discarded
    pub residency_non_resident_strict: Bool32,
}
impl Default for PhysicalDeviceSparseProperties {
    fn default() -> Self {
        Self {
            residency_standard2_d_block_shape: FALSE,
            residency_standard2_d_multisample_block_shape: FALSE,
            residency_standard3_d_block_shape: FALSE,
            residency_aligned_mip_size: FALSE,
            residency_non_resident_strict: FALSE,
        }
    }
}

/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceLimits {
    /// max 1D image dimension
    pub max_image_dimension1_d: u32,
    /// max 2D image dimension
    pub max_image_dimension2_d: u32,
    /// max 3D image dimension
    pub max_image_dimension3_d: u32,
    /// max cube map image dimension
    pub max_image_dimension_cube: u32,
    /// max layers for image arrays
    pub max_image_array_layers: u32,
    /// max texel buffer size (fstexels)
    pub max_texel_buffer_elements: u32,
    /// max uniform buffer range (bytes)
    pub max_uniform_buffer_range: u32,
    /// max storage buffer range (bytes)
    pub max_storage_buffer_range: u32,
    /// max size of the push constants pool (bytes)
    pub max_push_constants_size: u32,
    /// max number of device memory allocations supported
    pub max_memory_allocation_count: u32,
    /// max number of samplers that can be allocated on a device
    pub max_sampler_allocation_count: u32,
    /// Granularity (in bytes) at which buffers and images can be bound to adjacent memory for simultaneous usage
    pub buffer_image_granularity: DeviceSize,
    /// Total address space available for sparse allocations (bytes)
    pub sparse_address_space_size: DeviceSize,
    /// max number of descriptors sets that can be bound to a pipeline
    pub max_bound_descriptor_sets: u32,
    /// max number of samplers allowed per-stage in a descriptor set
    pub max_per_stage_descriptor_samplers: u32,
    /// max number of uniform buffers allowed per-stage in a descriptor set
    pub max_per_stage_descriptor_uniform_buffers: u32,
    /// max number of storage buffers allowed per-stage in a descriptor set
    pub max_per_stage_descriptor_storage_buffers: u32,
    /// max number of sampled images allowed per-stage in a descriptor set
    pub max_per_stage_descriptor_sampled_images: u32,
    /// max number of storage images allowed per-stage in a descriptor set
    pub max_per_stage_descriptor_storage_images: u32,
    /// max number of input attachments allowed per-stage in a descriptor set
    pub max_per_stage_descriptor_input_attachments: u32,
    /// max number of resources allowed by a single stage
    pub max_per_stage_resources: u32,
    /// max number of samplers allowed in all stages in a descriptor set
    pub max_descriptor_set_samplers: u32,
    /// max number of uniform buffers allowed in all stages in a descriptor set
    pub max_descriptor_set_uniform_buffers: u32,
    /// max number of dynamic uniform buffers allowed in all stages in a descriptor set
    pub max_descriptor_set_uniform_buffers_dynamic: u32,
    /// max number of storage buffers allowed in all stages in a descriptor set
    pub max_descriptor_set_storage_buffers: u32,
    /// max number of dynamic storage buffers allowed in all stages in a descriptor set
    pub max_descriptor_set_storage_buffers_dynamic: u32,
    /// max number of sampled images allowed in all stages in a descriptor set
    pub max_descriptor_set_sampled_images: u32,
    /// max number of storage images allowed in all stages in a descriptor set
    pub max_descriptor_set_storage_images: u32,
    /// max number of input attachments allowed in all stages in a descriptor set
    pub max_descriptor_set_input_attachments: u32,
    /// max number of vertex input attribute slots
    pub max_vertex_input_attributes: u32,
    /// max number of vertex input binding slots
    pub max_vertex_input_bindings: u32,
    /// max vertex input attribute offset added to vertex buffer offset
    pub max_vertex_input_attribute_offset: u32,
    /// max vertex input binding stride
    pub max_vertex_input_binding_stride: u32,
    /// max number of output components written by vertex shader
    pub max_vertex_output_components: u32,
    /// max level supported by tessellation primitive generator
    pub max_tessellation_generation_level: u32,
    /// max patch size (vertices)
    pub max_tessellation_patch_size: u32,
    /// max number of input components per-vertex in TCS
    pub max_tessellation_control_per_vertex_input_components: u32,
    /// max number of output components per-vertex in TCS
    pub max_tessellation_control_per_vertex_output_components: u32,
    /// max number of output components per-patch in TCS
    pub max_tessellation_control_per_patch_output_components: u32,
    /// max total number of per-vertex and per-patch output components in TCS
    pub max_tessellation_control_total_output_components: u32,
    /// max number of input components per vertex in TES
    pub max_tessellation_evaluation_input_components: u32,
    /// max number of output components per vertex in TES
    pub max_tessellation_evaluation_output_components: u32,
    /// max invocation count supported in geometry shader
    pub max_geometry_shader_invocations: u32,
    /// max number of input components read in geometry stage
    pub max_geometry_input_components: u32,
    /// max number of output components written in geometry stage
    pub max_geometry_output_components: u32,
    /// max number of vertices that can be emitted in geometry stage
    pub max_geometry_output_vertices: u32,
    /// max total number of components (all vertices) written in geometry stage
    pub max_geometry_total_output_components: u32,
    /// max number of input components read in fragment stage
    pub max_fragment_input_components: u32,
    /// max number of output attachments written in fragment stage
    pub max_fragment_output_attachments: u32,
    /// max number of output attachments written when using dual source blending
    pub max_fragment_dual_src_attachments: u32,
    /// max total number of storage buffers, storage images and output buffers
    pub max_fragment_combined_output_resources: u32,
    /// max total storage size of work group local storage (bytes)
    pub max_compute_shared_memory_size: u32,
    /// max num of compute work groups that may be dispatched by a single command (x,y,z)
    pub max_compute_work_group_count: [u32; 3],
    /// max total compute invocations in a single local work group
    pub max_compute_work_group_invocations: u32,
    /// max local size of a compute work group (x,y,z)
    pub max_compute_work_group_size: [u32; 3],
    /// number bits of subpixel precision in screen x and y
    pub sub_pixel_precision_bits: u32,
    /// number bits of precision for selecting texel weights
    pub sub_texel_precision_bits: u32,
    /// number bits of precision for selecting mipmap weights
    pub mipmap_precision_bits: u32,
    /// max index value for indexed draw calls (for 32-bit indices)
    pub max_draw_indexed_index_value: u32,
    /// max draw count for indirect drawing calls
    pub max_draw_indirect_count: u32,
    /// max absolute sampler LOD bias
    pub max_sampler_lod_bias: f32,
    /// max degree of sampler anisotropy
    pub max_sampler_anisotropy: f32,
    /// max number of active viewports
    pub max_viewports: u32,
    /// max viewport dimensions (x,y)
    pub max_viewport_dimensions: [u32; 2],
    /// viewport bounds range (min,max)
    pub viewport_bounds_range: [f32; 2],
    /// number bits of subpixel precision for viewport
    pub viewport_sub_pixel_bits: u32,
    /// min required alignment of pointers returned by MapMemory (bytes)
    pub min_memory_map_alignment: usize,
    /// min required alignment for texel buffer offsets (bytes)
    pub min_texel_buffer_offset_alignment: DeviceSize,
    /// min required alignment for uniform buffer sizes and offsets (bytes)
    pub min_uniform_buffer_offset_alignment: DeviceSize,
    /// min required alignment for storage buffer offsets (bytes)
    pub min_storage_buffer_offset_alignment: DeviceSize,
    /// min texel offset for OpTextureSampleOffset
    pub min_texel_offset: i32,
    /// max texel offset for OpTextureSampleOffset
    pub max_texel_offset: u32,
    /// min texel offset for OpTextureGatherOffset
    pub min_texel_gather_offset: i32,
    /// max texel offset for OpTextureGatherOffset
    pub max_texel_gather_offset: u32,
    /// furthest negative offset for interpolateAtOffset
    pub min_interpolation_offset: f32,
    /// furthest positive offset for interpolateAtOffset
    pub max_interpolation_offset: f32,
    /// number of subpixel bits for interpolateAtOffset
    pub sub_pixel_interpolation_offset_bits: u32,
    /// max width for a framebuffer
    pub max_framebuffer_width: u32,
    /// max height for a framebuffer
    pub max_framebuffer_height: u32,
    /// max layer count for a layered framebuffer
    pub max_framebuffer_layers: u32,
    /// supported color sample counts for a framebuffer
    pub framebuffer_color_sample_counts: SampleCountFlags,
    /// supported depth sample counts for a framebuffer
    pub framebuffer_depth_sample_counts: SampleCountFlags,
    /// supported stencil sample counts for a framebuffer
    pub framebuffer_stencil_sample_counts: SampleCountFlags,
    /// supported sample counts for a subpass which uses no attachments
    pub framebuffer_no_attachments_sample_counts: SampleCountFlags,
    /// max number of color attachments per subpass
    pub max_color_attachments: u32,
    /// supported color sample counts for a non-integer sampled image
    pub sampled_image_color_sample_counts: SampleCountFlags,
    /// supported sample counts for an integer image
    pub sampled_image_integer_sample_counts: SampleCountFlags,
    /// supported depth sample counts for a sampled image
    pub sampled_image_depth_sample_counts: SampleCountFlags,
    /// supported stencil sample counts for a sampled image
    pub sampled_image_stencil_sample_counts: SampleCountFlags,
    /// supported sample counts for a storage image
    pub storage_image_sample_counts: SampleCountFlags,
    /// max number of sample mask words
    pub max_sample_mask_words: u32,
    /// timestamps on graphics and compute queues
    pub timestamp_compute_and_graphics: Bool32,
    /// number of nanoseconds it takes for timestamp query value to increment by 1
    pub timestamp_period: f32,
    /// max number of clip distances
    pub max_clip_distances: u32,
    /// max number of cull distances
    pub max_cull_distances: u32,
    /// max combined number of user clipping
    pub max_combined_clip_and_cull_distances: u32,
    /// distinct queue priorities available
    pub discrete_queue_priorities: u32,
    /// range (min,max) of supported point sizes
    pub point_size_range: [f32; 2],
    /// range (min,max) of supported line widths
    pub line_width_range: [f32; 2],
    /// granularity of supported point sizes
    pub point_size_granularity: f32,
    /// granularity of supported line widths
    pub line_width_granularity: f32,
    /// line rasterization follows preferred rules
    pub strict_lines: Bool32,
    /// supports standard sample locations for all supported sample counts
    pub standard_sample_locations: Bool32,
    /// optimal offset of buffer copies
    pub optimal_buffer_copy_offset_alignment: DeviceSize,
    /// optimal pitch of buffer copies
    pub optimal_buffer_copy_row_pitch_alignment: DeviceSize,
    /// minimum size and alignment for non-coherent host-mapped device memory access
    pub non_coherent_atom_size: DeviceSize,
}
impl Default for PhysicalDeviceLimits {
    fn default() -> Self {
        Self {
            max_image_dimension1_d: 0,
            max_image_dimension2_d: 0,
            max_image_dimension3_d: 0,
            max_image_dimension_cube: 0,
            max_image_array_layers: 0,
            max_texel_buffer_elements: 0,
            max_uniform_buffer_range: 0,
            max_storage_buffer_range: 0,
            max_push_constants_size: 0,
            max_memory_allocation_count: 0,
            max_sampler_allocation_count: 0,
            buffer_image_granularity: Default::default(),
            sparse_address_space_size: Default::default(),
            max_bound_descriptor_sets: 0,
            max_per_stage_descriptor_samplers: 0,
            max_per_stage_descriptor_uniform_buffers: 0,
            max_per_stage_descriptor_storage_buffers: 0,
            max_per_stage_descriptor_sampled_images: 0,
            max_per_stage_descriptor_storage_images: 0,
            max_per_stage_descriptor_input_attachments: 0,
            max_per_stage_resources: 0,
            max_descriptor_set_samplers: 0,
            max_descriptor_set_uniform_buffers: 0,
            max_descriptor_set_uniform_buffers_dynamic: 0,
            max_descriptor_set_storage_buffers: 0,
            max_descriptor_set_storage_buffers_dynamic: 0,
            max_descriptor_set_sampled_images: 0,
            max_descriptor_set_storage_images: 0,
            max_descriptor_set_input_attachments: 0,
            max_vertex_input_attributes: 0,
            max_vertex_input_bindings: 0,
            max_vertex_input_attribute_offset: 0,
            max_vertex_input_binding_stride: 0,
            max_vertex_output_components: 0,
            max_tessellation_generation_level: 0,
            max_tessellation_patch_size: 0,
            max_tessellation_control_per_vertex_input_components: 0,
            max_tessellation_control_per_vertex_output_components: 0,
            max_tessellation_control_per_patch_output_components: 0,
            max_tessellation_control_total_output_components: 0,
            max_tessellation_evaluation_input_components: 0,
            max_tessellation_evaluation_output_components: 0,
            max_geometry_shader_invocations: 0,
            max_geometry_input_components: 0,
            max_geometry_output_components: 0,
            max_geometry_output_vertices: 0,
            max_geometry_total_output_components: 0,
            max_fragment_input_components: 0,
            max_fragment_output_attachments: 0,
            max_fragment_dual_src_attachments: 0,
            max_fragment_combined_output_resources: 0,
            max_compute_shared_memory_size: 0,
            max_compute_work_group_count: unsafe { mem::zeroed() },
            max_compute_work_group_invocations: 0,
            max_compute_work_group_size: unsafe { mem::zeroed() },
            sub_pixel_precision_bits: 0,
            sub_texel_precision_bits: 0,
            mipmap_precision_bits: 0,
            max_draw_indexed_index_value: 0,
            max_draw_indirect_count: 0,
            max_sampler_lod_bias: 0.0,
            max_sampler_anisotropy: 0.0,
            max_viewports: 0,
            max_viewport_dimensions: unsafe { mem::zeroed() },
            viewport_bounds_range: unsafe { mem::zeroed() },
            viewport_sub_pixel_bits: 0,
            min_memory_map_alignment: 0,
            min_texel_buffer_offset_alignment: Default::default(),
            min_uniform_buffer_offset_alignment: Default::default(),
            min_storage_buffer_offset_alignment: Default::default(),
            min_texel_offset: 0,
            max_texel_offset: 0,
            min_texel_gather_offset: 0,
            max_texel_gather_offset: 0,
            min_interpolation_offset: 0.0,
            max_interpolation_offset: 0.0,
            sub_pixel_interpolation_offset_bits: 0,
            max_framebuffer_width: 0,
            max_framebuffer_height: 0,
            max_framebuffer_layers: 0,
            framebuffer_color_sample_counts: Default::default(),
            framebuffer_depth_sample_counts: Default::default(),
            framebuffer_stencil_sample_counts: Default::default(),
            framebuffer_no_attachments_sample_counts: Default::default(),
            max_color_attachments: 0,
            sampled_image_color_sample_counts: Default::default(),
            sampled_image_integer_sample_counts: Default::default(),
            sampled_image_depth_sample_counts: Default::default(),
            sampled_image_stencil_sample_counts: Default::default(),
            storage_image_sample_counts: Default::default(),
            max_sample_mask_words: 0,
            timestamp_compute_and_graphics: FALSE,
            timestamp_period: 0.0,
            max_clip_distances: 0,
            max_cull_distances: 0,
            max_combined_clip_and_cull_distances: 0,
            discrete_queue_priorities: 0,
            point_size_range: unsafe { mem::zeroed() },
            line_width_range: unsafe { mem::zeroed() },
            point_size_granularity: 0.0,
            line_width_granularity: 0.0,
            strict_lines: FALSE,
            standard_sample_locations: FALSE,
            optimal_buffer_copy_offset_alignment: Default::default(),
            optimal_buffer_copy_row_pitch_alignment: Default::default(),
            non_coherent_atom_size: Default::default(),
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct SemaphoreCreateInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    /// Semaphore creation flags
    pub flags: SemaphoreCreateFlags,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for SemaphoreCreateInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::SemaphoreCreateInfo,
            next: ptr::null_mut(),
            flags: Default::default(),
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsSemaphoreCreateInfo {}
impl<'a> SemaphoreCreateInfo<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsSemaphoreCreateInfo>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct QueryPoolCreateInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub flags: QueryPoolCreateFlags,
    pub query_type: QueryType,
    pub query_count: u32,
    /// Optional
    pub pipeline_statistics: QueryPipelineStatisticFlags,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for QueryPoolCreateInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::QueryPoolCreateInfo,
            next: ptr::null_mut(),
            flags: Default::default(),
            query_type: Default::default(),
            query_count: 0,
            pipeline_statistics: Default::default(),
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsQueryPoolCreateInfo {}
impl<'a> QueryPoolCreateInfo<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsQueryPoolCreateInfo>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct FramebufferCreateInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub flags: FramebufferCreateFlags,
    pub render_pass: RenderPass,
    pub attachment_count: u32,
    /// Len: `attachment_count`
    pub attachments: *const ImageView,
    pub width: u32,
    pub height: u32,
    pub layers: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for FramebufferCreateInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::FramebufferCreateInfo,
            next: ptr::null_mut(),
            flags: Default::default(),
            render_pass: Default::default(),
            attachment_count: 0,
            attachments: ptr::null_mut(),
            width: 0,
            height: 0,
            layers: 0,
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsFramebufferCreateInfo {}
impl<'a> FramebufferCreateInfo<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsFramebufferCreateInfo>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DrawIndirectCommand {
    pub vertex_count: u32,
    pub instance_count: u32,
    pub first_vertex: u32,
    pub first_instance: u32,
}
impl Default for DrawIndirectCommand {
    fn default() -> Self {
        Self {
            vertex_count: 0,
            instance_count: 0,
            first_vertex: 0,
            first_instance: 0,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DrawIndexedIndirectCommand {
    pub index_count: u32,
    pub instance_count: u32,
    pub first_index: u32,
    pub vertex_offset: i32,
    pub first_instance: u32,
}
impl Default for DrawIndexedIndirectCommand {
    fn default() -> Self {
        Self {
            index_count: 0,
            instance_count: 0,
            first_index: 0,
            vertex_offset: 0,
            first_instance: 0,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DispatchIndirectCommand {
    pub x: u32,
    pub y: u32,
    pub z: u32,
}
impl Default for DispatchIndirectCommand {
    fn default() -> Self {
        Self { x: 0, y: 0, z: 0 }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct MultiDrawInfoEXT {
    pub first_vertex: u32,
    pub vertex_count: u32,
}
impl Default for MultiDrawInfoEXT {
    fn default() -> Self {
        Self {
            first_vertex: 0,
            vertex_count: 0,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct MultiDrawIndexedInfoEXT {
    pub first_index: u32,
    pub index_count: u32,
    pub vertex_offset: i32,
}
impl Default for MultiDrawIndexedInfoEXT {
    fn default() -> Self {
        Self {
            first_index: 0,
            index_count: 0,
            vertex_offset: 0,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct SubmitInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub wait_semaphore_count: u32,
    /// Len: `wait_semaphore_count`
    pub wait_semaphores: *const Semaphore,
    /// Nullable
    /// Len: `wait_semaphore_count`
    pub wait_dst_stage_mask: *const PipelineStageFlags,
    pub command_buffer_count: u32,
    /// Len: `command_buffer_count`
    pub command_buffers: *const vkCommandBuffer,
    pub signal_semaphore_count: u32,
    /// Len: `signal_semaphore_count`
    pub signal_semaphores: *const Semaphore,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for SubmitInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::SubmitInfo,
            next: ptr::null_mut(),
            wait_semaphore_count: 0,
            wait_semaphores: ptr::null_mut(),
            wait_dst_stage_mask: ptr::null_mut(),
            command_buffer_count: 0,
            command_buffers: ptr::null_mut(),
            signal_semaphore_count: 0,
            signal_semaphores: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsSubmitInfo {}
impl<'a> SubmitInfo<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsSubmitInfo>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DisplayPropertiesKHR<'a> {
    /// Handle of the display object
    pub display: DisplayKHR,
    /// Name of the display
    /// Len: null-terminated
    pub display_name: *const c_char,
    /// In millimeters?
    pub physical_dimensions: Extent2D,
    /// Max resolution for CRT?
    pub physical_resolution: Extent2D,
    /// one or more bits from VkSurfaceTransformFlagsKHR
    pub supported_transforms: SurfaceTransformFlagsKHR,
    /// VK_TRUE if the overlay plane's z-order can be changed on this display.
    pub plane_reorder_possible: Bool32,
    /// VK_TRUE if this is a "smart" display that supports self-refresh/internal buffering.
    pub persistent_content: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for DisplayPropertiesKHR<'_> {
    fn default() -> Self {
        Self {
            display: Default::default(),
            display_name: ptr::null_mut(),
            physical_dimensions: Default::default(),
            physical_resolution: Default::default(),
            supported_transforms: Default::default(),
            plane_reorder_possible: FALSE,
            persistent_content: FALSE,
            _marker: PhantomData,
        }
    }
}

/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DisplayPlanePropertiesKHR {
    /// Display the plane is currently associated with.  Will be VK_NULL_HANDLE if the plane is not in use.
    pub current_display: DisplayKHR,
    /// Current z-order of the plane.
    pub current_stack_index: u32,
}
impl Default for DisplayPlanePropertiesKHR {
    fn default() -> Self {
        Self {
            current_display: Default::default(),
            current_stack_index: 0,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DisplayModeParametersKHR {
    /// Visible scanout region.
    pub visible_region: Extent2D,
    /// Number of times per second the display is updated.
    pub refresh_rate: u32,
}
impl Default for DisplayModeParametersKHR {
    fn default() -> Self {
        Self {
            visible_region: Default::default(),
            refresh_rate: 0,
        }
    }
}

/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DisplayModePropertiesKHR {
    /// Handle of this display mode.
    pub display_mode: DisplayModeKHR,
    /// The parameters this mode uses.
    pub parameters: DisplayModeParametersKHR,
}
impl Default for DisplayModePropertiesKHR {
    fn default() -> Self {
        Self {
            display_mode: Default::default(),
            parameters: Default::default(),
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DisplayModeCreateInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub flags: DisplayModeCreateFlagsKHR,
    /// The parameters this mode uses.
    pub parameters: DisplayModeParametersKHR,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for DisplayModeCreateInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::DisplayModeCreateInfoKHR,
            next: ptr::null_mut(),
            flags: Default::default(),
            parameters: Default::default(),
            _marker: PhantomData,
        }
    }
}

/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DisplayPlaneCapabilitiesKHR {
    /// Types of alpha blending supported, if any.
    pub supported_alpha: DisplayPlaneAlphaFlagsKHR,
    /// Does the plane have any position and extent restrictions?
    pub min_src_position: Offset2D,
    pub max_src_position: Offset2D,
    pub min_src_extent: Extent2D,
    pub max_src_extent: Extent2D,
    pub min_dst_position: Offset2D,
    pub max_dst_position: Offset2D,
    pub min_dst_extent: Extent2D,
    pub max_dst_extent: Extent2D,
}
impl Default for DisplayPlaneCapabilitiesKHR {
    fn default() -> Self {
        Self {
            supported_alpha: Default::default(),
            min_src_position: Default::default(),
            max_src_position: Default::default(),
            min_src_extent: Default::default(),
            max_src_extent: Default::default(),
            min_dst_position: Default::default(),
            max_dst_position: Default::default(),
            min_dst_extent: Default::default(),
            max_dst_extent: Default::default(),
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DisplaySurfaceCreateInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub flags: DisplaySurfaceCreateFlagsKHR,
    /// The mode to use when displaying this surface
    pub display_mode: DisplayModeKHR,
    /// The plane on which this surface appears.  Must be between 0 and the value returned by vkGetPhysicalDeviceDisplayPlanePropertiesKHR() in pPropertyCount.
    pub plane_index: u32,
    /// The z-order of the plane.
    pub plane_stack_index: u32,
    /// Transform to apply to the images as part of the scanout operation
    pub transform: SurfaceTransformFlagsKHR,
    /// Global alpha value.  Must be between 0 and 1, inclusive.  Ignored if alphaMode is not VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR
    pub global_alpha: f32,
    /// The type of alpha blending to use. Must be one of the bits from VkDisplayPlaneCapabilitiesKHR::supportedAlpha for this display plane
    pub alpha_mode: DisplayPlaneAlphaFlagsKHR,
    /// size of the images to use with this surface
    pub image_extent: Extent2D,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for DisplaySurfaceCreateInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::DisplaySurfaceCreateInfoKHR,
            next: ptr::null_mut(),
            flags: Default::default(),
            display_mode: Default::default(),
            plane_index: 0,
            plane_stack_index: 0,
            transform: Default::default(),
            global_alpha: 0.0,
            alpha_mode: Default::default(),
            image_extent: Default::default(),
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsDisplaySurfaceCreateInfoKHR {}
impl<'a> DisplaySurfaceCreateInfoKHR<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsDisplaySurfaceCreateInfoKHR>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

/// Extends: `DisplaySurfaceCreateInfoKHR`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DisplaySurfaceStereoCreateInfoNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    /// The 3D stereo type to use when presenting this surface.
    pub stereo_type: DisplaySurfaceStereoTypeNV,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for DisplaySurfaceStereoCreateInfoNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::DisplaySurfaceStereoCreateInfoNV,
            next: ptr::null_mut(),
            stereo_type: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsDisplaySurfaceCreateInfoKHR for DisplaySurfaceStereoCreateInfoNV<'_> {}

/// Extends: `PresentInfoKHR`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DisplayPresentInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    /// Rectangle within the presentable image to read pixel data from when presenting to the display.
    pub src_rect: Rect2D,
    /// Rectangle within the current display mode's visible region to display srcRectangle in.
    pub dst_rect: Rect2D,
    /// For smart displays, use buffered mode.  If the display properties member "persistentMode" is VK_FALSE, this member must always be VK_FALSE.
    pub persistent: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for DisplayPresentInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::DisplayPresentInfoKHR,
            next: ptr::null_mut(),
            src_rect: Default::default(),
            dst_rect: Default::default(),
            persistent: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPresentInfoKHR for DisplayPresentInfoKHR<'_> {}

/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct SurfaceCapabilitiesKHR {
    /// Supported minimum number of images for the surface
    pub min_image_count: u32,
    /// Supported maximum number of images for the surface, 0 for unlimited
    pub max_image_count: u32,
    /// Current image width and height for the surface, (0, 0) if undefined
    pub current_extent: Extent2D,
    /// Supported minimum image width and height for the surface
    pub min_image_extent: Extent2D,
    /// Supported maximum image width and height for the surface
    pub max_image_extent: Extent2D,
    /// Supported maximum number of image layers for the surface
    pub max_image_array_layers: u32,
    /// 1 or more bits representing the transforms supported
    pub supported_transforms: SurfaceTransformFlagsKHR,
    /// The surface's current transform relative to the device's natural orientation
    pub current_transform: SurfaceTransformFlagsKHR,
    /// 1 or more bits representing the alpha compositing modes supported
    pub supported_composite_alpha: CompositeAlphaFlagsKHR,
    /// Supported image usage flags for the surface
    pub supported_usage_flags: ImageUsageFlags,
}
impl Default for SurfaceCapabilitiesKHR {
    fn default() -> Self {
        Self {
            min_image_count: 0,
            max_image_count: 0,
            current_extent: Default::default(),
            min_image_extent: Default::default(),
            max_image_extent: Default::default(),
            max_image_array_layers: 0,
            supported_transforms: Default::default(),
            current_transform: Default::default(),
            supported_composite_alpha: Default::default(),
            supported_usage_flags: Default::default(),
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct AndroidSurfaceCreateInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub flags: AndroidSurfaceCreateFlagsKHR,
    pub window: *mut ANativeWindow,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for AndroidSurfaceCreateInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::AndroidSurfaceCreateInfoKHR,
            next: ptr::null_mut(),
            flags: Default::default(),
            window: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ViSurfaceCreateInfoNN<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub flags: ViSurfaceCreateFlagsNN,
    pub window: *mut c_void,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ViSurfaceCreateInfoNN<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ViSurfaceCreateInfoNN,
            next: ptr::null_mut(),
            flags: Default::default(),
            window: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct WaylandSurfaceCreateInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub flags: WaylandSurfaceCreateFlagsKHR,
    pub display: *mut wl_display,
    pub surface: *mut wl_surface,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for WaylandSurfaceCreateInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::WaylandSurfaceCreateInfoKHR,
            next: ptr::null_mut(),
            flags: Default::default(),
            display: ptr::null_mut(),
            surface: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct Win32SurfaceCreateInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub flags: Win32SurfaceCreateFlagsKHR,
    pub hinstance: HINSTANCE,
    pub hwnd: HWND,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for Win32SurfaceCreateInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::Win32SurfaceCreateInfoKHR,
            next: ptr::null_mut(),
            flags: Default::default(),
            hinstance: Default::default(),
            hwnd: Default::default(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct XlibSurfaceCreateInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub flags: XlibSurfaceCreateFlagsKHR,
    pub dpy: *mut Display,
    pub window: Window,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for XlibSurfaceCreateInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::XlibSurfaceCreateInfoKHR,
            next: ptr::null_mut(),
            flags: Default::default(),
            dpy: ptr::null_mut(),
            window: Default::default(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct XcbSurfaceCreateInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub flags: XcbSurfaceCreateFlagsKHR,
    pub connection: *mut xcb_connection_t,
    pub window: xcb_window_t,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for XcbSurfaceCreateInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::XcbSurfaceCreateInfoKHR,
            next: ptr::null_mut(),
            flags: Default::default(),
            connection: ptr::null_mut(),
            window: Default::default(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DirectFBSurfaceCreateInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub flags: DirectFBSurfaceCreateFlagsEXT,
    pub dfb: *mut IDirectFB,
    pub surface: *mut IDirectFBSurface,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for DirectFBSurfaceCreateInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::DirectFBSurfaceCreateInfoEXT,
            next: ptr::null_mut(),
            flags: Default::default(),
            dfb: ptr::null_mut(),
            surface: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ImagePipeSurfaceCreateInfoFUCHSIA<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub flags: ImagePipeSurfaceCreateFlagsFUCHSIA,
    pub image_pipe_handle: zx_handle_t,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ImagePipeSurfaceCreateInfoFUCHSIA<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ImagePipeSurfaceCreateInfoFUCHSIA,
            next: ptr::null_mut(),
            flags: Default::default(),
            image_pipe_handle: Default::default(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct StreamDescriptorSurfaceCreateInfoGGP<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub flags: StreamDescriptorSurfaceCreateFlagsGGP,
    pub stream_descriptor: GgpStreamDescriptor,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for StreamDescriptorSurfaceCreateInfoGGP<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::StreamDescriptorSurfaceCreateInfoGGP,
            next: ptr::null_mut(),
            flags: Default::default(),
            stream_descriptor: Default::default(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ScreenSurfaceCreateInfoQNX<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub flags: ScreenSurfaceCreateFlagsQNX,
    pub context: *mut _screen_context,
    pub window: *mut _screen_window,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ScreenSurfaceCreateInfoQNX<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ScreenSurfaceCreateInfoQNX,
            next: ptr::null_mut(),
            flags: Default::default(),
            context: ptr::null_mut(),
            window: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)]
pub struct SurfaceFormatKHR {
    /// Supported pair of rendering format
    pub format: Format,
    /// and color space for the surface
    pub color_space: ColorSpaceKHR,
}
impl Default for SurfaceFormatKHR {
    fn default() -> Self {
        Self {
            format: Default::default(),
            color_space: Default::default(),
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct SwapchainCreateInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub flags: SwapchainCreateFlagsKHR,
    /// The swapchain's target surface
    pub surface: SurfaceKHR,
    /// Minimum number of presentation images the application needs
    pub min_image_count: u32,
    /// Format of the presentation images
    pub image_format: Format,
    /// Colorspace of the presentation images
    pub image_color_space: ColorSpaceKHR,
    /// Dimensions of the presentation images
    pub image_extent: Extent2D,
    /// Determines the number of views for multiview/stereo presentation
    pub image_array_layers: u32,
    /// Bits indicating how the presentation images will be used
    pub image_usage: ImageUsageFlags,
    /// Sharing mode used for the presentation images
    pub image_sharing_mode: SharingMode,
    /// Number of queue families having access to the images in case of concurrent sharing mode
    pub queue_family_index_count: u32,
    /// Array of queue family indices having access to the images in case of concurrent sharing mode
    /// Len: `queue_family_index_count`
    pub queue_family_indices: *const u32,
    /// The transform, relative to the device's natural orientation, applied to the image content prior to presentation
    pub pre_transform: SurfaceTransformFlagsKHR,
    /// The alpha blending mode used when compositing this surface with other surfaces in the window system
    pub composite_alpha: CompositeAlphaFlagsKHR,
    /// Which presentation mode to use for presents on this swap chain
    pub present_mode: PresentModeKHR,
    /// Specifies whether presentable images may be affected by window clip regions
    pub clipped: Bool32,
    /// Existing swap chain to replace, if any
    pub old_swapchain: SwapchainKHR,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for SwapchainCreateInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::SwapchainCreateInfoKHR,
            next: ptr::null_mut(),
            flags: Default::default(),
            surface: Default::default(),
            min_image_count: 0,
            image_format: Default::default(),
            image_color_space: Default::default(),
            image_extent: Default::default(),
            image_array_layers: 0,
            image_usage: Default::default(),
            image_sharing_mode: Default::default(),
            queue_family_index_count: 0,
            queue_family_indices: ptr::null_mut(),
            pre_transform: Default::default(),
            composite_alpha: Default::default(),
            present_mode: Default::default(),
            clipped: FALSE,
            old_swapchain: Default::default(),
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsSwapchainCreateInfoKHR {}
impl<'a> SwapchainCreateInfoKHR<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsSwapchainCreateInfoKHR>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PresentInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    /// Number of semaphores to wait for before presenting
    pub wait_semaphore_count: u32,
    /// Semaphores to wait for before presenting
    /// Len: `wait_semaphore_count`
    pub wait_semaphores: *const Semaphore,
    /// Number of swapchains to present in this call
    pub swapchain_count: u32,
    /// Swapchains to present an image from
    /// Len: `swapchain_count`
    pub swapchains: *const SwapchainKHR,
    /// Indices of which presentable images to present
    /// Len: `swapchain_count`
    pub image_indices: *const u32,
    /// Optional (i.e. if non-NULL) VkResult for each swapchain
    /// Nullable
    /// Len: `swapchain_count`
    pub results: *mut vkResult,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PresentInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PresentInfoKHR,
            next: ptr::null_mut(),
            wait_semaphore_count: 0,
            wait_semaphores: ptr::null_mut(),
            swapchain_count: 0,
            swapchains: ptr::null_mut(),
            image_indices: ptr::null_mut(),
            results: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsPresentInfoKHR {}
impl<'a> PresentInfoKHR<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsPresentInfoKHR>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

/// Extends: `InstanceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DebugReportCallbackCreateInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    /// Indicates which events call this callback
    pub flags: DebugReportFlagsEXT,
    /// Function pointer of a callback function
    pub pfn_callback: PFN_vkDebugReportCallbackEXT,
    /// Data provided to callback function
    /// Nullable
    pub user_data: *mut c_void,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for DebugReportCallbackCreateInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::DebugReportCallbackCreateInfoEXT,
            next: ptr::null_mut(),
            flags: Default::default(),
            pfn_callback: Default::default(),
            user_data: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsInstanceCreateInfo for DebugReportCallbackCreateInfoEXT<'_> {}

/// Extends: `InstanceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ValidationFlagsEXT<'a> {
    /// Must be VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    /// Number of validation checks to disable
    pub disabled_validation_check_count: u32,
    /// Validation checks to disable
    /// Len: `disabled_validation_check_count`
    pub disabled_validation_checks: *const ValidationCheckEXT,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ValidationFlagsEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ValidationFlagsEXT,
            next: ptr::null_mut(),
            disabled_validation_check_count: 0,
            disabled_validation_checks: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsInstanceCreateInfo for ValidationFlagsEXT<'_> {}

/// Extends: `InstanceCreateInfo`, `ShaderModuleCreateInfo`, `ShaderCreateInfoEXT`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ValidationFeaturesEXT<'a> {
    /// Must be VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    /// Number of validation features to enable
    pub enabled_validation_feature_count: u32,
    /// Validation features to enable
    /// Len: `enabled_validation_feature_count`
    pub enabled_validation_features: *const ValidationFeatureEnableEXT,
    /// Number of validation features to disable
    pub disabled_validation_feature_count: u32,
    /// Validation features to disable
    /// Len: `disabled_validation_feature_count`
    pub disabled_validation_features: *const ValidationFeatureDisableEXT,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ValidationFeaturesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ValidationFeaturesEXT,
            next: ptr::null_mut(),
            enabled_validation_feature_count: 0,
            enabled_validation_features: ptr::null_mut(),
            disabled_validation_feature_count: 0,
            disabled_validation_features: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsInstanceCreateInfo for ValidationFeaturesEXT<'_> {}
impl ExtendsShaderModuleCreateInfo for ValidationFeaturesEXT<'_> {}
impl ExtendsShaderCreateInfoEXT for ValidationFeaturesEXT<'_> {}

/// Extends: `InstanceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct LayerSettingsCreateInfoEXT<'a> {
    /// Must be VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    /// Number of settings to configure
    pub setting_count: u32,
    /// Validation features to enable
    /// Len: `setting_count`
    pub settings: *const LayerSettingEXT<'a>,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for LayerSettingsCreateInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::LayerSettingsCreateInfoEXT,
            next: ptr::null_mut(),
            setting_count: 0,
            settings: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsInstanceCreateInfo for LayerSettingsCreateInfoEXT<'_> {}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct LayerSettingEXT<'a> {
    /// Len: null-terminated
    pub layer_name: *const c_char,
    /// Len: null-terminated
    pub setting_name: *const c_char,
    /// The type of the object
    pub ty: LayerSettingTypeEXT,
    /// Number of values of the setting
    pub value_count: u32,
    /// Values to pass for a setting
    /// Len: `value_count`
    pub values: *const c_void,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for LayerSettingEXT<'_> {
    fn default() -> Self {
        Self {
            layer_name: ptr::null_mut(),
            setting_name: ptr::null_mut(),
            ty: Default::default(),
            value_count: 0,
            values: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

/// Extends: `ApplicationInfo`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ApplicationParametersEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub vendor_id: u32,
    pub device_id: u32,
    pub key: u32,
    pub value: u64,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ApplicationParametersEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ApplicationParametersEXT,
            next: ptr::null_mut(),
            vendor_id: 0,
            device_id: 0,
            key: 0,
            value: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsApplicationInfo for ApplicationParametersEXT<'_> {}
impl ExtendsDeviceCreateInfo for ApplicationParametersEXT<'_> {}

/// Extends: `PipelineRasterizationStateCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PipelineRasterizationStateRasterizationOrderAMD<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    /// Rasterization order to use for the pipeline
    pub rasterization_order: RasterizationOrderAMD,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PipelineRasterizationStateRasterizationOrderAMD<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PipelineRasterizationStateRasterizationOrderAMD,
            next: ptr::null_mut(),
            rasterization_order: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsPipelineRasterizationStateCreateInfo
    for PipelineRasterizationStateRasterizationOrderAMD<'_>
{
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DebugMarkerObjectNameInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    /// The type of the object
    pub object_type: DebugReportObjectTypeEXT,
    /// The handle of the object, cast to uint64_t
    pub object: u64,
    /// Name to apply to the object
    /// Len: null-terminated
    pub object_name: *const c_char,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for DebugMarkerObjectNameInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::DebugMarkerObjectNameInfoEXT,
            next: ptr::null_mut(),
            object_type: Default::default(),
            object: 0,
            object_name: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DebugMarkerObjectTagInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    /// The type of the object
    pub object_type: DebugReportObjectTypeEXT,
    /// The handle of the object, cast to uint64_t
    pub object: u64,
    /// The name of the tag to set on the object
    pub tag_name: u64,
    /// The length in bytes of the tag data
    pub tag_size: usize,
    /// Tag data to attach to the object
    /// Len: `tag_size`
    pub tag: *const c_void,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for DebugMarkerObjectTagInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::DebugMarkerObjectTagInfoEXT,
            next: ptr::null_mut(),
            object_type: Default::default(),
            object: 0,
            tag_name: 0,
            tag_size: 0,
            tag: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DebugMarkerMarkerInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    /// Name of the debug marker
    /// Len: null-terminated
    pub marker_name: *const c_char,
    /// Optional color for debug marker
    pub color: [f32; 4],
    pub _marker: PhantomData<&'a ()>,
}
impl Default for DebugMarkerMarkerInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::DebugMarkerMarkerInfoEXT,
            next: ptr::null_mut(),
            marker_name: ptr::null_mut(),
            color: unsafe { mem::zeroed() },
            _marker: PhantomData,
        }
    }
}

/// Extends: `ImageCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DedicatedAllocationImageCreateInfoNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    /// Whether this image uses a dedicated allocation
    pub dedicated_allocation: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for DedicatedAllocationImageCreateInfoNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::DedicatedAllocationImageCreateInfoNV,
            next: ptr::null_mut(),
            dedicated_allocation: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsImageCreateInfo for DedicatedAllocationImageCreateInfoNV<'_> {}

/// Extends: `BufferCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DedicatedAllocationBufferCreateInfoNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    /// Whether this buffer uses a dedicated allocation
    pub dedicated_allocation: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for DedicatedAllocationBufferCreateInfoNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::DedicatedAllocationBufferCreateInfoNV,
            next: ptr::null_mut(),
            dedicated_allocation: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsBufferCreateInfo for DedicatedAllocationBufferCreateInfoNV<'_> {}

/// Extends: `MemoryAllocateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DedicatedAllocationMemoryAllocateInfoNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    /// Image that this allocation will be bound to
    pub image: Image,
    /// Buffer that this allocation will be bound to
    pub buffer: Buffer,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for DedicatedAllocationMemoryAllocateInfoNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::DedicatedAllocationMemoryAllocateInfoNV,
            next: ptr::null_mut(),
            image: Default::default(),
            buffer: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsMemoryAllocateInfo for DedicatedAllocationMemoryAllocateInfoNV<'_> {}

/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ExternalImageFormatPropertiesNV {
    pub image_format_properties: ImageFormatProperties,
    pub external_memory_features: ExternalMemoryFeatureFlagsNV,
    pub export_from_imported_handle_types: ExternalMemoryHandleTypeFlagsNV,
    pub compatible_handle_types: ExternalMemoryHandleTypeFlagsNV,
}
impl Default for ExternalImageFormatPropertiesNV {
    fn default() -> Self {
        Self {
            image_format_properties: Default::default(),
            external_memory_features: Default::default(),
            export_from_imported_handle_types: Default::default(),
            compatible_handle_types: Default::default(),
        }
    }
}

/// Extends: `ImageCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ExternalMemoryImageCreateInfoNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub handle_types: ExternalMemoryHandleTypeFlagsNV,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ExternalMemoryImageCreateInfoNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ExternalMemoryImageCreateInfoNV,
            next: ptr::null_mut(),
            handle_types: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsImageCreateInfo for ExternalMemoryImageCreateInfoNV<'_> {}

/// Extends: `MemoryAllocateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ExportMemoryAllocateInfoNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub handle_types: ExternalMemoryHandleTypeFlagsNV,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ExportMemoryAllocateInfoNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ExportMemoryAllocateInfoNV,
            next: ptr::null_mut(),
            handle_types: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsMemoryAllocateInfo for ExportMemoryAllocateInfoNV<'_> {}

/// Extends: `MemoryAllocateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ImportMemoryWin32HandleInfoNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub handle_type: ExternalMemoryHandleTypeFlagsNV,
    pub handle: HANDLE,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ImportMemoryWin32HandleInfoNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ImportMemoryWin32HandleInfoNV,
            next: ptr::null_mut(),
            handle_type: Default::default(),
            handle: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsMemoryAllocateInfo for ImportMemoryWin32HandleInfoNV<'_> {}

/// Extends: `MemoryAllocateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ExportMemoryWin32HandleInfoNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    /// Nullable
    pub attributes: *const SECURITY_ATTRIBUTES,
    pub dw_access: DWORD,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ExportMemoryWin32HandleInfoNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ExportMemoryWin32HandleInfoNV,
            next: ptr::null_mut(),
            attributes: ptr::null_mut(),
            dw_access: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsMemoryAllocateInfo for ExportMemoryWin32HandleInfoNV<'_> {}

/// Extends: `MemoryAllocateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ExportMemorySciBufInfoNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub attributes: NvSciBufAttrList,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ExportMemorySciBufInfoNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ExportMemorySciBufInfoNV,
            next: ptr::null_mut(),
            attributes: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsMemoryAllocateInfo for ExportMemorySciBufInfoNV<'_> {}

/// Extends: `MemoryAllocateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ImportMemorySciBufInfoNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub handle_type: ExternalMemoryHandleTypeFlags,
    pub handle: NvSciBufObj,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ImportMemorySciBufInfoNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ImportMemorySciBufInfoNV,
            next: ptr::null_mut(),
            handle_type: Default::default(),
            handle: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsMemoryAllocateInfo for ImportMemorySciBufInfoNV<'_> {}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct MemoryGetSciBufInfoNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub memory: DeviceMemory,
    pub handle_type: ExternalMemoryHandleTypeFlags,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for MemoryGetSciBufInfoNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::MemoryGetSciBufInfoNV,
            next: ptr::null_mut(),
            memory: Default::default(),
            handle_type: Default::default(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct MemorySciBufPropertiesNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub memory_type_bits: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for MemorySciBufPropertiesNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::MemorySciBufPropertiesNV,
            next: ptr::null_mut(),
            memory_type_bits: 0,
            _marker: PhantomData,
        }
    }
}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceExternalMemorySciBufFeaturesNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub sci_buf_import: Bool32,
    pub sci_buf_export: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceExternalMemorySciBufFeaturesNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceExternalMemorySciBufFeaturesNV,
            next: ptr::null_mut(),
            sci_buf_import: FALSE,
            sci_buf_export: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceExternalMemorySciBufFeaturesNV<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceExternalMemorySciBufFeaturesNV<'_> {}

pub type PhysicalDeviceExternalSciBufFeaturesNV<'a> =
    PhysicalDeviceExternalMemorySciBufFeaturesNV<'a>;
/// Extends: `SubmitInfo`, `SubmitInfo2`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct Win32KeyedMutexAcquireReleaseInfoNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub acquire_count: u32,
    /// Len: `acquire_count`
    pub acquire_syncs: *const DeviceMemory,
    /// Len: `acquire_count`
    pub acquire_keys: *const u64,
    /// Len: `acquire_count`
    pub acquire_timeout_milliseconds: *const u32,
    pub release_count: u32,
    /// Len: `release_count`
    pub release_syncs: *const DeviceMemory,
    /// Len: `release_count`
    pub release_keys: *const u64,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for Win32KeyedMutexAcquireReleaseInfoNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::Win32KeyedMutexAcquireReleaseInfoNV,
            next: ptr::null_mut(),
            acquire_count: 0,
            acquire_syncs: ptr::null_mut(),
            acquire_keys: ptr::null_mut(),
            acquire_timeout_milliseconds: ptr::null_mut(),
            release_count: 0,
            release_syncs: ptr::null_mut(),
            release_keys: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsSubmitInfo for Win32KeyedMutexAcquireReleaseInfoNV<'_> {}
impl ExtendsSubmitInfo2 for Win32KeyedMutexAcquireReleaseInfoNV<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceDeviceGeneratedCommandsFeaturesNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub device_generated_commands: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceDeviceGeneratedCommandsFeaturesNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceDeviceGeneratedCommandsFeaturesNV,
            next: ptr::null_mut(),
            device_generated_commands: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDeviceGeneratedCommandsFeaturesNV<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceDeviceGeneratedCommandsFeaturesNV<'_> {}

/// Extends: `DescriptorSetAndBindingMappingEXT`, `PushDataInfoEXT`, `PushConstantsInfo`, `IndirectCommandsLayoutTokenEXT`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PushConstantBankInfoNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub bank: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PushConstantBankInfoNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PushConstantBankInfoNV,
            next: ptr::null_mut(),
            bank: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsDescriptorSetAndBindingMappingEXT for PushConstantBankInfoNV<'_> {}
impl ExtendsPushDataInfoEXT for PushConstantBankInfoNV<'_> {}
impl ExtendsPushConstantsInfo for PushConstantBankInfoNV<'_> {}
impl ExtendsIndirectCommandsLayoutTokenEXT for PushConstantBankInfoNV<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDevicePushConstantBankFeaturesNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub push_constant_bank: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDevicePushConstantBankFeaturesNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDevicePushConstantBankFeaturesNV,
            next: ptr::null_mut(),
            push_constant_bank: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePushConstantBankFeaturesNV<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDevicePushConstantBankFeaturesNV<'_> {}

/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDevicePushConstantBankPropertiesNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub max_graphics_push_constant_banks: u32,
    pub max_compute_push_constant_banks: u32,
    pub max_graphics_push_data_banks: u32,
    pub max_compute_push_data_banks: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDevicePushConstantBankPropertiesNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDevicePushConstantBankPropertiesNV,
            next: ptr::null_mut(),
            max_graphics_push_constant_banks: 0,
            max_compute_push_constant_banks: 0,
            max_graphics_push_data_banks: 0,
            max_compute_push_data_banks: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2 for PhysicalDevicePushConstantBankPropertiesNV<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub device_generated_compute: Bool32,
    pub device_generated_compute_pipelines: Bool32,
    pub device_generated_compute_capture_replay: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV,
            next: ptr::null_mut(),
            device_generated_compute: FALSE,
            device_generated_compute_pipelines: FALSE,
            device_generated_compute_capture_replay: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV<'_> {}

/// Extends: `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DevicePrivateDataCreateInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub private_data_slot_request_count: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for DevicePrivateDataCreateInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::DevicePrivateDataCreateInfo,
            next: ptr::null_mut(),
            private_data_slot_request_count: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsDeviceCreateInfo for DevicePrivateDataCreateInfo<'_> {}

pub type DevicePrivateDataCreateInfoEXT<'a> = DevicePrivateDataCreateInfo<'a>;
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PrivateDataSlotCreateInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub flags: PrivateDataSlotCreateFlags,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PrivateDataSlotCreateInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PrivateDataSlotCreateInfo,
            next: ptr::null_mut(),
            flags: Default::default(),
            _marker: PhantomData,
        }
    }
}

pub type PrivateDataSlotCreateInfoEXT<'a> = PrivateDataSlotCreateInfo<'a>;
/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDevicePrivateDataFeatures<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub private_data: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDevicePrivateDataFeatures<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDevicePrivateDataFeatures,
            next: ptr::null_mut(),
            private_data: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePrivateDataFeatures<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDevicePrivateDataFeatures<'_> {}

pub type PhysicalDevicePrivateDataFeaturesEXT<'a> = PhysicalDevicePrivateDataFeatures<'a>;
/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceDeviceGeneratedCommandsPropertiesNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub max_graphics_shader_group_count: u32,
    pub max_indirect_sequence_count: u32,
    pub max_indirect_commands_token_count: u32,
    pub max_indirect_commands_stream_count: u32,
    pub max_indirect_commands_token_offset: u32,
    pub max_indirect_commands_stream_stride: u32,
    pub min_sequences_count_buffer_offset_alignment: u32,
    pub min_sequences_index_buffer_offset_alignment: u32,
    pub min_indirect_commands_buffer_offset_alignment: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceDeviceGeneratedCommandsPropertiesNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceDeviceGeneratedCommandsPropertiesNV,
            next: ptr::null_mut(),
            max_graphics_shader_group_count: 0,
            max_indirect_sequence_count: 0,
            max_indirect_commands_token_count: 0,
            max_indirect_commands_stream_count: 0,
            max_indirect_commands_token_offset: 0,
            max_indirect_commands_stream_stride: 0,
            min_sequences_count_buffer_offset_alignment: 0,
            min_sequences_index_buffer_offset_alignment: 0,
            min_indirect_commands_buffer_offset_alignment: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDeviceGeneratedCommandsPropertiesNV<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceClusterAccelerationStructureFeaturesNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub cluster_acceleration_structure: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceClusterAccelerationStructureFeaturesNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceClusterAccelerationStructureFeaturesNV,
            next: ptr::null_mut(),
            cluster_acceleration_structure: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceClusterAccelerationStructureFeaturesNV<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceClusterAccelerationStructureFeaturesNV<'_> {}

/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceClusterAccelerationStructurePropertiesNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub max_vertices_per_cluster: u32,
    pub max_triangles_per_cluster: u32,
    pub cluster_scratch_byte_alignment: u32,
    pub cluster_byte_alignment: u32,
    pub cluster_template_byte_alignment: u32,
    pub cluster_bottom_level_byte_alignment: u32,
    pub cluster_template_bounds_byte_alignment: u32,
    pub max_cluster_geometry_index: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceClusterAccelerationStructurePropertiesNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceClusterAccelerationStructurePropertiesNV,
            next: ptr::null_mut(),
            max_vertices_per_cluster: 0,
            max_triangles_per_cluster: 0,
            cluster_scratch_byte_alignment: 0,
            cluster_byte_alignment: 0,
            cluster_template_byte_alignment: 0,
            cluster_bottom_level_byte_alignment: 0,
            cluster_template_bounds_byte_alignment: 0,
            max_cluster_geometry_index: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2
    for PhysicalDeviceClusterAccelerationStructurePropertiesNV<'_>
{
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct StridedDeviceAddressNV {
    pub start_address: DeviceAddress,
    /// Specified in bytes
    pub stride_in_bytes: DeviceSize,
}
impl Default for StridedDeviceAddressNV {
    fn default() -> Self {
        Self {
            start_address: Default::default(),
            stride_in_bytes: Default::default(),
        }
    }
}

/// Extends: `RayTracingPipelineCreateInfoKHR`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct RayTracingPipelineClusterAccelerationStructureCreateInfoNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub allow_cluster_acceleration_structure: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for RayTracingPipelineClusterAccelerationStructureCreateInfoNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::RayTracingPipelineClusterAccelerationStructureCreateInfoNV,
            next: ptr::null_mut(),
            allow_cluster_acceleration_structure: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsRayTracingPipelineCreateInfoKHR
    for RayTracingPipelineClusterAccelerationStructureCreateInfoNV<'_>
{
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV {
    pub geometry_index: u32,
    pub reserved: u32,
    pub geometry_flags: u32,
}
impl Default for ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV {
    fn default() -> Self {
        Self {
            geometry_index: 0,
            reserved: 0,
            geometry_flags: 0,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ClusterAccelerationStructureMoveObjectsInfoNV {
    pub src_acceleration_structure: DeviceAddress,
}
impl Default for ClusterAccelerationStructureMoveObjectsInfoNV {
    fn default() -> Self {
        Self {
            src_acceleration_structure: Default::default(),
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ClusterAccelerationStructureBuildClustersBottomLevelInfoNV {
    pub cluster_references_count: u32,
    pub cluster_references_stride: u32,
    pub cluster_references: DeviceAddress,
}
impl Default for ClusterAccelerationStructureBuildClustersBottomLevelInfoNV {
    fn default() -> Self {
        Self {
            cluster_references_count: 0,
            cluster_references_stride: 0,
            cluster_references: Default::default(),
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ClusterAccelerationStructureGetTemplateIndicesInfoNV {
    pub cluster_template_address: DeviceAddress,
}
impl Default for ClusterAccelerationStructureGetTemplateIndicesInfoNV {
    fn default() -> Self {
        Self {
            cluster_template_address: Default::default(),
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ClusterAccelerationStructureBuildTriangleClusterInfoNV {
    pub cluster_id: u32,
    pub cluster_flags: ClusterAccelerationStructureClusterFlagsNV,
    pub triangle_count: u32,
    pub vertex_count: u32,
    pub position_truncate_bit_count: u32,
    pub index_type: u32,
    pub opacity_micromap_index_type: u32,
    pub base_geometry_index_and_geometry_flags:
        ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV,
    pub index_buffer_stride: u16,
    pub vertex_buffer_stride: u16,
    pub geometry_index_and_flags_buffer_stride: u16,
    pub opacity_micromap_index_buffer_stride: u16,
    pub index_buffer: DeviceAddress,
    pub vertex_buffer: DeviceAddress,
    pub geometry_index_and_flags_buffer: DeviceAddress,
    pub opacity_micromap_array: DeviceAddress,
    pub opacity_micromap_index_buffer: DeviceAddress,
}
impl Default for ClusterAccelerationStructureBuildTriangleClusterInfoNV {
    fn default() -> Self {
        Self {
            cluster_id: 0,
            cluster_flags: Default::default(),
            triangle_count: 0,
            vertex_count: 0,
            position_truncate_bit_count: 0,
            index_type: 0,
            opacity_micromap_index_type: 0,
            base_geometry_index_and_geometry_flags: Default::default(),
            index_buffer_stride: 0,
            vertex_buffer_stride: 0,
            geometry_index_and_flags_buffer_stride: 0,
            opacity_micromap_index_buffer_stride: 0,
            index_buffer: Default::default(),
            vertex_buffer: Default::default(),
            geometry_index_and_flags_buffer: Default::default(),
            opacity_micromap_array: Default::default(),
            opacity_micromap_index_buffer: Default::default(),
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV {
    pub cluster_id: u32,
    pub cluster_flags: ClusterAccelerationStructureClusterFlagsNV,
    pub triangle_count: u32,
    pub vertex_count: u32,
    pub position_truncate_bit_count: u32,
    pub index_type: u32,
    pub opacity_micromap_index_type: u32,
    pub base_geometry_index_and_geometry_flags:
        ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV,
    pub index_buffer_stride: u16,
    pub vertex_buffer_stride: u16,
    pub geometry_index_and_flags_buffer_stride: u16,
    pub opacity_micromap_index_buffer_stride: u16,
    pub index_buffer: DeviceAddress,
    pub vertex_buffer: DeviceAddress,
    pub geometry_index_and_flags_buffer: DeviceAddress,
    pub opacity_micromap_array: DeviceAddress,
    pub opacity_micromap_index_buffer: DeviceAddress,
    pub instantiation_bounding_box_limit: DeviceAddress,
}
impl Default for ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV {
    fn default() -> Self {
        Self {
            cluster_id: 0,
            cluster_flags: Default::default(),
            triangle_count: 0,
            vertex_count: 0,
            position_truncate_bit_count: 0,
            index_type: 0,
            opacity_micromap_index_type: 0,
            base_geometry_index_and_geometry_flags: Default::default(),
            index_buffer_stride: 0,
            vertex_buffer_stride: 0,
            geometry_index_and_flags_buffer_stride: 0,
            opacity_micromap_index_buffer_stride: 0,
            index_buffer: Default::default(),
            vertex_buffer: Default::default(),
            geometry_index_and_flags_buffer: Default::default(),
            opacity_micromap_array: Default::default(),
            opacity_micromap_index_buffer: Default::default(),
            instantiation_bounding_box_limit: Default::default(),
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ClusterAccelerationStructureInstantiateClusterInfoNV {
    pub cluster_id_offset: u32,
    pub geometry_index_offset: u32,
    pub reserved: u32,
    pub cluster_template_address: DeviceAddress,
    pub vertex_buffer: StridedDeviceAddressNV,
}
impl Default for ClusterAccelerationStructureInstantiateClusterInfoNV {
    fn default() -> Self {
        Self {
            cluster_id_offset: 0,
            geometry_index_offset: 0,
            reserved: 0,
            cluster_template_address: Default::default(),
            vertex_buffer: Default::default(),
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ClusterAccelerationStructureClustersBottomLevelInputNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub max_total_cluster_count: u32,
    pub max_cluster_count_per_acceleration_structure: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ClusterAccelerationStructureClustersBottomLevelInputNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ClusterAccelerationStructureClustersBottomLevelInputNV,
            next: ptr::null_mut(),
            max_total_cluster_count: 0,
            max_cluster_count_per_acceleration_structure: 0,
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ClusterAccelerationStructureTriangleClusterInputNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub vertex_format: Format,
    pub max_geometry_index_value: u32,
    pub max_cluster_unique_geometry_count: u32,
    pub max_cluster_triangle_count: u32,
    pub max_cluster_vertex_count: u32,
    pub max_total_triangle_count: u32,
    pub max_total_vertex_count: u32,
    pub min_position_truncate_bit_count: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ClusterAccelerationStructureTriangleClusterInputNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ClusterAccelerationStructureTriangleClusterInputNV,
            next: ptr::null_mut(),
            vertex_format: Default::default(),
            max_geometry_index_value: 0,
            max_cluster_unique_geometry_count: 0,
            max_cluster_triangle_count: 0,
            max_cluster_vertex_count: 0,
            max_total_triangle_count: 0,
            max_total_vertex_count: 0,
            min_position_truncate_bit_count: 0,
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ClusterAccelerationStructureMoveObjectsInputNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub ty: ClusterAccelerationStructureTypeNV,
    pub no_move_overlap: Bool32,
    pub max_moved_bytes: DeviceSize,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ClusterAccelerationStructureMoveObjectsInputNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ClusterAccelerationStructureMoveObjectsInputNV,
            next: ptr::null_mut(),
            ty: Default::default(),
            no_move_overlap: FALSE,
            max_moved_bytes: Default::default(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub union ClusterAccelerationStructureOpInputNV<'a> {
    pub clusters_bottom_level: *mut ClusterAccelerationStructureClustersBottomLevelInputNV<'a>,
    pub triangle_clusters: *mut ClusterAccelerationStructureTriangleClusterInputNV<'a>,
    pub move_objects: *mut ClusterAccelerationStructureMoveObjectsInputNV<'a>,
}
impl Default for ClusterAccelerationStructureOpInputNV<'_> {
    fn default() -> Self {
        unsafe { mem::zeroed() }
    }
}

impl fmt::Debug for ClusterAccelerationStructureOpInputNV<'_> {
    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
        fmt.debug_struct("ClusterAccelerationStructureOpInputNV")
            .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ClusterAccelerationStructureInputInfoNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub max_acceleration_structure_count: u32,
    pub flags: BuildAccelerationStructureFlagsKHR,
    pub op_type: ClusterAccelerationStructureOpTypeNV,
    pub op_mode: ClusterAccelerationStructureOpModeNV,
    pub op_input: ClusterAccelerationStructureOpInputNV<'a>,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ClusterAccelerationStructureInputInfoNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ClusterAccelerationStructureInputInfoNV,
            next: ptr::null_mut(),
            max_acceleration_structure_count: 0,
            flags: Default::default(),
            op_type: Default::default(),
            op_mode: Default::default(),
            op_input: Default::default(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ClusterAccelerationStructureCommandsInfoNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub input: ClusterAccelerationStructureInputInfoNV<'a>,
    pub dst_implicit_data: DeviceAddress,
    pub scratch_data: DeviceAddress,
    pub dst_addresses_array: StridedDeviceAddressRegionKHR,
    pub dst_sizes_array: StridedDeviceAddressRegionKHR,
    pub src_infos_array: StridedDeviceAddressRegionKHR,
    pub src_infos_count: DeviceAddress,
    pub address_resolution_flags: ClusterAccelerationStructureAddressResolutionFlagsNV,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ClusterAccelerationStructureCommandsInfoNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ClusterAccelerationStructureCommandsInfoNV,
            next: ptr::null_mut(),
            input: Default::default(),
            dst_implicit_data: Default::default(),
            scratch_data: Default::default(),
            dst_addresses_array: Default::default(),
            dst_sizes_array: Default::default(),
            src_infos_array: Default::default(),
            src_infos_count: Default::default(),
            address_resolution_flags: Default::default(),
            _marker: PhantomData,
        }
    }
}

/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceMultiDrawPropertiesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub max_multi_draw_count: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceMultiDrawPropertiesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceMultiDrawPropertiesEXT,
            next: ptr::null_mut(),
            max_multi_draw_count: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMultiDrawPropertiesEXT<'_> {}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct GraphicsShaderGroupCreateInfoNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub stage_count: u32,
    /// Len: `stage_count`
    pub stages: *const PipelineShaderStageCreateInfo<'a>,
    /// Nullable
    pub vertex_input_state: *const PipelineVertexInputStateCreateInfo<'a>,
    /// Nullable
    pub tessellation_state: *const PipelineTessellationStateCreateInfo<'a>,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for GraphicsShaderGroupCreateInfoNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::GraphicsShaderGroupCreateInfoNV,
            next: ptr::null_mut(),
            stage_count: 0,
            stages: ptr::null_mut(),
            vertex_input_state: ptr::null_mut(),
            tessellation_state: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

/// Extends: `GraphicsPipelineCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct GraphicsPipelineShaderGroupsCreateInfoNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub group_count: u32,
    /// Len: `group_count`
    pub groups: *const GraphicsShaderGroupCreateInfoNV<'a>,
    pub pipeline_count: u32,
    /// Len: `pipeline_count`
    pub pipelines: *const Pipeline,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for GraphicsPipelineShaderGroupsCreateInfoNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::GraphicsPipelineShaderGroupsCreateInfoNV,
            next: ptr::null_mut(),
            group_count: 0,
            groups: ptr::null_mut(),
            pipeline_count: 0,
            pipelines: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsGraphicsPipelineCreateInfo for GraphicsPipelineShaderGroupsCreateInfoNV<'_> {}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct BindShaderGroupIndirectCommandNV {
    pub group_index: u32,
}
impl Default for BindShaderGroupIndirectCommandNV {
    fn default() -> Self {
        Self { group_index: 0 }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct BindIndexBufferIndirectCommandNV {
    pub buffer_address: DeviceAddress,
    pub size: u32,
    pub index_type: IndexType,
}
impl Default for BindIndexBufferIndirectCommandNV {
    fn default() -> Self {
        Self {
            buffer_address: Default::default(),
            size: 0,
            index_type: Default::default(),
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct BindVertexBufferIndirectCommandNV {
    pub buffer_address: DeviceAddress,
    pub size: u32,
    pub stride: u32,
}
impl Default for BindVertexBufferIndirectCommandNV {
    fn default() -> Self {
        Self {
            buffer_address: Default::default(),
            size: 0,
            stride: 0,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct SetStateFlagsIndirectCommandNV {
    pub data: u32,
}
impl Default for SetStateFlagsIndirectCommandNV {
    fn default() -> Self {
        Self { data: 0 }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct IndirectCommandsStreamNV {
    pub buffer: Buffer,
    pub offset: DeviceSize,
}
impl Default for IndirectCommandsStreamNV {
    fn default() -> Self {
        Self {
            buffer: Default::default(),
            offset: Default::default(),
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct IndirectCommandsLayoutTokenNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub token_type: IndirectCommandsTokenTypeNV,
    pub stream: u32,
    pub offset: u32,
    pub vertex_binding_unit: u32,
    pub vertex_dynamic_stride: Bool32,
    pub pushconstant_pipeline_layout: PipelineLayout,
    pub pushconstant_shader_stage_flags: ShaderStageFlags,
    pub pushconstant_offset: u32,
    pub pushconstant_size: u32,
    pub indirect_state_flags: IndirectStateFlagsNV,
    pub index_type_count: u32,
    /// Len: `index_type_count`
    pub index_types: *const IndexType,
    /// Len: `index_type_count`
    pub index_type_values: *const u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for IndirectCommandsLayoutTokenNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::IndirectCommandsLayoutTokenNV,
            next: ptr::null_mut(),
            token_type: Default::default(),
            stream: 0,
            offset: 0,
            vertex_binding_unit: 0,
            vertex_dynamic_stride: FALSE,
            pushconstant_pipeline_layout: Default::default(),
            pushconstant_shader_stage_flags: Default::default(),
            pushconstant_offset: 0,
            pushconstant_size: 0,
            indirect_state_flags: Default::default(),
            index_type_count: 0,
            index_types: ptr::null_mut(),
            index_type_values: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsIndirectCommandsLayoutTokenNV {}
impl<'a> IndirectCommandsLayoutTokenNV<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsIndirectCommandsLayoutTokenNV>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct IndirectCommandsLayoutCreateInfoNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub flags: IndirectCommandsLayoutUsageFlagsNV,
    pub pipeline_bind_point: PipelineBindPoint,
    pub token_count: u32,
    /// Len: `token_count`
    pub tokens: *const IndirectCommandsLayoutTokenNV<'a>,
    pub stream_count: u32,
    /// Len: `stream_count`
    pub stream_strides: *const u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for IndirectCommandsLayoutCreateInfoNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::IndirectCommandsLayoutCreateInfoNV,
            next: ptr::null_mut(),
            flags: Default::default(),
            pipeline_bind_point: Default::default(),
            token_count: 0,
            tokens: ptr::null_mut(),
            stream_count: 0,
            stream_strides: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct GeneratedCommandsInfoNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub pipeline_bind_point: PipelineBindPoint,
    pub pipeline: Pipeline,
    pub indirect_commands_layout: IndirectCommandsLayoutNV,
    pub stream_count: u32,
    /// Len: `stream_count`
    pub streams: *const IndirectCommandsStreamNV,
    pub sequences_count: u32,
    pub preprocess_buffer: Buffer,
    pub preprocess_offset: DeviceSize,
    pub preprocess_size: DeviceSize,
    pub sequences_count_buffer: Buffer,
    pub sequences_count_offset: DeviceSize,
    pub sequences_index_buffer: Buffer,
    pub sequences_index_offset: DeviceSize,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for GeneratedCommandsInfoNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::GeneratedCommandsInfoNV,
            next: ptr::null_mut(),
            pipeline_bind_point: Default::default(),
            pipeline: Default::default(),
            indirect_commands_layout: Default::default(),
            stream_count: 0,
            streams: ptr::null_mut(),
            sequences_count: 0,
            preprocess_buffer: Default::default(),
            preprocess_offset: Default::default(),
            preprocess_size: Default::default(),
            sequences_count_buffer: Default::default(),
            sequences_count_offset: Default::default(),
            sequences_index_buffer: Default::default(),
            sequences_index_offset: Default::default(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct GeneratedCommandsMemoryRequirementsInfoNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub pipeline_bind_point: PipelineBindPoint,
    pub pipeline: Pipeline,
    pub indirect_commands_layout: IndirectCommandsLayoutNV,
    pub max_sequences_count: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for GeneratedCommandsMemoryRequirementsInfoNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::GeneratedCommandsMemoryRequirementsInfoNV,
            next: ptr::null_mut(),
            pipeline_bind_point: Default::default(),
            pipeline: Default::default(),
            indirect_commands_layout: Default::default(),
            max_sequences_count: 0,
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PipelineIndirectDeviceAddressInfoNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub pipeline_bind_point: PipelineBindPoint,
    pub pipeline: Pipeline,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PipelineIndirectDeviceAddressInfoNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PipelineIndirectDeviceAddressInfoNV,
            next: ptr::null_mut(),
            pipeline_bind_point: Default::default(),
            pipeline: Default::default(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct BindPipelineIndirectCommandNV {
    pub pipeline_address: DeviceAddress,
}
impl Default for BindPipelineIndirectCommandNV {
    fn default() -> Self {
        Self {
            pipeline_address: Default::default(),
        }
    }
}

/// Extends: `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceFeatures2<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub features: PhysicalDeviceFeatures,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceFeatures2<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceFeatures2,
            next: ptr::null_mut(),
            features: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsDeviceCreateInfo for PhysicalDeviceFeatures2<'_> {}
pub trait ExtendsPhysicalDeviceFeatures2 {}
impl<'a> PhysicalDeviceFeatures2<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsPhysicalDeviceFeatures2>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

pub type PhysicalDeviceFeatures2KHR<'a> = PhysicalDeviceFeatures2<'a>;
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceProperties2<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub properties: PhysicalDeviceProperties,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceProperties2<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceProperties2,
            next: ptr::null_mut(),
            properties: Default::default(),
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsPhysicalDeviceProperties2 {}
impl<'a> PhysicalDeviceProperties2<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsPhysicalDeviceProperties2>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

pub type PhysicalDeviceProperties2KHR<'a> = PhysicalDeviceProperties2<'a>;
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct FormatProperties2<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub format_properties: FormatProperties,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for FormatProperties2<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::FormatProperties2,
            next: ptr::null_mut(),
            format_properties: Default::default(),
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsFormatProperties2 {}
impl<'a> FormatProperties2<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsFormatProperties2>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

pub type FormatProperties2KHR<'a> = FormatProperties2<'a>;
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ImageFormatProperties2<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub image_format_properties: ImageFormatProperties,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ImageFormatProperties2<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ImageFormatProperties2,
            next: ptr::null_mut(),
            image_format_properties: Default::default(),
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsImageFormatProperties2 {}
impl<'a> ImageFormatProperties2<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsImageFormatProperties2>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

pub type ImageFormatProperties2KHR<'a> = ImageFormatProperties2<'a>;
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceImageFormatInfo2<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub format: Format,
    pub ty: ImageType,
    pub tiling: ImageTiling,
    pub usage: ImageUsageFlags,
    pub flags: ImageCreateFlags,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceImageFormatInfo2<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceImageFormatInfo2,
            next: ptr::null_mut(),
            format: Default::default(),
            ty: Default::default(),
            tiling: Default::default(),
            usage: Default::default(),
            flags: Default::default(),
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsPhysicalDeviceImageFormatInfo2 {}
impl<'a> PhysicalDeviceImageFormatInfo2<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsPhysicalDeviceImageFormatInfo2>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

pub type PhysicalDeviceImageFormatInfo2KHR<'a> = PhysicalDeviceImageFormatInfo2<'a>;
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct QueueFamilyProperties2<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub queue_family_properties: QueueFamilyProperties,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for QueueFamilyProperties2<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::QueueFamilyProperties2,
            next: ptr::null_mut(),
            queue_family_properties: Default::default(),
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsQueueFamilyProperties2 {}
impl<'a> QueueFamilyProperties2<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsQueueFamilyProperties2>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

pub type QueueFamilyProperties2KHR<'a> = QueueFamilyProperties2<'a>;
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceMemoryProperties2<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub memory_properties: PhysicalDeviceMemoryProperties,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceMemoryProperties2<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceMemoryProperties2,
            next: ptr::null_mut(),
            memory_properties: Default::default(),
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsPhysicalDeviceMemoryProperties2 {}
impl<'a> PhysicalDeviceMemoryProperties2<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsPhysicalDeviceMemoryProperties2>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

pub type PhysicalDeviceMemoryProperties2KHR<'a> = PhysicalDeviceMemoryProperties2<'a>;
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct SparseImageFormatProperties2<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub properties: SparseImageFormatProperties,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for SparseImageFormatProperties2<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::SparseImageFormatProperties2,
            next: ptr::null_mut(),
            properties: Default::default(),
            _marker: PhantomData,
        }
    }
}

pub type SparseImageFormatProperties2KHR<'a> = SparseImageFormatProperties2<'a>;
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceSparseImageFormatInfo2<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub format: Format,
    pub ty: ImageType,
    pub samples: SampleCountFlags,
    pub usage: ImageUsageFlags,
    pub tiling: ImageTiling,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceSparseImageFormatInfo2<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceSparseImageFormatInfo2,
            next: ptr::null_mut(),
            format: Default::default(),
            ty: Default::default(),
            samples: Default::default(),
            usage: Default::default(),
            tiling: Default::default(),
            _marker: PhantomData,
        }
    }
}

pub type PhysicalDeviceSparseImageFormatInfo2KHR<'a> = PhysicalDeviceSparseImageFormatInfo2<'a>;
/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDevicePushDescriptorProperties<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub max_push_descriptors: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDevicePushDescriptorProperties<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDevicePushDescriptorProperties,
            next: ptr::null_mut(),
            max_push_descriptors: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2 for PhysicalDevicePushDescriptorProperties<'_> {}

pub type PhysicalDevicePushDescriptorPropertiesKHR<'a> = PhysicalDevicePushDescriptorProperties<'a>;
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ConformanceVersion {
    pub major: u8,
    pub minor: u8,
    pub subminor: u8,
    pub patch: u8,
}
impl Default for ConformanceVersion {
    fn default() -> Self {
        Self {
            major: 0,
            minor: 0,
            subminor: 0,
            patch: 0,
        }
    }
}

pub type ConformanceVersionKHR = ConformanceVersion;
/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceDriverProperties<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub driver_id: DriverId,
    /// Len: null-terminated
    pub driver_name: [c_char; MAX_DRIVER_NAME_SIZE as usize],
    /// Len: null-terminated
    pub driver_info: [c_char; MAX_DRIVER_INFO_SIZE as usize],
    pub conformance_version: ConformanceVersion,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceDriverProperties<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceDriverProperties,
            next: ptr::null_mut(),
            driver_id: Default::default(),
            driver_name: unsafe { mem::zeroed() },
            driver_info: unsafe { mem::zeroed() },
            conformance_version: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDriverProperties<'_> {}

pub type PhysicalDeviceDriverPropertiesKHR<'a> = PhysicalDeviceDriverProperties<'a>;
/// Extends: `PresentInfoKHR`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PresentRegionsKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    /// Copy of VkPresentInfoKHR::swapchainCount
    pub swapchain_count: u32,
    /// The regions that have changed
    /// Nullable
    /// Len: `swapchain_count`
    pub regions: *const PresentRegionKHR<'a>,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PresentRegionsKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PresentRegionsKHR,
            next: ptr::null_mut(),
            swapchain_count: 0,
            regions: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsPresentInfoKHR for PresentRegionsKHR<'_> {}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PresentRegionKHR<'a> {
    /// Number of rectangles in pRectangles
    pub rectangle_count: u32,
    /// Array of rectangles that have changed in a swapchain's image(s)
    /// Nullable
    /// Len: `rectangle_count`
    pub rectangles: *const RectLayerKHR,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PresentRegionKHR<'_> {
    fn default() -> Self {
        Self {
            rectangle_count: 0,
            rectangles: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct RectLayerKHR {
    /// upper-left corner of a rectangle that has not changed, in pixels of a presentation images
    pub offset: Offset2D,
    /// Dimensions of a rectangle that has not changed, in pixels of a presentation images
    pub extent: Extent2D,
    /// Layer of a swapchain's image(s), for stereoscopic-3D images
    pub layer: u32,
}
impl Default for RectLayerKHR {
    fn default() -> Self {
        Self {
            offset: Default::default(),
            extent: Default::default(),
            layer: 0,
        }
    }
}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceVariablePointersFeatures<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub variable_pointers_storage_buffer: Bool32,
    pub variable_pointers: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceVariablePointersFeatures<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceVariablePointersFeatures,
            next: ptr::null_mut(),
            variable_pointers_storage_buffer: FALSE,
            variable_pointers: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVariablePointersFeatures<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceVariablePointersFeatures<'_> {}

pub type PhysicalDeviceVariablePointersFeaturesKHR<'a> = PhysicalDeviceVariablePointersFeatures<'a>;
pub type PhysicalDeviceVariablePointerFeaturesKHR<'a> = PhysicalDeviceVariablePointersFeatures<'a>;
pub type PhysicalDeviceVariablePointerFeatures<'a> = PhysicalDeviceVariablePointersFeatures<'a>;
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ExternalMemoryProperties {
    pub external_memory_features: ExternalMemoryFeatureFlags,
    pub export_from_imported_handle_types: ExternalMemoryHandleTypeFlags,
    pub compatible_handle_types: ExternalMemoryHandleTypeFlags,
}
impl Default for ExternalMemoryProperties {
    fn default() -> Self {
        Self {
            external_memory_features: Default::default(),
            export_from_imported_handle_types: Default::default(),
            compatible_handle_types: Default::default(),
        }
    }
}

pub type ExternalMemoryPropertiesKHR = ExternalMemoryProperties;
/// Extends: `PhysicalDeviceImageFormatInfo2`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceExternalImageFormatInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub handle_type: ExternalMemoryHandleTypeFlags,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceExternalImageFormatInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceExternalImageFormatInfo,
            next: ptr::null_mut(),
            handle_type: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceImageFormatInfo2 for PhysicalDeviceExternalImageFormatInfo<'_> {}

pub type PhysicalDeviceExternalImageFormatInfoKHR<'a> = PhysicalDeviceExternalImageFormatInfo<'a>;
/// Extends: `ImageFormatProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ExternalImageFormatProperties<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub external_memory_properties: ExternalMemoryProperties,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ExternalImageFormatProperties<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ExternalImageFormatProperties,
            next: ptr::null_mut(),
            external_memory_properties: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsImageFormatProperties2 for ExternalImageFormatProperties<'_> {}

pub type ExternalImageFormatPropertiesKHR<'a> = ExternalImageFormatProperties<'a>;
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceExternalBufferInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub flags: BufferCreateFlags,
    pub usage: BufferUsageFlags,
    pub handle_type: ExternalMemoryHandleTypeFlags,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceExternalBufferInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceExternalBufferInfo,
            next: ptr::null_mut(),
            flags: Default::default(),
            usage: Default::default(),
            handle_type: Default::default(),
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsPhysicalDeviceExternalBufferInfo {}
impl<'a> PhysicalDeviceExternalBufferInfo<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsPhysicalDeviceExternalBufferInfo>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

pub type PhysicalDeviceExternalBufferInfoKHR<'a> = PhysicalDeviceExternalBufferInfo<'a>;
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ExternalBufferProperties<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub external_memory_properties: ExternalMemoryProperties,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ExternalBufferProperties<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ExternalBufferProperties,
            next: ptr::null_mut(),
            external_memory_properties: Default::default(),
            _marker: PhantomData,
        }
    }
}

pub type ExternalBufferPropertiesKHR<'a> = ExternalBufferProperties<'a>;
/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceIDProperties<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub device_uuid: [u8; UUID_SIZE as usize],
    pub driver_uuid: [u8; UUID_SIZE as usize],
    pub device_luid: [u8; LUID_SIZE as usize],
    pub device_node_mask: u32,
    pub device_luid_valid: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceIDProperties<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceIDProperties,
            next: ptr::null_mut(),
            device_uuid: unsafe { mem::zeroed() },
            driver_uuid: unsafe { mem::zeroed() },
            device_luid: unsafe { mem::zeroed() },
            device_node_mask: 0,
            device_luid_valid: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceIDProperties<'_> {}

pub type PhysicalDeviceIDPropertiesKHR<'a> = PhysicalDeviceIDProperties<'a>;
/// Extends: `ImageCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ExternalMemoryImageCreateInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub handle_types: ExternalMemoryHandleTypeFlags,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ExternalMemoryImageCreateInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ExternalMemoryImageCreateInfo,
            next: ptr::null_mut(),
            handle_types: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsImageCreateInfo for ExternalMemoryImageCreateInfo<'_> {}

pub type ExternalMemoryImageCreateInfoKHR<'a> = ExternalMemoryImageCreateInfo<'a>;
/// Extends: `BufferCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ExternalMemoryBufferCreateInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub handle_types: ExternalMemoryHandleTypeFlags,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ExternalMemoryBufferCreateInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ExternalMemoryBufferCreateInfo,
            next: ptr::null_mut(),
            handle_types: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsBufferCreateInfo for ExternalMemoryBufferCreateInfo<'_> {}

pub type ExternalMemoryBufferCreateInfoKHR<'a> = ExternalMemoryBufferCreateInfo<'a>;
/// Extends: `MemoryAllocateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ExportMemoryAllocateInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub handle_types: ExternalMemoryHandleTypeFlags,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ExportMemoryAllocateInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ExportMemoryAllocateInfo,
            next: ptr::null_mut(),
            handle_types: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsMemoryAllocateInfo for ExportMemoryAllocateInfo<'_> {}

pub type ExportMemoryAllocateInfoKHR<'a> = ExportMemoryAllocateInfo<'a>;
/// Extends: `MemoryAllocateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ImportMemoryWin32HandleInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub handle_type: ExternalMemoryHandleTypeFlags,
    pub handle: HANDLE,
    pub name: LPCWSTR,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ImportMemoryWin32HandleInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ImportMemoryWin32HandleInfoKHR,
            next: ptr::null_mut(),
            handle_type: Default::default(),
            handle: Default::default(),
            name: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsMemoryAllocateInfo for ImportMemoryWin32HandleInfoKHR<'_> {}

/// Extends: `MemoryAllocateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ExportMemoryWin32HandleInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    /// Nullable
    pub attributes: *const SECURITY_ATTRIBUTES,
    pub dw_access: DWORD,
    pub name: LPCWSTR,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ExportMemoryWin32HandleInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ExportMemoryWin32HandleInfoKHR,
            next: ptr::null_mut(),
            attributes: ptr::null_mut(),
            dw_access: Default::default(),
            name: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsMemoryAllocateInfo for ExportMemoryWin32HandleInfoKHR<'_> {}

/// Extends: `MemoryAllocateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ImportMemoryZirconHandleInfoFUCHSIA<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub handle_type: ExternalMemoryHandleTypeFlags,
    pub handle: zx_handle_t,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ImportMemoryZirconHandleInfoFUCHSIA<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ImportMemoryZirconHandleInfoFUCHSIA,
            next: ptr::null_mut(),
            handle_type: Default::default(),
            handle: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsMemoryAllocateInfo for ImportMemoryZirconHandleInfoFUCHSIA<'_> {}

/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct MemoryZirconHandlePropertiesFUCHSIA<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub memory_type_bits: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for MemoryZirconHandlePropertiesFUCHSIA<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::MemoryZirconHandlePropertiesFUCHSIA,
            next: ptr::null_mut(),
            memory_type_bits: 0,
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct MemoryGetZirconHandleInfoFUCHSIA<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub memory: DeviceMemory,
    pub handle_type: ExternalMemoryHandleTypeFlags,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for MemoryGetZirconHandleInfoFUCHSIA<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::MemoryGetZirconHandleInfoFUCHSIA,
            next: ptr::null_mut(),
            memory: Default::default(),
            handle_type: Default::default(),
            _marker: PhantomData,
        }
    }
}

/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct MemoryWin32HandlePropertiesKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub memory_type_bits: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for MemoryWin32HandlePropertiesKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::MemoryWin32HandlePropertiesKHR,
            next: ptr::null_mut(),
            memory_type_bits: 0,
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct MemoryGetWin32HandleInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub memory: DeviceMemory,
    pub handle_type: ExternalMemoryHandleTypeFlags,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for MemoryGetWin32HandleInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::MemoryGetWin32HandleInfoKHR,
            next: ptr::null_mut(),
            memory: Default::default(),
            handle_type: Default::default(),
            _marker: PhantomData,
        }
    }
}

/// Extends: `MemoryAllocateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ImportMemoryFdInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub handle_type: ExternalMemoryHandleTypeFlags,
    pub fd: c_int,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ImportMemoryFdInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ImportMemoryFdInfoKHR,
            next: ptr::null_mut(),
            handle_type: Default::default(),
            fd: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsMemoryAllocateInfo for ImportMemoryFdInfoKHR<'_> {}

/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct MemoryFdPropertiesKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub memory_type_bits: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for MemoryFdPropertiesKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::MemoryFdPropertiesKHR,
            next: ptr::null_mut(),
            memory_type_bits: 0,
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct MemoryGetFdInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub memory: DeviceMemory,
    pub handle_type: ExternalMemoryHandleTypeFlags,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for MemoryGetFdInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::MemoryGetFdInfoKHR,
            next: ptr::null_mut(),
            memory: Default::default(),
            handle_type: Default::default(),
            _marker: PhantomData,
        }
    }
}

/// Extends: `SubmitInfo`, `SubmitInfo2`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct Win32KeyedMutexAcquireReleaseInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub acquire_count: u32,
    /// Len: `acquire_count`
    pub acquire_syncs: *const DeviceMemory,
    /// Len: `acquire_count`
    pub acquire_keys: *const u64,
    /// Len: `acquire_count`
    pub acquire_timeouts: *const u32,
    pub release_count: u32,
    /// Len: `release_count`
    pub release_syncs: *const DeviceMemory,
    /// Len: `release_count`
    pub release_keys: *const u64,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for Win32KeyedMutexAcquireReleaseInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::Win32KeyedMutexAcquireReleaseInfoKHR,
            next: ptr::null_mut(),
            acquire_count: 0,
            acquire_syncs: ptr::null_mut(),
            acquire_keys: ptr::null_mut(),
            acquire_timeouts: ptr::null_mut(),
            release_count: 0,
            release_syncs: ptr::null_mut(),
            release_keys: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsSubmitInfo for Win32KeyedMutexAcquireReleaseInfoKHR<'_> {}
impl ExtendsSubmitInfo2 for Win32KeyedMutexAcquireReleaseInfoKHR<'_> {}

/// Extends: `MemoryAllocateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ImportMemoryMetalHandleInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub handle_type: ExternalMemoryHandleTypeFlags,
    /// Nullable
    pub handle: *mut c_void,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ImportMemoryMetalHandleInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ImportMemoryMetalHandleInfoEXT,
            next: ptr::null_mut(),
            handle_type: Default::default(),
            handle: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsMemoryAllocateInfo for ImportMemoryMetalHandleInfoEXT<'_> {}

/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct MemoryMetalHandlePropertiesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub memory_type_bits: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for MemoryMetalHandlePropertiesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::MemoryMetalHandlePropertiesEXT,
            next: ptr::null_mut(),
            memory_type_bits: 0,
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct MemoryGetMetalHandleInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub memory: DeviceMemory,
    pub handle_type: ExternalMemoryHandleTypeFlags,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for MemoryGetMetalHandleInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::MemoryGetMetalHandleInfoEXT,
            next: ptr::null_mut(),
            memory: Default::default(),
            handle_type: Default::default(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceExternalSemaphoreInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub handle_type: ExternalSemaphoreHandleTypeFlags,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceExternalSemaphoreInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceExternalSemaphoreInfo,
            next: ptr::null_mut(),
            handle_type: Default::default(),
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsPhysicalDeviceExternalSemaphoreInfo {}
impl<'a> PhysicalDeviceExternalSemaphoreInfo<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsPhysicalDeviceExternalSemaphoreInfo>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

pub type PhysicalDeviceExternalSemaphoreInfoKHR<'a> = PhysicalDeviceExternalSemaphoreInfo<'a>;
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ExternalSemaphoreProperties<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub export_from_imported_handle_types: ExternalSemaphoreHandleTypeFlags,
    pub compatible_handle_types: ExternalSemaphoreHandleTypeFlags,
    pub external_semaphore_features: ExternalSemaphoreFeatureFlags,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ExternalSemaphoreProperties<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ExternalSemaphoreProperties,
            next: ptr::null_mut(),
            export_from_imported_handle_types: Default::default(),
            compatible_handle_types: Default::default(),
            external_semaphore_features: Default::default(),
            _marker: PhantomData,
        }
    }
}

pub type ExternalSemaphorePropertiesKHR<'a> = ExternalSemaphoreProperties<'a>;
/// Extends: `SemaphoreCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ExportSemaphoreCreateInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub handle_types: ExternalSemaphoreHandleTypeFlags,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ExportSemaphoreCreateInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ExportSemaphoreCreateInfo,
            next: ptr::null_mut(),
            handle_types: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsSemaphoreCreateInfo for ExportSemaphoreCreateInfo<'_> {}

pub type ExportSemaphoreCreateInfoKHR<'a> = ExportSemaphoreCreateInfo<'a>;
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ImportSemaphoreWin32HandleInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub semaphore: Semaphore,
    pub flags: SemaphoreImportFlags,
    pub handle_type: ExternalSemaphoreHandleTypeFlags,
    pub handle: HANDLE,
    pub name: LPCWSTR,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ImportSemaphoreWin32HandleInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ImportSemaphoreWin32HandleInfoKHR,
            next: ptr::null_mut(),
            semaphore: Default::default(),
            flags: Default::default(),
            handle_type: Default::default(),
            handle: Default::default(),
            name: Default::default(),
            _marker: PhantomData,
        }
    }
}

/// Extends: `SemaphoreCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ExportSemaphoreWin32HandleInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    /// Nullable
    pub attributes: *const SECURITY_ATTRIBUTES,
    pub dw_access: DWORD,
    pub name: LPCWSTR,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ExportSemaphoreWin32HandleInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ExportSemaphoreWin32HandleInfoKHR,
            next: ptr::null_mut(),
            attributes: ptr::null_mut(),
            dw_access: Default::default(),
            name: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsSemaphoreCreateInfo for ExportSemaphoreWin32HandleInfoKHR<'_> {}

/// Extends: `SubmitInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct D3D12FenceSubmitInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub wait_semaphore_values_count: u32,
    /// Nullable
    /// Len: `wait_semaphore_values_count`
    pub wait_semaphore_values: *const u64,
    pub signal_semaphore_values_count: u32,
    /// Nullable
    /// Len: `signal_semaphore_values_count`
    pub signal_semaphore_values: *const u64,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for D3D12FenceSubmitInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::D3D12FenceSubmitInfoKHR,
            next: ptr::null_mut(),
            wait_semaphore_values_count: 0,
            wait_semaphore_values: ptr::null_mut(),
            signal_semaphore_values_count: 0,
            signal_semaphore_values: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsSubmitInfo for D3D12FenceSubmitInfoKHR<'_> {}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct SemaphoreGetWin32HandleInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub semaphore: Semaphore,
    pub handle_type: ExternalSemaphoreHandleTypeFlags,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for SemaphoreGetWin32HandleInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::SemaphoreGetWin32HandleInfoKHR,
            next: ptr::null_mut(),
            semaphore: Default::default(),
            handle_type: Default::default(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ImportSemaphoreFdInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub semaphore: Semaphore,
    pub flags: SemaphoreImportFlags,
    pub handle_type: ExternalSemaphoreHandleTypeFlags,
    pub fd: c_int,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ImportSemaphoreFdInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ImportSemaphoreFdInfoKHR,
            next: ptr::null_mut(),
            semaphore: Default::default(),
            flags: Default::default(),
            handle_type: Default::default(),
            fd: Default::default(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct SemaphoreGetFdInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub semaphore: Semaphore,
    pub handle_type: ExternalSemaphoreHandleTypeFlags,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for SemaphoreGetFdInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::SemaphoreGetFdInfoKHR,
            next: ptr::null_mut(),
            semaphore: Default::default(),
            handle_type: Default::default(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ImportSemaphoreZirconHandleInfoFUCHSIA<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub semaphore: Semaphore,
    pub flags: SemaphoreImportFlags,
    pub handle_type: ExternalSemaphoreHandleTypeFlags,
    pub zircon_handle: zx_handle_t,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ImportSemaphoreZirconHandleInfoFUCHSIA<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ImportSemaphoreZirconHandleInfoFUCHSIA,
            next: ptr::null_mut(),
            semaphore: Default::default(),
            flags: Default::default(),
            handle_type: Default::default(),
            zircon_handle: Default::default(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct SemaphoreGetZirconHandleInfoFUCHSIA<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub semaphore: Semaphore,
    pub handle_type: ExternalSemaphoreHandleTypeFlags,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for SemaphoreGetZirconHandleInfoFUCHSIA<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::SemaphoreGetZirconHandleInfoFUCHSIA,
            next: ptr::null_mut(),
            semaphore: Default::default(),
            handle_type: Default::default(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceExternalFenceInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub handle_type: ExternalFenceHandleTypeFlags,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceExternalFenceInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceExternalFenceInfo,
            next: ptr::null_mut(),
            handle_type: Default::default(),
            _marker: PhantomData,
        }
    }
}

pub type PhysicalDeviceExternalFenceInfoKHR<'a> = PhysicalDeviceExternalFenceInfo<'a>;
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ExternalFenceProperties<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub export_from_imported_handle_types: ExternalFenceHandleTypeFlags,
    pub compatible_handle_types: ExternalFenceHandleTypeFlags,
    pub external_fence_features: ExternalFenceFeatureFlags,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ExternalFenceProperties<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ExternalFenceProperties,
            next: ptr::null_mut(),
            export_from_imported_handle_types: Default::default(),
            compatible_handle_types: Default::default(),
            external_fence_features: Default::default(),
            _marker: PhantomData,
        }
    }
}

pub type ExternalFencePropertiesKHR<'a> = ExternalFenceProperties<'a>;
/// Extends: `FenceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ExportFenceCreateInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub handle_types: ExternalFenceHandleTypeFlags,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ExportFenceCreateInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ExportFenceCreateInfo,
            next: ptr::null_mut(),
            handle_types: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsFenceCreateInfo for ExportFenceCreateInfo<'_> {}

pub type ExportFenceCreateInfoKHR<'a> = ExportFenceCreateInfo<'a>;
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ImportFenceWin32HandleInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub fence: Fence,
    pub flags: FenceImportFlags,
    pub handle_type: ExternalFenceHandleTypeFlags,
    pub handle: HANDLE,
    pub name: LPCWSTR,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ImportFenceWin32HandleInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ImportFenceWin32HandleInfoKHR,
            next: ptr::null_mut(),
            fence: Default::default(),
            flags: Default::default(),
            handle_type: Default::default(),
            handle: Default::default(),
            name: Default::default(),
            _marker: PhantomData,
        }
    }
}

/// Extends: `FenceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ExportFenceWin32HandleInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    /// Nullable
    pub attributes: *const SECURITY_ATTRIBUTES,
    pub dw_access: DWORD,
    pub name: LPCWSTR,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ExportFenceWin32HandleInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ExportFenceWin32HandleInfoKHR,
            next: ptr::null_mut(),
            attributes: ptr::null_mut(),
            dw_access: Default::default(),
            name: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsFenceCreateInfo for ExportFenceWin32HandleInfoKHR<'_> {}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct FenceGetWin32HandleInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub fence: Fence,
    pub handle_type: ExternalFenceHandleTypeFlags,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for FenceGetWin32HandleInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::FenceGetWin32HandleInfoKHR,
            next: ptr::null_mut(),
            fence: Default::default(),
            handle_type: Default::default(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ImportFenceFdInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub fence: Fence,
    pub flags: FenceImportFlags,
    pub handle_type: ExternalFenceHandleTypeFlags,
    pub fd: c_int,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ImportFenceFdInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ImportFenceFdInfoKHR,
            next: ptr::null_mut(),
            fence: Default::default(),
            flags: Default::default(),
            handle_type: Default::default(),
            fd: Default::default(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct FenceGetFdInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub fence: Fence,
    pub handle_type: ExternalFenceHandleTypeFlags,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for FenceGetFdInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::FenceGetFdInfoKHR,
            next: ptr::null_mut(),
            fence: Default::default(),
            handle_type: Default::default(),
            _marker: PhantomData,
        }
    }
}

/// Extends: `FenceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ExportFenceSciSyncInfoNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub attributes: NvSciSyncAttrList,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ExportFenceSciSyncInfoNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ExportFenceSciSyncInfoNV,
            next: ptr::null_mut(),
            attributes: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsFenceCreateInfo for ExportFenceSciSyncInfoNV<'_> {}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ImportFenceSciSyncInfoNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub fence: Fence,
    pub handle_type: ExternalFenceHandleTypeFlags,
    pub handle: *mut c_void,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ImportFenceSciSyncInfoNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ImportFenceSciSyncInfoNV,
            next: ptr::null_mut(),
            fence: Default::default(),
            handle_type: Default::default(),
            handle: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct FenceGetSciSyncInfoNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub fence: Fence,
    pub handle_type: ExternalFenceHandleTypeFlags,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for FenceGetSciSyncInfoNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::FenceGetSciSyncInfoNV,
            next: ptr::null_mut(),
            fence: Default::default(),
            handle_type: Default::default(),
            _marker: PhantomData,
        }
    }
}

/// Extends: `SemaphoreCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ExportSemaphoreSciSyncInfoNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub attributes: NvSciSyncAttrList,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ExportSemaphoreSciSyncInfoNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ExportSemaphoreSciSyncInfoNV,
            next: ptr::null_mut(),
            attributes: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsSemaphoreCreateInfo for ExportSemaphoreSciSyncInfoNV<'_> {}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ImportSemaphoreSciSyncInfoNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub semaphore: Semaphore,
    pub handle_type: ExternalSemaphoreHandleTypeFlags,
    pub handle: *mut c_void,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ImportSemaphoreSciSyncInfoNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ImportSemaphoreSciSyncInfoNV,
            next: ptr::null_mut(),
            semaphore: Default::default(),
            handle_type: Default::default(),
            handle: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct SemaphoreGetSciSyncInfoNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub semaphore: Semaphore,
    pub handle_type: ExternalSemaphoreHandleTypeFlags,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for SemaphoreGetSciSyncInfoNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::SemaphoreGetSciSyncInfoNV,
            next: ptr::null_mut(),
            semaphore: Default::default(),
            handle_type: Default::default(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct SciSyncAttributesInfoNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub client_type: SciSyncClientTypeNV,
    pub primitive_type: SciSyncPrimitiveTypeNV,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for SciSyncAttributesInfoNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::SciSyncAttributesInfoNV,
            next: ptr::null_mut(),
            client_type: Default::default(),
            primitive_type: Default::default(),
            _marker: PhantomData,
        }
    }
}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceExternalSciSyncFeaturesNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub sci_sync_fence: Bool32,
    pub sci_sync_semaphore: Bool32,
    pub sci_sync_import: Bool32,
    pub sci_sync_export: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceExternalSciSyncFeaturesNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceExternalSciSyncFeaturesNV,
            next: ptr::null_mut(),
            sci_sync_fence: FALSE,
            sci_sync_semaphore: FALSE,
            sci_sync_import: FALSE,
            sci_sync_export: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceExternalSciSyncFeaturesNV<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceExternalSciSyncFeaturesNV<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceExternalSciSync2FeaturesNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub sci_sync_fence: Bool32,
    pub sci_sync_semaphore2: Bool32,
    pub sci_sync_import: Bool32,
    pub sci_sync_export: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceExternalSciSync2FeaturesNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceExternalSciSync2FeaturesNV,
            next: ptr::null_mut(),
            sci_sync_fence: FALSE,
            sci_sync_semaphore2: FALSE,
            sci_sync_import: FALSE,
            sci_sync_export: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceExternalSciSync2FeaturesNV<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceExternalSciSync2FeaturesNV<'_> {}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct SemaphoreSciSyncPoolCreateInfoNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub handle: NvSciSyncObj,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for SemaphoreSciSyncPoolCreateInfoNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::SemaphoreSciSyncPoolCreateInfoNV,
            next: ptr::null_mut(),
            handle: Default::default(),
            _marker: PhantomData,
        }
    }
}

/// Extends: `SemaphoreCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct SemaphoreSciSyncCreateInfoNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub semaphore_pool: SemaphoreSciSyncPoolNV,
    pub fence: *const NvSciSyncFence,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for SemaphoreSciSyncCreateInfoNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::SemaphoreSciSyncCreateInfoNV,
            next: ptr::null_mut(),
            semaphore_pool: Default::default(),
            fence: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsSemaphoreCreateInfo for SemaphoreSciSyncCreateInfoNV<'_> {}

/// Extends: `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DeviceSemaphoreSciSyncPoolReservationCreateInfoNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub semaphore_sci_sync_pool_request_count: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for DeviceSemaphoreSciSyncPoolReservationCreateInfoNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::DeviceSemaphoreSciSyncPoolReservationCreateInfoNV,
            next: ptr::null_mut(),
            semaphore_sci_sync_pool_request_count: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsDeviceCreateInfo for DeviceSemaphoreSciSyncPoolReservationCreateInfoNV<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceMultiviewFeatures<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    /// Multiple views in a render pass
    pub multiview: Bool32,
    /// Multiple views in a render pass w/ geometry shader
    pub multiview_geometry_shader: Bool32,
    /// Multiple views in a render pass w/ tessellation shader
    pub multiview_tessellation_shader: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceMultiviewFeatures<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceMultiviewFeatures,
            next: ptr::null_mut(),
            multiview: FALSE,
            multiview_geometry_shader: FALSE,
            multiview_tessellation_shader: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMultiviewFeatures<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceMultiviewFeatures<'_> {}

pub type PhysicalDeviceMultiviewFeaturesKHR<'a> = PhysicalDeviceMultiviewFeatures<'a>;
/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceMultiviewProperties<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    /// max number of views in a subpass
    pub max_multiview_view_count: u32,
    /// max instance index for a draw in a multiview subpass
    pub max_multiview_instance_index: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceMultiviewProperties<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceMultiviewProperties,
            next: ptr::null_mut(),
            max_multiview_view_count: 0,
            max_multiview_instance_index: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMultiviewProperties<'_> {}

pub type PhysicalDeviceMultiviewPropertiesKHR<'a> = PhysicalDeviceMultiviewProperties<'a>;
/// Extends: `RenderPassCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct RenderPassMultiviewCreateInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub subpass_count: u32,
    /// Len: `subpass_count`
    pub view_masks: *const u32,
    pub dependency_count: u32,
    /// Len: `dependency_count`
    pub view_offsets: *const i32,
    pub correlation_mask_count: u32,
    /// Len: `correlation_mask_count`
    pub correlation_masks: *const u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for RenderPassMultiviewCreateInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::RenderPassMultiviewCreateInfo,
            next: ptr::null_mut(),
            subpass_count: 0,
            view_masks: ptr::null_mut(),
            dependency_count: 0,
            view_offsets: ptr::null_mut(),
            correlation_mask_count: 0,
            correlation_masks: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsRenderPassCreateInfo for RenderPassMultiviewCreateInfo<'_> {}

pub type RenderPassMultiviewCreateInfoKHR<'a> = RenderPassMultiviewCreateInfo<'a>;
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct SurfaceCapabilities2EXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    /// Supported minimum number of images for the surface
    pub min_image_count: u32,
    /// Supported maximum number of images for the surface, 0 for unlimited
    pub max_image_count: u32,
    /// Current image width and height for the surface, (0, 0) if undefined
    pub current_extent: Extent2D,
    /// Supported minimum image width and height for the surface
    pub min_image_extent: Extent2D,
    /// Supported maximum image width and height for the surface
    pub max_image_extent: Extent2D,
    /// Supported maximum number of image layers for the surface
    pub max_image_array_layers: u32,
    /// 1 or more bits representing the transforms supported
    pub supported_transforms: SurfaceTransformFlagsKHR,
    /// The surface's current transform relative to the device's natural orientation
    pub current_transform: SurfaceTransformFlagsKHR,
    /// 1 or more bits representing the alpha compositing modes supported
    pub supported_composite_alpha: CompositeAlphaFlagsKHR,
    /// Supported image usage flags for the surface
    pub supported_usage_flags: ImageUsageFlags,
    pub supported_surface_counters: SurfaceCounterFlagsEXT,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for SurfaceCapabilities2EXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::SurfaceCapabilities2EXT,
            next: ptr::null_mut(),
            min_image_count: 0,
            max_image_count: 0,
            current_extent: Default::default(),
            min_image_extent: Default::default(),
            max_image_extent: Default::default(),
            max_image_array_layers: 0,
            supported_transforms: Default::default(),
            current_transform: Default::default(),
            supported_composite_alpha: Default::default(),
            supported_usage_flags: Default::default(),
            supported_surface_counters: Default::default(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DisplayPowerInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub power_state: DisplayPowerStateEXT,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for DisplayPowerInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::DisplayPowerInfoEXT,
            next: ptr::null_mut(),
            power_state: Default::default(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DeviceEventInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub device_event: DeviceEventTypeEXT,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for DeviceEventInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::DeviceEventInfoEXT,
            next: ptr::null_mut(),
            device_event: Default::default(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DisplayEventInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub display_event: DisplayEventTypeEXT,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for DisplayEventInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::DisplayEventInfoEXT,
            next: ptr::null_mut(),
            display_event: Default::default(),
            _marker: PhantomData,
        }
    }
}

/// Extends: `SwapchainCreateInfoKHR`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct SwapchainCounterCreateInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub surface_counters: SurfaceCounterFlagsEXT,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for SwapchainCounterCreateInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::SwapchainCounterCreateInfoEXT,
            next: ptr::null_mut(),
            surface_counters: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsSwapchainCreateInfoKHR for SwapchainCounterCreateInfoEXT<'_> {}

/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceGroupProperties<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub physical_device_count: u32,
    /// Len: `physical_device_count`
    pub physical_devices: [vkPhysicalDevice; MAX_DEVICE_GROUP_SIZE as usize],
    pub subset_allocation: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceGroupProperties<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceGroupProperties,
            next: ptr::null_mut(),
            physical_device_count: 0,
            physical_devices: unsafe { mem::zeroed() },
            subset_allocation: FALSE,
            _marker: PhantomData,
        }
    }
}

pub type PhysicalDeviceGroupPropertiesKHR<'a> = PhysicalDeviceGroupProperties<'a>;
/// Extends: `MemoryAllocateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct MemoryAllocateFlagsInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub flags: MemoryAllocateFlags,
    pub device_mask: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for MemoryAllocateFlagsInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::MemoryAllocateFlagsInfo,
            next: ptr::null_mut(),
            flags: Default::default(),
            device_mask: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsMemoryAllocateInfo for MemoryAllocateFlagsInfo<'_> {}

pub type MemoryAllocateFlagsInfoKHR<'a> = MemoryAllocateFlagsInfo<'a>;
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct BindBufferMemoryInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub buffer: Buffer,
    pub memory: DeviceMemory,
    pub memory_offset: DeviceSize,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for BindBufferMemoryInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::BindBufferMemoryInfo,
            next: ptr::null_mut(),
            buffer: Default::default(),
            memory: Default::default(),
            memory_offset: Default::default(),
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsBindBufferMemoryInfo {}
impl<'a> BindBufferMemoryInfo<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsBindBufferMemoryInfo>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

pub type BindBufferMemoryInfoKHR<'a> = BindBufferMemoryInfo<'a>;
/// Extends: `BindBufferMemoryInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct BindBufferMemoryDeviceGroupInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub device_index_count: u32,
    /// Len: `device_index_count`
    pub device_indices: *const u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for BindBufferMemoryDeviceGroupInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::BindBufferMemoryDeviceGroupInfo,
            next: ptr::null_mut(),
            device_index_count: 0,
            device_indices: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsBindBufferMemoryInfo for BindBufferMemoryDeviceGroupInfo<'_> {}

pub type BindBufferMemoryDeviceGroupInfoKHR<'a> = BindBufferMemoryDeviceGroupInfo<'a>;
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct BindImageMemoryInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub image: Image,
    pub memory: DeviceMemory,
    pub memory_offset: DeviceSize,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for BindImageMemoryInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::BindImageMemoryInfo,
            next: ptr::null_mut(),
            image: Default::default(),
            memory: Default::default(),
            memory_offset: Default::default(),
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsBindImageMemoryInfo {}
impl<'a> BindImageMemoryInfo<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsBindImageMemoryInfo>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

pub type BindImageMemoryInfoKHR<'a> = BindImageMemoryInfo<'a>;
/// Extends: `BindImageMemoryInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct BindImageMemoryDeviceGroupInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub device_index_count: u32,
    /// Len: `device_index_count`
    pub device_indices: *const u32,
    pub split_instance_bind_region_count: u32,
    /// Len: `split_instance_bind_region_count`
    pub split_instance_bind_regions: *const Rect2D,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for BindImageMemoryDeviceGroupInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::BindImageMemoryDeviceGroupInfo,
            next: ptr::null_mut(),
            device_index_count: 0,
            device_indices: ptr::null_mut(),
            split_instance_bind_region_count: 0,
            split_instance_bind_regions: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsBindImageMemoryInfo for BindImageMemoryDeviceGroupInfo<'_> {}

pub type BindImageMemoryDeviceGroupInfoKHR<'a> = BindImageMemoryDeviceGroupInfo<'a>;
/// Extends: `RenderPassBeginInfo`, `RenderingInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DeviceGroupRenderPassBeginInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub device_mask: u32,
    pub device_render_area_count: u32,
    /// Len: `device_render_area_count`
    pub device_render_areas: *const Rect2D,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for DeviceGroupRenderPassBeginInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::DeviceGroupRenderPassBeginInfo,
            next: ptr::null_mut(),
            device_mask: 0,
            device_render_area_count: 0,
            device_render_areas: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsRenderPassBeginInfo for DeviceGroupRenderPassBeginInfo<'_> {}
impl ExtendsRenderingInfo for DeviceGroupRenderPassBeginInfo<'_> {}

pub type DeviceGroupRenderPassBeginInfoKHR<'a> = DeviceGroupRenderPassBeginInfo<'a>;
/// Extends: `CommandBufferBeginInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DeviceGroupCommandBufferBeginInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub device_mask: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for DeviceGroupCommandBufferBeginInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::DeviceGroupCommandBufferBeginInfo,
            next: ptr::null_mut(),
            device_mask: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsCommandBufferBeginInfo for DeviceGroupCommandBufferBeginInfo<'_> {}

pub type DeviceGroupCommandBufferBeginInfoKHR<'a> = DeviceGroupCommandBufferBeginInfo<'a>;
/// Extends: `SubmitInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DeviceGroupSubmitInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub wait_semaphore_count: u32,
    /// Len: `wait_semaphore_count`
    pub wait_semaphore_device_indices: *const u32,
    pub command_buffer_count: u32,
    /// Len: `command_buffer_count`
    pub command_buffer_device_masks: *const u32,
    pub signal_semaphore_count: u32,
    /// Len: `signal_semaphore_count`
    pub signal_semaphore_device_indices: *const u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for DeviceGroupSubmitInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::DeviceGroupSubmitInfo,
            next: ptr::null_mut(),
            wait_semaphore_count: 0,
            wait_semaphore_device_indices: ptr::null_mut(),
            command_buffer_count: 0,
            command_buffer_device_masks: ptr::null_mut(),
            signal_semaphore_count: 0,
            signal_semaphore_device_indices: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsSubmitInfo for DeviceGroupSubmitInfo<'_> {}

pub type DeviceGroupSubmitInfoKHR<'a> = DeviceGroupSubmitInfo<'a>;
/// Extends: `BindSparseInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DeviceGroupBindSparseInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub resource_device_index: u32,
    pub memory_device_index: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for DeviceGroupBindSparseInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::DeviceGroupBindSparseInfo,
            next: ptr::null_mut(),
            resource_device_index: 0,
            memory_device_index: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsBindSparseInfo for DeviceGroupBindSparseInfo<'_> {}

pub type DeviceGroupBindSparseInfoKHR<'a> = DeviceGroupBindSparseInfo<'a>;
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DeviceGroupPresentCapabilitiesKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub present_mask: [u32; MAX_DEVICE_GROUP_SIZE as usize],
    pub modes: DeviceGroupPresentModeFlagsKHR,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for DeviceGroupPresentCapabilitiesKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::DeviceGroupPresentCapabilitiesKHR,
            next: ptr::null_mut(),
            present_mask: unsafe { mem::zeroed() },
            modes: Default::default(),
            _marker: PhantomData,
        }
    }
}

/// Extends: `ImageCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ImageSwapchainCreateInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub swapchain: SwapchainKHR,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ImageSwapchainCreateInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ImageSwapchainCreateInfoKHR,
            next: ptr::null_mut(),
            swapchain: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsImageCreateInfo for ImageSwapchainCreateInfoKHR<'_> {}

/// Extends: `BindImageMemoryInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct BindImageMemorySwapchainInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub swapchain: SwapchainKHR,
    pub image_index: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for BindImageMemorySwapchainInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::BindImageMemorySwapchainInfoKHR,
            next: ptr::null_mut(),
            swapchain: Default::default(),
            image_index: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsBindImageMemoryInfo for BindImageMemorySwapchainInfoKHR<'_> {}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct AcquireNextImageInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub swapchain: SwapchainKHR,
    pub timeout: u64,
    pub semaphore: Semaphore,
    pub fence: Fence,
    pub device_mask: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for AcquireNextImageInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::AcquireNextImageInfoKHR,
            next: ptr::null_mut(),
            swapchain: Default::default(),
            timeout: 0,
            semaphore: Default::default(),
            fence: Default::default(),
            device_mask: 0,
            _marker: PhantomData,
        }
    }
}

/// Extends: `PresentInfoKHR`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DeviceGroupPresentInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub swapchain_count: u32,
    /// Len: `swapchain_count`
    pub device_masks: *const u32,
    pub mode: DeviceGroupPresentModeFlagsKHR,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for DeviceGroupPresentInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::DeviceGroupPresentInfoKHR,
            next: ptr::null_mut(),
            swapchain_count: 0,
            device_masks: ptr::null_mut(),
            mode: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsPresentInfoKHR for DeviceGroupPresentInfoKHR<'_> {}

/// Extends: `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DeviceGroupDeviceCreateInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub physical_device_count: u32,
    /// Len: `physical_device_count`
    pub physical_devices: *const vkPhysicalDevice,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for DeviceGroupDeviceCreateInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::DeviceGroupDeviceCreateInfo,
            next: ptr::null_mut(),
            physical_device_count: 0,
            physical_devices: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsDeviceCreateInfo for DeviceGroupDeviceCreateInfo<'_> {}

pub type DeviceGroupDeviceCreateInfoKHR<'a> = DeviceGroupDeviceCreateInfo<'a>;
/// Extends: `SwapchainCreateInfoKHR`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DeviceGroupSwapchainCreateInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub modes: DeviceGroupPresentModeFlagsKHR,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for DeviceGroupSwapchainCreateInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::DeviceGroupSwapchainCreateInfoKHR,
            next: ptr::null_mut(),
            modes: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsSwapchainCreateInfoKHR for DeviceGroupSwapchainCreateInfoKHR<'_> {}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DescriptorUpdateTemplateEntry {
    /// Binding within the destination descriptor set to write
    pub dst_binding: u32,
    /// Array element within the destination binding to write
    pub dst_array_element: u32,
    /// Number of descriptors to write
    pub descriptor_count: u32,
    /// Descriptor type to write
    pub descriptor_type: DescriptorType,
    /// Offset into pData where the descriptors to update are stored
    pub offset: usize,
    /// Stride between two descriptors in pData when writing more than one descriptor
    pub stride: usize,
}
impl Default for DescriptorUpdateTemplateEntry {
    fn default() -> Self {
        Self {
            dst_binding: 0,
            dst_array_element: 0,
            descriptor_count: 0,
            descriptor_type: Default::default(),
            offset: 0,
            stride: 0,
        }
    }
}

pub type DescriptorUpdateTemplateEntryKHR = DescriptorUpdateTemplateEntry;
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DescriptorUpdateTemplateCreateInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub flags: DescriptorUpdateTemplateCreateFlags,
    /// Number of descriptor update entries to use for the update template
    pub descriptor_update_entry_count: u32,
    /// Descriptor update entries for the template
    /// Len: `descriptor_update_entry_count`
    pub descriptor_update_entries: *const DescriptorUpdateTemplateEntry,
    pub template_type: DescriptorUpdateTemplateType,
    pub descriptor_set_layout: DescriptorSetLayout,
    pub pipeline_bind_point: PipelineBindPoint,
    /// If used for push descriptors, this is the only allowed layout
    pub pipeline_layout: PipelineLayout,
    pub set: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for DescriptorUpdateTemplateCreateInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::DescriptorUpdateTemplateCreateInfo,
            next: ptr::null_mut(),
            flags: Default::default(),
            descriptor_update_entry_count: 0,
            descriptor_update_entries: ptr::null_mut(),
            template_type: Default::default(),
            descriptor_set_layout: Default::default(),
            pipeline_bind_point: Default::default(),
            pipeline_layout: Default::default(),
            set: 0,
            _marker: PhantomData,
        }
    }
}

pub type DescriptorUpdateTemplateCreateInfoKHR<'a> = DescriptorUpdateTemplateCreateInfo<'a>;
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct XYColorEXT {
    pub x: f32,
    pub y: f32,
}
impl Default for XYColorEXT {
    fn default() -> Self {
        Self { x: 0.0, y: 0.0 }
    }
}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDevicePresentIdFeaturesKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    /// Present ID in VkPresentInfoKHR
    pub present_id: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDevicePresentIdFeaturesKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDevicePresentIdFeaturesKHR,
            next: ptr::null_mut(),
            present_id: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePresentIdFeaturesKHR<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDevicePresentIdFeaturesKHR<'_> {}

/// Extends: `PresentInfoKHR`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PresentIdKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    /// Copy of VkPresentInfoKHR::swapchainCount
    pub swapchain_count: u32,
    /// Present ID values for each swapchain
    /// Nullable
    /// Len: `swapchain_count`
    pub present_ids: *const u64,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PresentIdKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PresentIdKHR,
            next: ptr::null_mut(),
            swapchain_count: 0,
            present_ids: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsPresentInfoKHR for PresentIdKHR<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDevicePresentId2FeaturesKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    /// Present ID2 in VkPresentInfoKHR
    pub present_id2: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDevicePresentId2FeaturesKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDevicePresentId2FeaturesKHR,
            next: ptr::null_mut(),
            present_id2: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePresentId2FeaturesKHR<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDevicePresentId2FeaturesKHR<'_> {}

/// Extends: `PresentInfoKHR`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PresentId2KHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    /// Copy of VkPresentInfoKHR::swapchainCount
    pub swapchain_count: u32,
    /// Present ID values for each swapchain
    /// Nullable
    /// Len: `swapchain_count`
    pub present_ids: *const u64,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PresentId2KHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PresentId2KHR,
            next: ptr::null_mut(),
            swapchain_count: 0,
            present_ids: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsPresentInfoKHR for PresentId2KHR<'_> {}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PresentWait2InfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub present_id: u64,
    pub timeout: u64,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PresentWait2InfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PresentWait2InfoKHR,
            next: ptr::null_mut(),
            present_id: 0,
            timeout: 0,
            _marker: PhantomData,
        }
    }
}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDevicePresentWaitFeaturesKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    /// vkWaitForPresentKHR is supported
    pub present_wait: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDevicePresentWaitFeaturesKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDevicePresentWaitFeaturesKHR,
            next: ptr::null_mut(),
            present_wait: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePresentWaitFeaturesKHR<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDevicePresentWaitFeaturesKHR<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDevicePresentWait2FeaturesKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    /// vkWaitForPresent2KHR is supported
    pub present_wait2: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDevicePresentWait2FeaturesKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDevicePresentWait2FeaturesKHR,
            next: ptr::null_mut(),
            present_wait2: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePresentWait2FeaturesKHR<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDevicePresentWait2FeaturesKHR<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDevicePresentTimingFeaturesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    /// vkGetPastPresentationTimingEXT is supported
    pub present_timing: Bool32,
    /// Absolute time can be used to specify present time
    pub present_at_absolute_time: Bool32,
    /// Relative time can be used to specify present duration
    pub present_at_relative_time: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDevicePresentTimingFeaturesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDevicePresentTimingFeaturesEXT,
            next: ptr::null_mut(),
            present_timing: FALSE,
            present_at_absolute_time: FALSE,
            present_at_relative_time: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePresentTimingFeaturesEXT<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDevicePresentTimingFeaturesEXT<'_> {}

/// Extends: `SurfaceCapabilities2KHR`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PresentTimingSurfaceCapabilitiesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    /// presentation timings of the surface can be queried using vkGetPastPresentationTimingEXT
    pub present_timing_supported: Bool32,
    /// surface can be presented using absolute times
    pub present_at_absolute_time_supported: Bool32,
    /// surface can be presented using relative times
    pub present_at_relative_time_supported: Bool32,
    /// present stages that can be queried
    pub present_stage_queries: PresentStageFlagsEXT,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PresentTimingSurfaceCapabilitiesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PresentTimingSurfaceCapabilitiesEXT,
            next: ptr::null_mut(),
            present_timing_supported: FALSE,
            present_at_absolute_time_supported: FALSE,
            present_at_relative_time_supported: FALSE,
            present_stage_queries: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsSurfaceCapabilities2KHR for PresentTimingSurfaceCapabilitiesEXT<'_> {}

/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct SwapchainTimingPropertiesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    /// Number of nanoseconds from the start of one refresh cycle to the next
    pub refresh_duration: u64,
    /// Interval in nanoseconds between refresh cycles durations
    pub refresh_interval: u64,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for SwapchainTimingPropertiesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::SwapchainTimingPropertiesEXT,
            next: ptr::null_mut(),
            refresh_duration: 0,
            refresh_interval: 0,
            _marker: PhantomData,
        }
    }
}

/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct SwapchainTimeDomainPropertiesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub time_domain_count: u32,
    /// Available time domains to use with the swapchain
    /// Nullable
    /// Len: `time_domain_count`
    pub time_domains: *mut TimeDomainKHR,
    /// Unique identifier for a time domain
    /// Nullable
    /// Len: `time_domain_count`
    pub time_domain_ids: *mut u64,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for SwapchainTimeDomainPropertiesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::SwapchainTimeDomainPropertiesEXT,
            next: ptr::null_mut(),
            time_domain_count: 0,
            time_domains: ptr::null_mut(),
            time_domain_ids: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PresentStageTimeEXT {
    pub stage: PresentStageFlagsEXT,
    /// Time in nanoseconds of the associated stage
    pub time: u64,
}
impl Default for PresentStageTimeEXT {
    fn default() -> Self {
        Self {
            stage: Default::default(),
            time: 0,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PastPresentationTimingInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub flags: PastPresentationTimingFlagsEXT,
    pub swapchain: SwapchainKHR,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PastPresentationTimingInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PastPresentationTimingInfoEXT,
            next: ptr::null_mut(),
            flags: Default::default(),
            swapchain: Default::default(),
            _marker: PhantomData,
        }
    }
}

/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PastPresentationTimingPropertiesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub timing_properties_counter: u64,
    pub time_domains_counter: u64,
    pub presentation_timing_count: u32,
    /// Len: `presentation_timing_count`
    pub presentation_timings: *mut PastPresentationTimingEXT<'a>,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PastPresentationTimingPropertiesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PastPresentationTimingPropertiesEXT,
            next: ptr::null_mut(),
            timing_properties_counter: 0,
            time_domains_counter: 0,
            presentation_timing_count: 0,
            presentation_timings: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PastPresentationTimingEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    /// Application-provided identifier, previously given to vkQueuePresentKHR
    pub present_id: u64,
    /// Application-provided present time
    pub target_time: u64,
    /// Number of present stages results available in pPresentStages
    pub present_stage_count: u32,
    /// Reported timings for each present stage
    /// Len: `present_stage_count`
    pub present_stages: *mut PresentStageTimeEXT,
    /// Time domain of the present stages
    pub time_domain: TimeDomainKHR,
    /// Time domain id of the present stages
    pub time_domain_id: u64,
    /// VK_TRUE if all the present stages have been reported
    pub report_complete: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PastPresentationTimingEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PastPresentationTimingEXT,
            next: ptr::null_mut(),
            present_id: 0,
            target_time: 0,
            present_stage_count: 0,
            present_stages: ptr::null_mut(),
            time_domain: Default::default(),
            time_domain_id: 0,
            report_complete: FALSE,
            _marker: PhantomData,
        }
    }
}

/// Extends: `PresentInfoKHR`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PresentTimingsInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    /// Copy of VkPresentInfoKHR::swapchainCount
    pub swapchain_count: u32,
    /// Present timing details for each swapchain
    /// Nullable
    /// Len: `swapchain_count`
    pub timing_infos: *const PresentTimingInfoEXT<'a>,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PresentTimingsInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PresentTimingsInfoEXT,
            next: ptr::null_mut(),
            swapchain_count: 0,
            timing_infos: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsPresentInfoKHR for PresentTimingsInfoEXT<'_> {}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PresentTimingInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub flags: PresentTimingInfoFlagsEXT,
    pub target_time: u64,
    /// Time domain to interpret the target present time and collect present stages timings with
    pub time_domain_id: u64,
    /// Present stages to collect timing information for
    pub present_stage_queries: PresentStageFlagsEXT,
    /// Target stage-local time domain's stage
    pub target_time_domain_present_stage: PresentStageFlagsEXT,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PresentTimingInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PresentTimingInfoEXT,
            next: ptr::null_mut(),
            flags: Default::default(),
            target_time: 0,
            time_domain_id: 0,
            present_stage_queries: Default::default(),
            target_time_domain_present_stage: Default::default(),
            _marker: PhantomData,
        }
    }
}

/// Extends: `CalibratedTimestampInfoKHR`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct SwapchainCalibratedTimestampInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub swapchain: SwapchainKHR,
    pub present_stage: PresentStageFlagsEXT,
    pub time_domain_id: u64,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for SwapchainCalibratedTimestampInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::SwapchainCalibratedTimestampInfoEXT,
            next: ptr::null_mut(),
            swapchain: Default::default(),
            present_stage: Default::default(),
            time_domain_id: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsCalibratedTimestampInfoKHR for SwapchainCalibratedTimestampInfoEXT<'_> {}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct HdrMetadataEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    /// Display primary's Red
    pub display_primary_red: XYColorEXT,
    /// Display primary's Green
    pub display_primary_green: XYColorEXT,
    /// Display primary's Blue
    pub display_primary_blue: XYColorEXT,
    /// Display primary's Blue
    pub white_point: XYColorEXT,
    /// Display maximum luminance
    pub max_luminance: f32,
    /// Display minimum luminance
    pub min_luminance: f32,
    /// Content maximum luminance
    pub max_content_light_level: f32,
    pub max_frame_average_light_level: f32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for HdrMetadataEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::HdrMetadataEXT,
            next: ptr::null_mut(),
            display_primary_red: Default::default(),
            display_primary_green: Default::default(),
            display_primary_blue: Default::default(),
            white_point: Default::default(),
            max_luminance: 0.0,
            min_luminance: 0.0,
            max_content_light_level: 0.0,
            max_frame_average_light_level: 0.0,
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsHdrMetadataEXT {}
impl<'a> HdrMetadataEXT<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsHdrMetadataEXT>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

/// Extends: `HdrMetadataEXT`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct HdrVividDynamicMetadataHUAWEI<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    /// Specified in bytes
    pub dynamic_metadata_size: usize,
    /// Binary code of size dynamicMetadataSize
    /// Len: `dynamic_metadata_size`
    pub dynamic_metadata: *const c_void,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for HdrVividDynamicMetadataHUAWEI<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::HdrVividDynamicMetadataHUAWEI,
            next: ptr::null_mut(),
            dynamic_metadata_size: 0,
            dynamic_metadata: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsHdrMetadataEXT for HdrVividDynamicMetadataHUAWEI<'_> {}

/// Extends: `SurfaceCapabilities2KHR`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DisplayNativeHdrSurfaceCapabilitiesAMD<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub local_dimming_support: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for DisplayNativeHdrSurfaceCapabilitiesAMD<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::DisplayNativeHdrSurfaceCapabilitiesAMD,
            next: ptr::null_mut(),
            local_dimming_support: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsSurfaceCapabilities2KHR for DisplayNativeHdrSurfaceCapabilitiesAMD<'_> {}

/// Extends: `SwapchainCreateInfoKHR`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct SwapchainDisplayNativeHdrCreateInfoAMD<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub local_dimming_enable: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for SwapchainDisplayNativeHdrCreateInfoAMD<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::SwapchainDisplayNativeHdrCreateInfoAMD,
            next: ptr::null_mut(),
            local_dimming_enable: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsSwapchainCreateInfoKHR for SwapchainDisplayNativeHdrCreateInfoAMD<'_> {}

/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct RefreshCycleDurationGOOGLE {
    /// Number of nanoseconds from the start of one refresh cycle to the next
    pub refresh_duration: u64,
}
impl Default for RefreshCycleDurationGOOGLE {
    fn default() -> Self {
        Self {
            refresh_duration: 0,
        }
    }
}

/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PastPresentationTimingGOOGLE {
    /// Application-provided identifier, previously given to vkQueuePresentKHR
    pub present_id: u32,
    /// Earliest time an image should have been presented, previously given to vkQueuePresentKHR
    pub desired_present_time: u64,
    /// Time the image was actually displayed
    pub actual_present_time: u64,
    /// Earliest time the image could have been displayed
    pub earliest_present_time: u64,
    /// How early vkQueuePresentKHR was processed vs. how soon it needed to be and make earliestPresentTime
    pub present_margin: u64,
}
impl Default for PastPresentationTimingGOOGLE {
    fn default() -> Self {
        Self {
            present_id: 0,
            desired_present_time: 0,
            actual_present_time: 0,
            earliest_present_time: 0,
            present_margin: 0,
        }
    }
}

/// Extends: `PresentInfoKHR`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PresentTimesInfoGOOGLE<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    /// Copy of VkPresentInfoKHR::swapchainCount
    pub swapchain_count: u32,
    /// The earliest times to present images
    /// Nullable
    /// Len: `swapchain_count`
    pub times: *const PresentTimeGOOGLE,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PresentTimesInfoGOOGLE<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PresentTimesInfoGOOGLE,
            next: ptr::null_mut(),
            swapchain_count: 0,
            times: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsPresentInfoKHR for PresentTimesInfoGOOGLE<'_> {}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PresentTimeGOOGLE {
    /// Application-provided identifier
    pub present_id: u32,
    /// Earliest time an image should be presented
    pub desired_present_time: u64,
}
impl Default for PresentTimeGOOGLE {
    fn default() -> Self {
        Self {
            present_id: 0,
            desired_present_time: 0,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct IOSSurfaceCreateInfoMVK<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub flags: IOSSurfaceCreateFlagsMVK,
    pub view: *const c_void,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for IOSSurfaceCreateInfoMVK<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::IOSSurfaceCreateInfoMVK,
            next: ptr::null_mut(),
            flags: Default::default(),
            view: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct MacOSSurfaceCreateInfoMVK<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub flags: MacOSSurfaceCreateFlagsMVK,
    pub view: *const c_void,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for MacOSSurfaceCreateInfoMVK<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::MacOSSurfaceCreateInfoMVK,
            next: ptr::null_mut(),
            flags: Default::default(),
            view: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct MetalSurfaceCreateInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub flags: MetalSurfaceCreateFlagsEXT,
    pub layer: *const CAMetalLayer,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for MetalSurfaceCreateInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::MetalSurfaceCreateInfoEXT,
            next: ptr::null_mut(),
            flags: Default::default(),
            layer: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ViewportWScalingNV {
    pub xcoeff: f32,
    pub ycoeff: f32,
}
impl Default for ViewportWScalingNV {
    fn default() -> Self {
        Self {
            xcoeff: 0.0,
            ycoeff: 0.0,
        }
    }
}

/// Extends: `PipelineViewportStateCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PipelineViewportWScalingStateCreateInfoNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub viewport_w_scaling_enable: Bool32,
    pub viewport_count: u32,
    /// Nullable
    /// Len: `viewport_count`
    pub viewport_w_scalings: *const ViewportWScalingNV,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PipelineViewportWScalingStateCreateInfoNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PipelineViewportWScalingStateCreateInfoNV,
            next: ptr::null_mut(),
            viewport_w_scaling_enable: FALSE,
            viewport_count: 0,
            viewport_w_scalings: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsPipelineViewportStateCreateInfo for PipelineViewportWScalingStateCreateInfoNV<'_> {}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ViewportSwizzleNV {
    pub x: ViewportCoordinateSwizzleNV,
    pub y: ViewportCoordinateSwizzleNV,
    pub z: ViewportCoordinateSwizzleNV,
    pub w: ViewportCoordinateSwizzleNV,
}
impl Default for ViewportSwizzleNV {
    fn default() -> Self {
        Self {
            x: Default::default(),
            y: Default::default(),
            z: Default::default(),
            w: Default::default(),
        }
    }
}

/// Extends: `PipelineViewportStateCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PipelineViewportSwizzleStateCreateInfoNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub flags: PipelineViewportSwizzleStateCreateFlagsNV,
    pub viewport_count: u32,
    /// Len: `viewport_count`
    pub viewport_swizzles: *const ViewportSwizzleNV,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PipelineViewportSwizzleStateCreateInfoNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PipelineViewportSwizzleStateCreateInfoNV,
            next: ptr::null_mut(),
            flags: Default::default(),
            viewport_count: 0,
            viewport_swizzles: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsPipelineViewportStateCreateInfo for PipelineViewportSwizzleStateCreateInfoNV<'_> {}

/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceDiscardRectanglePropertiesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    /// max number of active discard rectangles
    pub max_discard_rectangles: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceDiscardRectanglePropertiesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceDiscardRectanglePropertiesEXT,
            next: ptr::null_mut(),
            max_discard_rectangles: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDiscardRectanglePropertiesEXT<'_> {}

/// Extends: `GraphicsPipelineCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PipelineDiscardRectangleStateCreateInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub flags: PipelineDiscardRectangleStateCreateFlagsEXT,
    pub discard_rectangle_mode: DiscardRectangleModeEXT,
    pub discard_rectangle_count: u32,
    /// Len: `discard_rectangle_count`
    pub discard_rectangles: *const Rect2D,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PipelineDiscardRectangleStateCreateInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PipelineDiscardRectangleStateCreateInfoEXT,
            next: ptr::null_mut(),
            flags: Default::default(),
            discard_rectangle_mode: Default::default(),
            discard_rectangle_count: 0,
            discard_rectangles: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsGraphicsPipelineCreateInfo for PipelineDiscardRectangleStateCreateInfoEXT<'_> {}

/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub per_view_position_all_components: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX,
            next: ptr::null_mut(),
            per_view_position_all_components: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2
    for PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX<'_>
{
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct InputAttachmentAspectReference {
    pub subpass: u32,
    pub input_attachment_index: u32,
    pub aspect_mask: ImageAspectFlags,
}
impl Default for InputAttachmentAspectReference {
    fn default() -> Self {
        Self {
            subpass: 0,
            input_attachment_index: 0,
            aspect_mask: Default::default(),
        }
    }
}

pub type InputAttachmentAspectReferenceKHR = InputAttachmentAspectReference;
/// Extends: `RenderPassCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct RenderPassInputAttachmentAspectCreateInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub aspect_reference_count: u32,
    /// Len: `aspect_reference_count`
    pub aspect_references: *const InputAttachmentAspectReference,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for RenderPassInputAttachmentAspectCreateInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::RenderPassInputAttachmentAspectCreateInfo,
            next: ptr::null_mut(),
            aspect_reference_count: 0,
            aspect_references: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsRenderPassCreateInfo for RenderPassInputAttachmentAspectCreateInfo<'_> {}

pub type RenderPassInputAttachmentAspectCreateInfoKHR<'a> =
    RenderPassInputAttachmentAspectCreateInfo<'a>;
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceSurfaceInfo2KHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub surface: SurfaceKHR,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceSurfaceInfo2KHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceSurfaceInfo2KHR,
            next: ptr::null_mut(),
            surface: Default::default(),
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsPhysicalDeviceSurfaceInfo2KHR {}
impl<'a> PhysicalDeviceSurfaceInfo2KHR<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsPhysicalDeviceSurfaceInfo2KHR>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct SurfaceCapabilities2KHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub surface_capabilities: SurfaceCapabilitiesKHR,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for SurfaceCapabilities2KHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::SurfaceCapabilities2KHR,
            next: ptr::null_mut(),
            surface_capabilities: Default::default(),
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsSurfaceCapabilities2KHR {}
impl<'a> SurfaceCapabilities2KHR<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsSurfaceCapabilities2KHR>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct SurfaceFormat2KHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub surface_format: SurfaceFormatKHR,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for SurfaceFormat2KHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::SurfaceFormat2KHR,
            next: ptr::null_mut(),
            surface_format: Default::default(),
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsSurfaceFormat2KHR {}
impl<'a> SurfaceFormat2KHR<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsSurfaceFormat2KHR>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DisplayProperties2KHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub display_properties: DisplayPropertiesKHR<'a>,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for DisplayProperties2KHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::DisplayProperties2KHR,
            next: ptr::null_mut(),
            display_properties: Default::default(),
            _marker: PhantomData,
        }
    }
}

/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DisplayPlaneProperties2KHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub display_plane_properties: DisplayPlanePropertiesKHR,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for DisplayPlaneProperties2KHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::DisplayPlaneProperties2KHR,
            next: ptr::null_mut(),
            display_plane_properties: Default::default(),
            _marker: PhantomData,
        }
    }
}

/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DisplayModeProperties2KHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub display_mode_properties: DisplayModePropertiesKHR,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for DisplayModeProperties2KHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::DisplayModeProperties2KHR,
            next: ptr::null_mut(),
            display_mode_properties: Default::default(),
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsDisplayModeProperties2KHR {}
impl<'a> DisplayModeProperties2KHR<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsDisplayModeProperties2KHR>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

/// Extends: `DisplayModeProperties2KHR`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DisplayModeStereoPropertiesNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    /// Whether this mode supports HDMI 3D stereo rendering.
    pub hdmi3_d_supported: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for DisplayModeStereoPropertiesNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::DisplayModeStereoPropertiesNV,
            next: ptr::null_mut(),
            hdmi3_d_supported: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsDisplayModeProperties2KHR for DisplayModeStereoPropertiesNV<'_> {}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DisplayPlaneInfo2KHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub mode: DisplayModeKHR,
    pub plane_index: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for DisplayPlaneInfo2KHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::DisplayPlaneInfo2KHR,
            next: ptr::null_mut(),
            mode: Default::default(),
            plane_index: 0,
            _marker: PhantomData,
        }
    }
}

/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DisplayPlaneCapabilities2KHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub capabilities: DisplayPlaneCapabilitiesKHR,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for DisplayPlaneCapabilities2KHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::DisplayPlaneCapabilities2KHR,
            next: ptr::null_mut(),
            capabilities: Default::default(),
            _marker: PhantomData,
        }
    }
}

/// Extends: `SurfaceCapabilities2KHR`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct SharedPresentSurfaceCapabilitiesKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    /// Supported image usage flags if swapchain created using a shared present mode
    pub shared_present_supported_usage_flags: ImageUsageFlags,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for SharedPresentSurfaceCapabilitiesKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::SharedPresentSurfaceCapabilitiesKHR,
            next: ptr::null_mut(),
            shared_present_supported_usage_flags: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsSurfaceCapabilities2KHR for SharedPresentSurfaceCapabilitiesKHR<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDevice16BitStorageFeatures<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    /// 16-bit integer/floating-point variables supported in BufferBlock
    pub storage_buffer16_bit_access: Bool32,
    /// 16-bit integer/floating-point variables supported in BufferBlock and Block
    pub uniform_and_storage_buffer16_bit_access: Bool32,
    /// 16-bit integer/floating-point variables supported in PushConstant
    pub storage_push_constant16: Bool32,
    /// 16-bit integer/floating-point variables supported in shader inputs and outputs
    pub storage_input_output16: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDevice16BitStorageFeatures<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDevice16BitStorageFeatures,
            next: ptr::null_mut(),
            storage_buffer16_bit_access: FALSE,
            uniform_and_storage_buffer16_bit_access: FALSE,
            storage_push_constant16: FALSE,
            storage_input_output16: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevice16BitStorageFeatures<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDevice16BitStorageFeatures<'_> {}

pub type PhysicalDevice16BitStorageFeaturesKHR<'a> = PhysicalDevice16BitStorageFeatures<'a>;
/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceSubgroupProperties<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    /// The size of a subgroup for this queue.
    pub subgroup_size: u32,
    /// Bitfield of what shader stages support subgroup operations
    pub supported_stages: ShaderStageFlags,
    /// Bitfield of what subgroup operations are supported.
    pub supported_operations: SubgroupFeatureFlags,
    /// Flag to specify whether quad operations are available in all stages.
    pub quad_operations_in_all_stages: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceSubgroupProperties<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceSubgroupProperties,
            next: ptr::null_mut(),
            subgroup_size: 0,
            supported_stages: Default::default(),
            supported_operations: Default::default(),
            quad_operations_in_all_stages: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceSubgroupProperties<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceShaderSubgroupExtendedTypesFeatures<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    /// Flag to specify whether subgroup operations with extended types are supported
    pub shader_subgroup_extended_types: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceShaderSubgroupExtendedTypesFeatures<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceShaderSubgroupExtendedTypesFeatures,
            next: ptr::null_mut(),
            shader_subgroup_extended_types: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderSubgroupExtendedTypesFeatures<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderSubgroupExtendedTypesFeatures<'_> {}

pub type PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR<'a> =
    PhysicalDeviceShaderSubgroupExtendedTypesFeatures<'a>;
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct BufferMemoryRequirementsInfo2<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub buffer: Buffer,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for BufferMemoryRequirementsInfo2<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::BufferMemoryRequirementsInfo2,
            next: ptr::null_mut(),
            buffer: Default::default(),
            _marker: PhantomData,
        }
    }
}

pub type BufferMemoryRequirementsInfo2KHR<'a> = BufferMemoryRequirementsInfo2<'a>;
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DeviceBufferMemoryRequirements<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub create_info: *const BufferCreateInfo<'a>,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for DeviceBufferMemoryRequirements<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::DeviceBufferMemoryRequirements,
            next: ptr::null_mut(),
            create_info: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

pub type DeviceBufferMemoryRequirementsKHR<'a> = DeviceBufferMemoryRequirements<'a>;
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ImageMemoryRequirementsInfo2<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub image: Image,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ImageMemoryRequirementsInfo2<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ImageMemoryRequirementsInfo2,
            next: ptr::null_mut(),
            image: Default::default(),
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsImageMemoryRequirementsInfo2 {}
impl<'a> ImageMemoryRequirementsInfo2<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsImageMemoryRequirementsInfo2>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

pub type ImageMemoryRequirementsInfo2KHR<'a> = ImageMemoryRequirementsInfo2<'a>;
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ImageSparseMemoryRequirementsInfo2<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub image: Image,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ImageSparseMemoryRequirementsInfo2<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ImageSparseMemoryRequirementsInfo2,
            next: ptr::null_mut(),
            image: Default::default(),
            _marker: PhantomData,
        }
    }
}

pub type ImageSparseMemoryRequirementsInfo2KHR<'a> = ImageSparseMemoryRequirementsInfo2<'a>;
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DeviceImageMemoryRequirements<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub create_info: *const ImageCreateInfo<'a>,
    pub plane_aspect: ImageAspectFlags,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for DeviceImageMemoryRequirements<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::DeviceImageMemoryRequirements,
            next: ptr::null_mut(),
            create_info: ptr::null_mut(),
            plane_aspect: Default::default(),
            _marker: PhantomData,
        }
    }
}

pub type DeviceImageMemoryRequirementsKHR<'a> = DeviceImageMemoryRequirements<'a>;
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct MemoryRequirements2<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub memory_requirements: MemoryRequirements,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for MemoryRequirements2<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::MemoryRequirements2,
            next: ptr::null_mut(),
            memory_requirements: Default::default(),
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsMemoryRequirements2 {}
impl<'a> MemoryRequirements2<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsMemoryRequirements2>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

pub type MemoryRequirements2KHR<'a> = MemoryRequirements2<'a>;
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct SparseImageMemoryRequirements2<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub memory_requirements: SparseImageMemoryRequirements,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for SparseImageMemoryRequirements2<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::SparseImageMemoryRequirements2,
            next: ptr::null_mut(),
            memory_requirements: Default::default(),
            _marker: PhantomData,
        }
    }
}

pub type SparseImageMemoryRequirements2KHR<'a> = SparseImageMemoryRequirements2<'a>;
/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDevicePointClippingProperties<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub point_clipping_behavior: PointClippingBehavior,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDevicePointClippingProperties<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDevicePointClippingProperties,
            next: ptr::null_mut(),
            point_clipping_behavior: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2 for PhysicalDevicePointClippingProperties<'_> {}

pub type PhysicalDevicePointClippingPropertiesKHR<'a> = PhysicalDevicePointClippingProperties<'a>;
/// Extends: `MemoryRequirements2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct MemoryDedicatedRequirements<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub prefers_dedicated_allocation: Bool32,
    pub requires_dedicated_allocation: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for MemoryDedicatedRequirements<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::MemoryDedicatedRequirements,
            next: ptr::null_mut(),
            prefers_dedicated_allocation: FALSE,
            requires_dedicated_allocation: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsMemoryRequirements2 for MemoryDedicatedRequirements<'_> {}

pub type MemoryDedicatedRequirementsKHR<'a> = MemoryDedicatedRequirements<'a>;
/// Extends: `MemoryAllocateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct MemoryDedicatedAllocateInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    /// Image that this allocation will be bound to
    pub image: Image,
    /// Buffer that this allocation will be bound to
    pub buffer: Buffer,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for MemoryDedicatedAllocateInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::MemoryDedicatedAllocateInfo,
            next: ptr::null_mut(),
            image: Default::default(),
            buffer: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsMemoryAllocateInfo for MemoryDedicatedAllocateInfo<'_> {}

pub type MemoryDedicatedAllocateInfoKHR<'a> = MemoryDedicatedAllocateInfo<'a>;
/// Extends: `ImageViewCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ImageViewUsageCreateInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub usage: ImageUsageFlags,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ImageViewUsageCreateInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ImageViewUsageCreateInfo,
            next: ptr::null_mut(),
            usage: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsImageViewCreateInfo for ImageViewUsageCreateInfo<'_> {}

/// Extends: `ImageViewCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ImageViewSlicedCreateInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub slice_offset: u32,
    pub slice_count: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ImageViewSlicedCreateInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ImageViewSlicedCreateInfoEXT,
            next: ptr::null_mut(),
            slice_offset: 0,
            slice_count: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsImageViewCreateInfo for ImageViewSlicedCreateInfoEXT<'_> {}

pub type ImageViewUsageCreateInfoKHR<'a> = ImageViewUsageCreateInfo<'a>;
/// Extends: `PipelineTessellationStateCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PipelineTessellationDomainOriginStateCreateInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub domain_origin: TessellationDomainOrigin,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PipelineTessellationDomainOriginStateCreateInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PipelineTessellationDomainOriginStateCreateInfo,
            next: ptr::null_mut(),
            domain_origin: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsPipelineTessellationStateCreateInfo
    for PipelineTessellationDomainOriginStateCreateInfo<'_>
{
}

pub type PipelineTessellationDomainOriginStateCreateInfoKHR<'a> =
    PipelineTessellationDomainOriginStateCreateInfo<'a>;
/// Extends: `SamplerCreateInfo`, `ImageViewCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct SamplerYcbcrConversionInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub conversion: SamplerYcbcrConversion,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for SamplerYcbcrConversionInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::SamplerYcbcrConversionInfo,
            next: ptr::null_mut(),
            conversion: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsSamplerCreateInfo for SamplerYcbcrConversionInfo<'_> {}
impl ExtendsImageViewCreateInfo for SamplerYcbcrConversionInfo<'_> {}

pub type SamplerYcbcrConversionInfoKHR<'a> = SamplerYcbcrConversionInfo<'a>;
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct SamplerYcbcrConversionCreateInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub format: Format,
    pub ycbcr_model: SamplerYcbcrModelConversion,
    pub ycbcr_range: SamplerYcbcrRange,
    pub components: ComponentMapping,
    pub x_chroma_offset: ChromaLocation,
    pub y_chroma_offset: ChromaLocation,
    pub chroma_filter: Filter,
    pub force_explicit_reconstruction: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for SamplerYcbcrConversionCreateInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::SamplerYcbcrConversionCreateInfo,
            next: ptr::null_mut(),
            format: Default::default(),
            ycbcr_model: Default::default(),
            ycbcr_range: Default::default(),
            components: Default::default(),
            x_chroma_offset: Default::default(),
            y_chroma_offset: Default::default(),
            chroma_filter: Default::default(),
            force_explicit_reconstruction: FALSE,
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsSamplerYcbcrConversionCreateInfo {}
impl<'a> SamplerYcbcrConversionCreateInfo<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsSamplerYcbcrConversionCreateInfo>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

pub type SamplerYcbcrConversionCreateInfoKHR<'a> = SamplerYcbcrConversionCreateInfo<'a>;
/// Extends: `BindImageMemoryInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct BindImagePlaneMemoryInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub plane_aspect: ImageAspectFlags,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for BindImagePlaneMemoryInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::BindImagePlaneMemoryInfo,
            next: ptr::null_mut(),
            plane_aspect: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsBindImageMemoryInfo for BindImagePlaneMemoryInfo<'_> {}

pub type BindImagePlaneMemoryInfoKHR<'a> = BindImagePlaneMemoryInfo<'a>;
/// Extends: `ImageMemoryRequirementsInfo2`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ImagePlaneMemoryRequirementsInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub plane_aspect: ImageAspectFlags,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ImagePlaneMemoryRequirementsInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ImagePlaneMemoryRequirementsInfo,
            next: ptr::null_mut(),
            plane_aspect: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsImageMemoryRequirementsInfo2 for ImagePlaneMemoryRequirementsInfo<'_> {}

pub type ImagePlaneMemoryRequirementsInfoKHR<'a> = ImagePlaneMemoryRequirementsInfo<'a>;
/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceSamplerYcbcrConversionFeatures<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    /// Sampler color conversion supported
    pub sampler_ycbcr_conversion: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceSamplerYcbcrConversionFeatures<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceSamplerYcbcrConversionFeatures,
            next: ptr::null_mut(),
            sampler_ycbcr_conversion: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceSamplerYcbcrConversionFeatures<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceSamplerYcbcrConversionFeatures<'_> {}

pub type PhysicalDeviceSamplerYcbcrConversionFeaturesKHR<'a> =
    PhysicalDeviceSamplerYcbcrConversionFeatures<'a>;
/// Extends: `ImageFormatProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct SamplerYcbcrConversionImageFormatProperties<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub combined_image_sampler_descriptor_count: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for SamplerYcbcrConversionImageFormatProperties<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::SamplerYcbcrConversionImageFormatProperties,
            next: ptr::null_mut(),
            combined_image_sampler_descriptor_count: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsImageFormatProperties2 for SamplerYcbcrConversionImageFormatProperties<'_> {}

pub type SamplerYcbcrConversionImageFormatPropertiesKHR<'a> =
    SamplerYcbcrConversionImageFormatProperties<'a>;
/// Extends: `ImageFormatProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct TextureLODGatherFormatPropertiesAMD<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub supports_texture_gather_lod_bias_amd: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for TextureLODGatherFormatPropertiesAMD<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::TextureLODGatherFormatPropertiesAMD,
            next: ptr::null_mut(),
            supports_texture_gather_lod_bias_amd: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsImageFormatProperties2 for TextureLODGatherFormatPropertiesAMD<'_> {}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ConditionalRenderingBeginInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub buffer: Buffer,
    pub offset: DeviceSize,
    pub flags: ConditionalRenderingFlagsEXT,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ConditionalRenderingBeginInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ConditionalRenderingBeginInfoEXT,
            next: ptr::null_mut(),
            buffer: Default::default(),
            offset: Default::default(),
            flags: Default::default(),
            _marker: PhantomData,
        }
    }
}

/// Extends: `SubmitInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ProtectedSubmitInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    /// Submit protected command buffers
    pub protected_submit: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ProtectedSubmitInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ProtectedSubmitInfo,
            next: ptr::null_mut(),
            protected_submit: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsSubmitInfo for ProtectedSubmitInfo<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceProtectedMemoryFeatures<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub protected_memory: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceProtectedMemoryFeatures<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceProtectedMemoryFeatures,
            next: ptr::null_mut(),
            protected_memory: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceProtectedMemoryFeatures<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceProtectedMemoryFeatures<'_> {}

/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceProtectedMemoryProperties<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub protected_no_fault: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceProtectedMemoryProperties<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceProtectedMemoryProperties,
            next: ptr::null_mut(),
            protected_no_fault: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceProtectedMemoryProperties<'_> {}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DeviceQueueInfo2<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub flags: DeviceQueueCreateFlags,
    pub queue_family_index: u32,
    pub queue_index: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for DeviceQueueInfo2<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::DeviceQueueInfo2,
            next: ptr::null_mut(),
            flags: Default::default(),
            queue_family_index: 0,
            queue_index: 0,
            _marker: PhantomData,
        }
    }
}

/// Extends: `PipelineMultisampleStateCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PipelineCoverageToColorStateCreateInfoNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub flags: PipelineCoverageToColorStateCreateFlagsNV,
    pub coverage_to_color_enable: Bool32,
    pub coverage_to_color_location: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PipelineCoverageToColorStateCreateInfoNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PipelineCoverageToColorStateCreateInfoNV,
            next: ptr::null_mut(),
            flags: Default::default(),
            coverage_to_color_enable: FALSE,
            coverage_to_color_location: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPipelineMultisampleStateCreateInfo for PipelineCoverageToColorStateCreateInfoNV<'_> {}

/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceSamplerFilterMinmaxProperties<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub filter_minmax_single_component_formats: Bool32,
    pub filter_minmax_image_component_mapping: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceSamplerFilterMinmaxProperties<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceSamplerFilterMinmaxProperties,
            next: ptr::null_mut(),
            filter_minmax_single_component_formats: FALSE,
            filter_minmax_image_component_mapping: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceSamplerFilterMinmaxProperties<'_> {}

pub type PhysicalDeviceSamplerFilterMinmaxPropertiesEXT<'a> =
    PhysicalDeviceSamplerFilterMinmaxProperties<'a>;
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct SampleLocationEXT {
    pub x: f32,
    pub y: f32,
}
impl Default for SampleLocationEXT {
    fn default() -> Self {
        Self { x: 0.0, y: 0.0 }
    }
}

/// Extends: `ImageMemoryBarrier`, `ImageMemoryBarrier2`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct SampleLocationsInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub sample_locations_per_pixel: SampleCountFlags,
    pub sample_location_grid_size: Extent2D,
    pub sample_locations_count: u32,
    /// Len: `sample_locations_count`
    pub sample_locations: *const SampleLocationEXT,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for SampleLocationsInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::SampleLocationsInfoEXT,
            next: ptr::null_mut(),
            sample_locations_per_pixel: Default::default(),
            sample_location_grid_size: Default::default(),
            sample_locations_count: 0,
            sample_locations: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsImageMemoryBarrier for SampleLocationsInfoEXT<'_> {}
impl ExtendsImageMemoryBarrier2 for SampleLocationsInfoEXT<'_> {}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct AttachmentSampleLocationsEXT<'a> {
    pub attachment_index: u32,
    pub sample_locations_info: SampleLocationsInfoEXT<'a>,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for AttachmentSampleLocationsEXT<'_> {
    fn default() -> Self {
        Self {
            attachment_index: 0,
            sample_locations_info: Default::default(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct SubpassSampleLocationsEXT<'a> {
    pub subpass_index: u32,
    pub sample_locations_info: SampleLocationsInfoEXT<'a>,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for SubpassSampleLocationsEXT<'_> {
    fn default() -> Self {
        Self {
            subpass_index: 0,
            sample_locations_info: Default::default(),
            _marker: PhantomData,
        }
    }
}

/// Extends: `RenderPassBeginInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct RenderPassSampleLocationsBeginInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub attachment_initial_sample_locations_count: u32,
    /// Len: `attachment_initial_sample_locations_count`
    pub attachment_initial_sample_locations: *const AttachmentSampleLocationsEXT<'a>,
    pub post_subpass_sample_locations_count: u32,
    /// Len: `post_subpass_sample_locations_count`
    pub post_subpass_sample_locations: *const SubpassSampleLocationsEXT<'a>,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for RenderPassSampleLocationsBeginInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::RenderPassSampleLocationsBeginInfoEXT,
            next: ptr::null_mut(),
            attachment_initial_sample_locations_count: 0,
            attachment_initial_sample_locations: ptr::null_mut(),
            post_subpass_sample_locations_count: 0,
            post_subpass_sample_locations: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsRenderPassBeginInfo for RenderPassSampleLocationsBeginInfoEXT<'_> {}

/// Extends: `PipelineMultisampleStateCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PipelineSampleLocationsStateCreateInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub sample_locations_enable: Bool32,
    pub sample_locations_info: SampleLocationsInfoEXT<'a>,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PipelineSampleLocationsStateCreateInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PipelineSampleLocationsStateCreateInfoEXT,
            next: ptr::null_mut(),
            sample_locations_enable: FALSE,
            sample_locations_info: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsPipelineMultisampleStateCreateInfo for PipelineSampleLocationsStateCreateInfoEXT<'_> {}

/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceSampleLocationsPropertiesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub sample_location_sample_counts: SampleCountFlags,
    pub max_sample_location_grid_size: Extent2D,
    pub sample_location_coordinate_range: [f32; 2],
    pub sample_location_sub_pixel_bits: u32,
    pub variable_sample_locations: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceSampleLocationsPropertiesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceSampleLocationsPropertiesEXT,
            next: ptr::null_mut(),
            sample_location_sample_counts: Default::default(),
            max_sample_location_grid_size: Default::default(),
            sample_location_coordinate_range: unsafe { mem::zeroed() },
            sample_location_sub_pixel_bits: 0,
            variable_sample_locations: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceSampleLocationsPropertiesEXT<'_> {}

/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct MultisamplePropertiesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub max_sample_location_grid_size: Extent2D,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for MultisamplePropertiesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::MultisamplePropertiesEXT,
            next: ptr::null_mut(),
            max_sample_location_grid_size: Default::default(),
            _marker: PhantomData,
        }
    }
}

/// Extends: `SamplerCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct SamplerReductionModeCreateInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub reduction_mode: SamplerReductionMode,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for SamplerReductionModeCreateInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::SamplerReductionModeCreateInfo,
            next: ptr::null_mut(),
            reduction_mode: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsSamplerCreateInfo for SamplerReductionModeCreateInfo<'_> {}

pub type SamplerReductionModeCreateInfoEXT<'a> = SamplerReductionModeCreateInfo<'a>;
/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceBlendOperationAdvancedFeaturesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub advanced_blend_coherent_operations: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceBlendOperationAdvancedFeaturesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceBlendOperationAdvancedFeaturesEXT,
            next: ptr::null_mut(),
            advanced_blend_coherent_operations: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceBlendOperationAdvancedFeaturesEXT<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceBlendOperationAdvancedFeaturesEXT<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceMultiDrawFeaturesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub multi_draw: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceMultiDrawFeaturesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceMultiDrawFeaturesEXT,
            next: ptr::null_mut(),
            multi_draw: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMultiDrawFeaturesEXT<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceMultiDrawFeaturesEXT<'_> {}

/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceBlendOperationAdvancedPropertiesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub advanced_blend_max_color_attachments: u32,
    pub advanced_blend_independent_blend: Bool32,
    pub advanced_blend_non_premultiplied_src_color: Bool32,
    pub advanced_blend_non_premultiplied_dst_color: Bool32,
    pub advanced_blend_correlated_overlap: Bool32,
    pub advanced_blend_all_operations: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceBlendOperationAdvancedPropertiesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceBlendOperationAdvancedPropertiesEXT,
            next: ptr::null_mut(),
            advanced_blend_max_color_attachments: 0,
            advanced_blend_independent_blend: FALSE,
            advanced_blend_non_premultiplied_src_color: FALSE,
            advanced_blend_non_premultiplied_dst_color: FALSE,
            advanced_blend_correlated_overlap: FALSE,
            advanced_blend_all_operations: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceBlendOperationAdvancedPropertiesEXT<'_> {}

/// Extends: `PipelineColorBlendStateCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PipelineColorBlendAdvancedStateCreateInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub src_premultiplied: Bool32,
    pub dst_premultiplied: Bool32,
    pub blend_overlap: BlendOverlapEXT,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PipelineColorBlendAdvancedStateCreateInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PipelineColorBlendAdvancedStateCreateInfoEXT,
            next: ptr::null_mut(),
            src_premultiplied: FALSE,
            dst_premultiplied: FALSE,
            blend_overlap: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsPipelineColorBlendStateCreateInfo for PipelineColorBlendAdvancedStateCreateInfoEXT<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceInlineUniformBlockFeatures<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub inline_uniform_block: Bool32,
    pub descriptor_binding_inline_uniform_block_update_after_bind: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceInlineUniformBlockFeatures<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceInlineUniformBlockFeatures,
            next: ptr::null_mut(),
            inline_uniform_block: FALSE,
            descriptor_binding_inline_uniform_block_update_after_bind: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceInlineUniformBlockFeatures<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceInlineUniformBlockFeatures<'_> {}

pub type PhysicalDeviceInlineUniformBlockFeaturesEXT<'a> =
    PhysicalDeviceInlineUniformBlockFeatures<'a>;
/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceInlineUniformBlockProperties<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub max_inline_uniform_block_size: u32,
    pub max_per_stage_descriptor_inline_uniform_blocks: u32,
    pub max_per_stage_descriptor_update_after_bind_inline_uniform_blocks: u32,
    pub max_descriptor_set_inline_uniform_blocks: u32,
    pub max_descriptor_set_update_after_bind_inline_uniform_blocks: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceInlineUniformBlockProperties<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceInlineUniformBlockProperties,
            next: ptr::null_mut(),
            max_inline_uniform_block_size: 0,
            max_per_stage_descriptor_inline_uniform_blocks: 0,
            max_per_stage_descriptor_update_after_bind_inline_uniform_blocks: 0,
            max_descriptor_set_inline_uniform_blocks: 0,
            max_descriptor_set_update_after_bind_inline_uniform_blocks: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceInlineUniformBlockProperties<'_> {}

pub type PhysicalDeviceInlineUniformBlockPropertiesEXT<'a> =
    PhysicalDeviceInlineUniformBlockProperties<'a>;
/// Extends: `WriteDescriptorSet`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct WriteDescriptorSetInlineUniformBlock<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub data_size: u32,
    /// Len: `data_size`
    pub data: *const c_void,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for WriteDescriptorSetInlineUniformBlock<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::WriteDescriptorSetInlineUniformBlock,
            next: ptr::null_mut(),
            data_size: 0,
            data: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsWriteDescriptorSet for WriteDescriptorSetInlineUniformBlock<'_> {}

pub type WriteDescriptorSetInlineUniformBlockEXT<'a> = WriteDescriptorSetInlineUniformBlock<'a>;
/// Extends: `DescriptorPoolCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DescriptorPoolInlineUniformBlockCreateInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub max_inline_uniform_block_bindings: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for DescriptorPoolInlineUniformBlockCreateInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::DescriptorPoolInlineUniformBlockCreateInfo,
            next: ptr::null_mut(),
            max_inline_uniform_block_bindings: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsDescriptorPoolCreateInfo for DescriptorPoolInlineUniformBlockCreateInfo<'_> {}

pub type DescriptorPoolInlineUniformBlockCreateInfoEXT<'a> =
    DescriptorPoolInlineUniformBlockCreateInfo<'a>;
/// Extends: `PipelineMultisampleStateCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PipelineCoverageModulationStateCreateInfoNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub flags: PipelineCoverageModulationStateCreateFlagsNV,
    pub coverage_modulation_mode: CoverageModulationModeNV,
    pub coverage_modulation_table_enable: Bool32,
    pub coverage_modulation_table_count: u32,
    /// Nullable
    /// Len: `coverage_modulation_table_count`
    pub coverage_modulation_table: *const f32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PipelineCoverageModulationStateCreateInfoNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PipelineCoverageModulationStateCreateInfoNV,
            next: ptr::null_mut(),
            flags: Default::default(),
            coverage_modulation_mode: Default::default(),
            coverage_modulation_table_enable: FALSE,
            coverage_modulation_table_count: 0,
            coverage_modulation_table: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsPipelineMultisampleStateCreateInfo for PipelineCoverageModulationStateCreateInfoNV<'_> {}

/// Extends: `ImageCreateInfo`, `SwapchainCreateInfoKHR`, `PhysicalDeviceImageFormatInfo2`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ImageFormatListCreateInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub view_format_count: u32,
    /// Len: `view_format_count`
    pub view_formats: *const Format,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ImageFormatListCreateInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ImageFormatListCreateInfo,
            next: ptr::null_mut(),
            view_format_count: 0,
            view_formats: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsImageCreateInfo for ImageFormatListCreateInfo<'_> {}
impl ExtendsSwapchainCreateInfoKHR for ImageFormatListCreateInfo<'_> {}
impl ExtendsPhysicalDeviceImageFormatInfo2 for ImageFormatListCreateInfo<'_> {}

pub type ImageFormatListCreateInfoKHR<'a> = ImageFormatListCreateInfo<'a>;
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ValidationCacheCreateInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub flags: ValidationCacheCreateFlagsEXT,
    pub initial_data_size: usize,
    /// Len: `initial_data_size`
    pub initial_data: *const c_void,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ValidationCacheCreateInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ValidationCacheCreateInfoEXT,
            next: ptr::null_mut(),
            flags: Default::default(),
            initial_data_size: 0,
            initial_data: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

/// Extends: `ShaderModuleCreateInfo`, `PipelineShaderStageCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ShaderModuleValidationCacheCreateInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub validation_cache: ValidationCacheEXT,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ShaderModuleValidationCacheCreateInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ShaderModuleValidationCacheCreateInfoEXT,
            next: ptr::null_mut(),
            validation_cache: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsShaderModuleCreateInfo for ShaderModuleValidationCacheCreateInfoEXT<'_> {}
impl ExtendsPipelineShaderStageCreateInfo for ShaderModuleValidationCacheCreateInfoEXT<'_> {}

/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceMaintenance3Properties<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub max_per_set_descriptors: u32,
    pub max_memory_allocation_size: DeviceSize,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceMaintenance3Properties<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceMaintenance3Properties,
            next: ptr::null_mut(),
            max_per_set_descriptors: 0,
            max_memory_allocation_size: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMaintenance3Properties<'_> {}

pub type PhysicalDeviceMaintenance3PropertiesKHR<'a> = PhysicalDeviceMaintenance3Properties<'a>;
/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceMaintenance4Features<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub maintenance4: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceMaintenance4Features<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceMaintenance4Features,
            next: ptr::null_mut(),
            maintenance4: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMaintenance4Features<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceMaintenance4Features<'_> {}

pub type PhysicalDeviceMaintenance4FeaturesKHR<'a> = PhysicalDeviceMaintenance4Features<'a>;
/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceMaintenance4Properties<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub max_buffer_size: DeviceSize,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceMaintenance4Properties<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceMaintenance4Properties,
            next: ptr::null_mut(),
            max_buffer_size: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMaintenance4Properties<'_> {}

pub type PhysicalDeviceMaintenance4PropertiesKHR<'a> = PhysicalDeviceMaintenance4Properties<'a>;
/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceMaintenance5Features<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub maintenance5: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceMaintenance5Features<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceMaintenance5Features,
            next: ptr::null_mut(),
            maintenance5: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMaintenance5Features<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceMaintenance5Features<'_> {}

pub type PhysicalDeviceMaintenance5FeaturesKHR<'a> = PhysicalDeviceMaintenance5Features<'a>;
/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceMaintenance5Properties<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub early_fragment_multisample_coverage_after_sample_counting: Bool32,
    pub early_fragment_sample_mask_test_before_sample_counting: Bool32,
    pub depth_stencil_swizzle_one_support: Bool32,
    pub polygon_mode_point_size: Bool32,
    pub non_strict_single_pixel_wide_lines_use_parallelogram: Bool32,
    pub non_strict_wide_lines_use_parallelogram: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceMaintenance5Properties<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceMaintenance5Properties,
            next: ptr::null_mut(),
            early_fragment_multisample_coverage_after_sample_counting: FALSE,
            early_fragment_sample_mask_test_before_sample_counting: FALSE,
            depth_stencil_swizzle_one_support: FALSE,
            polygon_mode_point_size: FALSE,
            non_strict_single_pixel_wide_lines_use_parallelogram: FALSE,
            non_strict_wide_lines_use_parallelogram: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMaintenance5Properties<'_> {}

pub type PhysicalDeviceMaintenance5PropertiesKHR<'a> = PhysicalDeviceMaintenance5Properties<'a>;
/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceMaintenance6Features<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub maintenance6: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceMaintenance6Features<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceMaintenance6Features,
            next: ptr::null_mut(),
            maintenance6: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMaintenance6Features<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceMaintenance6Features<'_> {}

pub type PhysicalDeviceMaintenance6FeaturesKHR<'a> = PhysicalDeviceMaintenance6Features<'a>;
/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceMaintenance6Properties<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub block_texel_view_compatible_multiple_layers: Bool32,
    pub max_combined_image_sampler_descriptor_count: u32,
    pub fragment_shading_rate_clamp_combiner_inputs: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceMaintenance6Properties<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceMaintenance6Properties,
            next: ptr::null_mut(),
            block_texel_view_compatible_multiple_layers: FALSE,
            max_combined_image_sampler_descriptor_count: 0,
            fragment_shading_rate_clamp_combiner_inputs: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMaintenance6Properties<'_> {}

pub type PhysicalDeviceMaintenance6PropertiesKHR<'a> = PhysicalDeviceMaintenance6Properties<'a>;
/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceMaintenance7FeaturesKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub maintenance7: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceMaintenance7FeaturesKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceMaintenance7FeaturesKHR,
            next: ptr::null_mut(),
            maintenance7: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMaintenance7FeaturesKHR<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceMaintenance7FeaturesKHR<'_> {}

/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceMaintenance7PropertiesKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub robust_fragment_shading_rate_attachment_access: Bool32,
    pub separate_depth_stencil_attachment_access: Bool32,
    pub max_descriptor_set_total_uniform_buffers_dynamic: u32,
    pub max_descriptor_set_total_storage_buffers_dynamic: u32,
    pub max_descriptor_set_total_buffers_dynamic: u32,
    pub max_descriptor_set_update_after_bind_total_uniform_buffers_dynamic: u32,
    pub max_descriptor_set_update_after_bind_total_storage_buffers_dynamic: u32,
    pub max_descriptor_set_update_after_bind_total_buffers_dynamic: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceMaintenance7PropertiesKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceMaintenance7PropertiesKHR,
            next: ptr::null_mut(),
            robust_fragment_shading_rate_attachment_access: FALSE,
            separate_depth_stencil_attachment_access: FALSE,
            max_descriptor_set_total_uniform_buffers_dynamic: 0,
            max_descriptor_set_total_storage_buffers_dynamic: 0,
            max_descriptor_set_total_buffers_dynamic: 0,
            max_descriptor_set_update_after_bind_total_uniform_buffers_dynamic: 0,
            max_descriptor_set_update_after_bind_total_storage_buffers_dynamic: 0,
            max_descriptor_set_update_after_bind_total_buffers_dynamic: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMaintenance7PropertiesKHR<'_> {}

/// Extends: `PhysicalDeviceProperties2`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceLayeredApiPropertiesListKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub layered_api_count: u32,
    /// Output list of layered implementations underneath the physical device
    /// Nullable
    /// Len: `layered_api_count`
    pub layered_apis: *mut PhysicalDeviceLayeredApiPropertiesKHR<'a>,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceLayeredApiPropertiesListKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceLayeredApiPropertiesListKHR,
            next: ptr::null_mut(),
            layered_api_count: 0,
            layered_apis: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceLayeredApiPropertiesListKHR<'_> {}

/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceLayeredApiPropertiesKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub vendor_id: u32,
    pub device_id: u32,
    pub layered_api: PhysicalDeviceLayeredApiKHR,
    pub device_name: [c_char; MAX_PHYSICAL_DEVICE_NAME_SIZE as usize],
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceLayeredApiPropertiesKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceLayeredApiPropertiesKHR,
            next: ptr::null_mut(),
            vendor_id: 0,
            device_id: 0,
            layered_api: Default::default(),
            device_name: unsafe { mem::zeroed() },
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsPhysicalDeviceLayeredApiPropertiesKHR {}
impl<'a> PhysicalDeviceLayeredApiPropertiesKHR<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsPhysicalDeviceLayeredApiPropertiesKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

/// Extends: `PhysicalDeviceLayeredApiPropertiesKHR`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceLayeredApiVulkanPropertiesKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub properties: PhysicalDeviceProperties2<'a>,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceLayeredApiVulkanPropertiesKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceLayeredApiVulkanPropertiesKHR,
            next: ptr::null_mut(),
            properties: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceLayeredApiPropertiesKHR
    for PhysicalDeviceLayeredApiVulkanPropertiesKHR<'_>
{
}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceMaintenance8FeaturesKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub maintenance8: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceMaintenance8FeaturesKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceMaintenance8FeaturesKHR,
            next: ptr::null_mut(),
            maintenance8: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMaintenance8FeaturesKHR<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceMaintenance8FeaturesKHR<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceMaintenance9FeaturesKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub maintenance9: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceMaintenance9FeaturesKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceMaintenance9FeaturesKHR,
            next: ptr::null_mut(),
            maintenance9: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMaintenance9FeaturesKHR<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceMaintenance9FeaturesKHR<'_> {}

/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceMaintenance9PropertiesKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub image2_d_view_of3_d_sparse: Bool32,
    pub default_vertex_attribute_value: DefaultVertexAttributeValueKHR,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceMaintenance9PropertiesKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceMaintenance9PropertiesKHR,
            next: ptr::null_mut(),
            image2_d_view_of3_d_sparse: FALSE,
            default_vertex_attribute_value: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMaintenance9PropertiesKHR<'_> {}

/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceMaintenance10PropertiesKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub rgba4_opaque_black_swizzled: Bool32,
    pub resolve_srgb_format_applies_transfer_function: Bool32,
    pub resolve_srgb_format_supports_transfer_function_control: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceMaintenance10PropertiesKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceMaintenance10PropertiesKHR,
            next: ptr::null_mut(),
            rgba4_opaque_black_swizzled: FALSE,
            resolve_srgb_format_applies_transfer_function: FALSE,
            resolve_srgb_format_supports_transfer_function_control: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMaintenance10PropertiesKHR<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceMaintenance10FeaturesKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub maintenance10: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceMaintenance10FeaturesKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceMaintenance10FeaturesKHR,
            next: ptr::null_mut(),
            maintenance10: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMaintenance10FeaturesKHR<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceMaintenance10FeaturesKHR<'_> {}

/// Extends: `QueueFamilyProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct QueueFamilyOwnershipTransferPropertiesKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub optimal_image_transfer_to_queue_families: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for QueueFamilyOwnershipTransferPropertiesKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::QueueFamilyOwnershipTransferPropertiesKHR,
            next: ptr::null_mut(),
            optimal_image_transfer_to_queue_families: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsQueueFamilyProperties2 for QueueFamilyOwnershipTransferPropertiesKHR<'_> {}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct RenderingAreaInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub view_mask: u32,
    pub color_attachment_count: u32,
    /// Len: `color_attachment_count`
    pub color_attachment_formats: *const Format,
    pub depth_attachment_format: Format,
    pub stencil_attachment_format: Format,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for RenderingAreaInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::RenderingAreaInfo,
            next: ptr::null_mut(),
            view_mask: 0,
            color_attachment_count: 0,
            color_attachment_formats: ptr::null_mut(),
            depth_attachment_format: Default::default(),
            stencil_attachment_format: Default::default(),
            _marker: PhantomData,
        }
    }
}

pub type RenderingAreaInfoKHR<'a> = RenderingAreaInfo<'a>;
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DescriptorSetLayoutSupport<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub supported: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for DescriptorSetLayoutSupport<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::DescriptorSetLayoutSupport,
            next: ptr::null_mut(),
            supported: FALSE,
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsDescriptorSetLayoutSupport {}
impl<'a> DescriptorSetLayoutSupport<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsDescriptorSetLayoutSupport>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

pub type DescriptorSetLayoutSupportKHR<'a> = DescriptorSetLayoutSupport<'a>;
/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceShaderDrawParametersFeatures<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub shader_draw_parameters: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceShaderDrawParametersFeatures<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceShaderDrawParametersFeatures,
            next: ptr::null_mut(),
            shader_draw_parameters: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderDrawParametersFeatures<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderDrawParametersFeatures<'_> {}

pub type PhysicalDeviceShaderDrawParameterFeatures<'a> =
    PhysicalDeviceShaderDrawParametersFeatures<'a>;
/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceShaderFloat16Int8Features<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    /// 16-bit floats (halfs) in shaders
    pub shader_float16: Bool32,
    /// 8-bit integers in shaders
    pub shader_int8: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceShaderFloat16Int8Features<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceShaderFloat16Int8Features,
            next: ptr::null_mut(),
            shader_float16: FALSE,
            shader_int8: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderFloat16Int8Features<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderFloat16Int8Features<'_> {}

pub type PhysicalDeviceShaderFloat16Int8FeaturesKHR<'a> =
    PhysicalDeviceShaderFloat16Int8Features<'a>;
pub type PhysicalDeviceFloat16Int8FeaturesKHR<'a> = PhysicalDeviceShaderFloat16Int8Features<'a>;
/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceFloatControlsProperties<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub denorm_behavior_independence: ShaderFloatControlsIndependence,
    pub rounding_mode_independence: ShaderFloatControlsIndependence,
    /// An implementation can preserve signed zero, nan, inf
    pub shader_signed_zero_inf_nan_preserve_float16: Bool32,
    /// An implementation can preserve signed zero, nan, inf
    pub shader_signed_zero_inf_nan_preserve_float32: Bool32,
    /// An implementation can preserve signed zero, nan, inf
    pub shader_signed_zero_inf_nan_preserve_float64: Bool32,
    /// An implementation can preserve  denormals
    pub shader_denorm_preserve_float16: Bool32,
    /// An implementation can preserve  denormals
    pub shader_denorm_preserve_float32: Bool32,
    /// An implementation can preserve  denormals
    pub shader_denorm_preserve_float64: Bool32,
    /// An implementation can flush to zero  denormals
    pub shader_denorm_flush_to_zero_float16: Bool32,
    /// An implementation can flush to zero  denormals
    pub shader_denorm_flush_to_zero_float32: Bool32,
    /// An implementation can flush to zero  denormals
    pub shader_denorm_flush_to_zero_float64: Bool32,
    /// An implementation can support RTE
    pub shader_rounding_mode_rte_float16: Bool32,
    /// An implementation can support RTE
    pub shader_rounding_mode_rte_float32: Bool32,
    /// An implementation can support RTE
    pub shader_rounding_mode_rte_float64: Bool32,
    /// An implementation can support RTZ
    pub shader_rounding_mode_rtz_float16: Bool32,
    /// An implementation can support RTZ
    pub shader_rounding_mode_rtz_float32: Bool32,
    /// An implementation can support RTZ
    pub shader_rounding_mode_rtz_float64: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceFloatControlsProperties<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceFloatControlsProperties,
            next: ptr::null_mut(),
            denorm_behavior_independence: Default::default(),
            rounding_mode_independence: Default::default(),
            shader_signed_zero_inf_nan_preserve_float16: FALSE,
            shader_signed_zero_inf_nan_preserve_float32: FALSE,
            shader_signed_zero_inf_nan_preserve_float64: FALSE,
            shader_denorm_preserve_float16: FALSE,
            shader_denorm_preserve_float32: FALSE,
            shader_denorm_preserve_float64: FALSE,
            shader_denorm_flush_to_zero_float16: FALSE,
            shader_denorm_flush_to_zero_float32: FALSE,
            shader_denorm_flush_to_zero_float64: FALSE,
            shader_rounding_mode_rte_float16: FALSE,
            shader_rounding_mode_rte_float32: FALSE,
            shader_rounding_mode_rte_float64: FALSE,
            shader_rounding_mode_rtz_float16: FALSE,
            shader_rounding_mode_rtz_float32: FALSE,
            shader_rounding_mode_rtz_float64: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceFloatControlsProperties<'_> {}

pub type PhysicalDeviceFloatControlsPropertiesKHR<'a> = PhysicalDeviceFloatControlsProperties<'a>;
/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceHostQueryResetFeatures<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub host_query_reset: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceHostQueryResetFeatures<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceHostQueryResetFeatures,
            next: ptr::null_mut(),
            host_query_reset: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceHostQueryResetFeatures<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceHostQueryResetFeatures<'_> {}

pub type PhysicalDeviceHostQueryResetFeaturesEXT<'a> = PhysicalDeviceHostQueryResetFeatures<'a>;
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ShaderResourceUsageAMD {
    pub num_used_vgprs: u32,
    pub num_used_sgprs: u32,
    pub lds_size_per_local_work_group: u32,
    pub lds_usage_size_in_bytes: usize,
    pub scratch_mem_usage_in_bytes: usize,
}
impl Default for ShaderResourceUsageAMD {
    fn default() -> Self {
        Self {
            num_used_vgprs: 0,
            num_used_sgprs: 0,
            lds_size_per_local_work_group: 0,
            lds_usage_size_in_bytes: 0,
            scratch_mem_usage_in_bytes: 0,
        }
    }
}

/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ShaderStatisticsInfoAMD {
    pub shader_stage_mask: ShaderStageFlags,
    pub resource_usage: ShaderResourceUsageAMD,
    pub num_physical_vgprs: u32,
    pub num_physical_sgprs: u32,
    pub num_available_vgprs: u32,
    pub num_available_sgprs: u32,
    pub compute_work_group_size: [u32; 3],
}
impl Default for ShaderStatisticsInfoAMD {
    fn default() -> Self {
        Self {
            shader_stage_mask: Default::default(),
            resource_usage: Default::default(),
            num_physical_vgprs: 0,
            num_physical_sgprs: 0,
            num_available_vgprs: 0,
            num_available_sgprs: 0,
            compute_work_group_size: unsafe { mem::zeroed() },
        }
    }
}

/// Extends: `DeviceQueueCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DeviceQueueGlobalPriorityCreateInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub global_priority: QueueGlobalPriority,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for DeviceQueueGlobalPriorityCreateInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::DeviceQueueGlobalPriorityCreateInfo,
            next: ptr::null_mut(),
            global_priority: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsDeviceQueueCreateInfo for DeviceQueueGlobalPriorityCreateInfo<'_> {}

pub type DeviceQueueGlobalPriorityCreateInfoKHR<'a> = DeviceQueueGlobalPriorityCreateInfo<'a>;
pub type DeviceQueueGlobalPriorityCreateInfoEXT<'a> = DeviceQueueGlobalPriorityCreateInfo<'a>;
/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceGlobalPriorityQueryFeatures<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub global_priority_query: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceGlobalPriorityQueryFeatures<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceGlobalPriorityQueryFeatures,
            next: ptr::null_mut(),
            global_priority_query: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceGlobalPriorityQueryFeatures<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceGlobalPriorityQueryFeatures<'_> {}

pub type PhysicalDeviceGlobalPriorityQueryFeaturesKHR<'a> =
    PhysicalDeviceGlobalPriorityQueryFeatures<'a>;
pub type PhysicalDeviceGlobalPriorityQueryFeaturesEXT<'a> =
    PhysicalDeviceGlobalPriorityQueryFeatures<'a>;
/// Extends: `QueueFamilyProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct QueueFamilyGlobalPriorityProperties<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub priority_count: u32,
    /// Len: `priority_count`
    pub priorities: [QueueGlobalPriority; MAX_GLOBAL_PRIORITY_SIZE as usize],
    pub _marker: PhantomData<&'a ()>,
}
impl Default for QueueFamilyGlobalPriorityProperties<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::QueueFamilyGlobalPriorityProperties,
            next: ptr::null_mut(),
            priority_count: 0,
            priorities: unsafe { mem::zeroed() },
            _marker: PhantomData,
        }
    }
}

impl ExtendsQueueFamilyProperties2 for QueueFamilyGlobalPriorityProperties<'_> {}

pub type QueueFamilyGlobalPriorityPropertiesKHR<'a> = QueueFamilyGlobalPriorityProperties<'a>;
pub type QueueFamilyGlobalPriorityPropertiesEXT<'a> = QueueFamilyGlobalPriorityProperties<'a>;
/// Extends: `PipelineShaderStageCreateInfo`, `ResourceDescriptorInfoEXT`, `SamplerCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DebugUtilsObjectNameInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub object_type: ObjectType,
    pub object_handle: u64,
    /// Nullable
    /// Len: null-terminated
    pub object_name: *const c_char,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for DebugUtilsObjectNameInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::DebugUtilsObjectNameInfoEXT,
            next: ptr::null_mut(),
            object_type: Default::default(),
            object_handle: 0,
            object_name: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsPipelineShaderStageCreateInfo for DebugUtilsObjectNameInfoEXT<'_> {}
impl ExtendsResourceDescriptorInfoEXT for DebugUtilsObjectNameInfoEXT<'_> {}
impl ExtendsSamplerCreateInfo for DebugUtilsObjectNameInfoEXT<'_> {}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DebugUtilsObjectTagInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub object_type: ObjectType,
    pub object_handle: u64,
    pub tag_name: u64,
    pub tag_size: usize,
    /// Len: `tag_size`
    pub tag: *const c_void,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for DebugUtilsObjectTagInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::DebugUtilsObjectTagInfoEXT,
            next: ptr::null_mut(),
            object_type: Default::default(),
            object_handle: 0,
            tag_name: 0,
            tag_size: 0,
            tag: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DebugUtilsLabelEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    /// Len: null-terminated
    pub label_name: *const c_char,
    pub color: [f32; 4],
    pub _marker: PhantomData<&'a ()>,
}
impl Default for DebugUtilsLabelEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::DebugUtilsLabelEXT,
            next: ptr::null_mut(),
            label_name: ptr::null_mut(),
            color: unsafe { mem::zeroed() },
            _marker: PhantomData,
        }
    }
}

/// Extends: `InstanceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DebugUtilsMessengerCreateInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub flags: DebugUtilsMessengerCreateFlagsEXT,
    pub message_severity: DebugUtilsMessageSeverityFlagsEXT,
    pub message_type: DebugUtilsMessageTypeFlagsEXT,
    pub pfn_user_callback: PFN_vkDebugUtilsMessengerCallbackEXT,
    /// Nullable
    pub user_data: *mut c_void,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for DebugUtilsMessengerCreateInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::DebugUtilsMessengerCreateInfoEXT,
            next: ptr::null_mut(),
            flags: Default::default(),
            message_severity: Default::default(),
            message_type: Default::default(),
            pfn_user_callback: Default::default(),
            user_data: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsInstanceCreateInfo for DebugUtilsMessengerCreateInfoEXT<'_> {}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DebugUtilsMessengerCallbackDataEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub flags: DebugUtilsMessengerCallbackDataFlagsEXT,
    /// Nullable
    /// Len: null-terminated
    pub message_id_name: *const c_char,
    pub message_id_number: i32,
    /// Nullable
    /// Len: null-terminated
    pub message: *const c_char,
    pub queue_label_count: u32,
    /// Len: `queue_label_count`
    pub queue_labels: *const DebugUtilsLabelEXT<'a>,
    pub cmd_buf_label_count: u32,
    /// Len: `cmd_buf_label_count`
    pub cmd_buf_labels: *const DebugUtilsLabelEXT<'a>,
    pub object_count: u32,
    /// Len: `object_count`
    pub objects: *const DebugUtilsObjectNameInfoEXT<'a>,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for DebugUtilsMessengerCallbackDataEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::DebugUtilsMessengerCallbackDataEXT,
            next: ptr::null_mut(),
            flags: Default::default(),
            message_id_name: ptr::null_mut(),
            message_id_number: 0,
            message: ptr::null_mut(),
            queue_label_count: 0,
            queue_labels: ptr::null_mut(),
            cmd_buf_label_count: 0,
            cmd_buf_labels: ptr::null_mut(),
            object_count: 0,
            objects: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsDebugUtilsMessengerCallbackDataEXT {}
impl<'a> DebugUtilsMessengerCallbackDataEXT<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsDebugUtilsMessengerCallbackDataEXT>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceDeviceMemoryReportFeaturesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub device_memory_report: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceDeviceMemoryReportFeaturesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceDeviceMemoryReportFeaturesEXT,
            next: ptr::null_mut(),
            device_memory_report: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDeviceMemoryReportFeaturesEXT<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceDeviceMemoryReportFeaturesEXT<'_> {}

/// Extends: `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DeviceDeviceMemoryReportCreateInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub flags: DeviceMemoryReportFlagsEXT,
    pub pfn_user_callback: PFN_vkDeviceMemoryReportCallbackEXT,
    /// Nullable
    pub user_data: *mut c_void,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for DeviceDeviceMemoryReportCreateInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::DeviceDeviceMemoryReportCreateInfoEXT,
            next: ptr::null_mut(),
            flags: Default::default(),
            pfn_user_callback: Default::default(),
            user_data: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsDeviceCreateInfo for DeviceDeviceMemoryReportCreateInfoEXT<'_> {}

/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DeviceMemoryReportCallbackDataEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub flags: DeviceMemoryReportFlagsEXT,
    pub ty: DeviceMemoryReportEventTypeEXT,
    pub memory_object_id: u64,
    pub size: DeviceSize,
    pub object_type: ObjectType,
    pub object_handle: u64,
    pub heap_index: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for DeviceMemoryReportCallbackDataEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::DeviceMemoryReportCallbackDataEXT,
            next: ptr::null_mut(),
            flags: Default::default(),
            ty: Default::default(),
            memory_object_id: 0,
            size: Default::default(),
            object_type: Default::default(),
            object_handle: 0,
            heap_index: 0,
            _marker: PhantomData,
        }
    }
}

/// Extends: `MemoryAllocateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ImportMemoryHostPointerInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub handle_type: ExternalMemoryHandleTypeFlags,
    pub host_pointer: *mut c_void,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ImportMemoryHostPointerInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ImportMemoryHostPointerInfoEXT,
            next: ptr::null_mut(),
            handle_type: Default::default(),
            host_pointer: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsMemoryAllocateInfo for ImportMemoryHostPointerInfoEXT<'_> {}

/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct MemoryHostPointerPropertiesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub memory_type_bits: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for MemoryHostPointerPropertiesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::MemoryHostPointerPropertiesEXT,
            next: ptr::null_mut(),
            memory_type_bits: 0,
            _marker: PhantomData,
        }
    }
}

/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceExternalMemoryHostPropertiesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub min_imported_host_pointer_alignment: DeviceSize,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceExternalMemoryHostPropertiesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceExternalMemoryHostPropertiesEXT,
            next: ptr::null_mut(),
            min_imported_host_pointer_alignment: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceExternalMemoryHostPropertiesEXT<'_> {}

/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceConservativeRasterizationPropertiesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    /// The size in pixels the primitive is enlarged at each edge during conservative rasterization
    pub primitive_overestimation_size: f32,
    /// The maximum additional overestimation the client can specify in the pipeline state
    pub max_extra_primitive_overestimation_size: f32,
    /// The granularity of extra overestimation sizes the implementations supports between 0 and maxExtraOverestimationSize
    pub extra_primitive_overestimation_size_granularity: f32,
    /// true if the implementation supports conservative rasterization underestimation mode
    pub primitive_underestimation: Bool32,
    /// true if conservative rasterization also applies to points and lines
    pub conservative_point_and_line_rasterization: Bool32,
    /// true if degenerate triangles (those with zero area after snap) are rasterized
    pub degenerate_triangles_rasterized: Bool32,
    /// true if degenerate lines (those with zero length after snap) are rasterized
    pub degenerate_lines_rasterized: Bool32,
    /// true if the implementation supports the FullyCoveredEXT SPIR-V builtin fragment shader input variable
    pub fully_covered_fragment_shader_input_variable: Bool32,
    /// true if the implementation supports both conservative rasterization and post depth coverage sample coverage mask
    pub conservative_rasterization_post_depth_coverage: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceConservativeRasterizationPropertiesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceConservativeRasterizationPropertiesEXT,
            next: ptr::null_mut(),
            primitive_overestimation_size: 0.0,
            max_extra_primitive_overestimation_size: 0.0,
            extra_primitive_overestimation_size_granularity: 0.0,
            primitive_underestimation: FALSE,
            conservative_point_and_line_rasterization: FALSE,
            degenerate_triangles_rasterized: FALSE,
            degenerate_lines_rasterized: FALSE,
            fully_covered_fragment_shader_input_variable: FALSE,
            conservative_rasterization_post_depth_coverage: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceConservativeRasterizationPropertiesEXT<'_> {}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct CalibratedTimestampInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub time_domain: TimeDomainKHR,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for CalibratedTimestampInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::CalibratedTimestampInfoKHR,
            next: ptr::null_mut(),
            time_domain: Default::default(),
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsCalibratedTimestampInfoKHR {}
impl<'a> CalibratedTimestampInfoKHR<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsCalibratedTimestampInfoKHR>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

pub type CalibratedTimestampInfoEXT<'a> = CalibratedTimestampInfoKHR<'a>;
/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceShaderCorePropertiesAMD<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    /// number of shader engines
    pub shader_engine_count: u32,
    /// number of shader arrays
    pub shader_arrays_per_engine_count: u32,
    /// number of physical CUs per shader array
    pub compute_units_per_shader_array: u32,
    /// number of SIMDs per compute unit
    pub simd_per_compute_unit: u32,
    /// number of wavefront slots in each SIMD
    pub wavefronts_per_simd: u32,
    /// maximum number of threads per wavefront
    pub wavefront_size: u32,
    /// number of physical SGPRs per SIMD
    pub sgprs_per_simd: u32,
    /// minimum number of SGPRs that can be allocated by a wave
    pub min_sgpr_allocation: u32,
    /// number of available SGPRs
    pub max_sgpr_allocation: u32,
    /// SGPRs are allocated in groups of this size
    pub sgpr_allocation_granularity: u32,
    /// number of physical VGPRs per SIMD
    pub vgprs_per_simd: u32,
    /// minimum number of VGPRs that can be allocated by a wave
    pub min_vgpr_allocation: u32,
    /// number of available VGPRs
    pub max_vgpr_allocation: u32,
    /// VGPRs are allocated in groups of this size
    pub vgpr_allocation_granularity: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceShaderCorePropertiesAMD<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceShaderCorePropertiesAMD,
            next: ptr::null_mut(),
            shader_engine_count: 0,
            shader_arrays_per_engine_count: 0,
            compute_units_per_shader_array: 0,
            simd_per_compute_unit: 0,
            wavefronts_per_simd: 0,
            wavefront_size: 0,
            sgprs_per_simd: 0,
            min_sgpr_allocation: 0,
            max_sgpr_allocation: 0,
            sgpr_allocation_granularity: 0,
            vgprs_per_simd: 0,
            min_vgpr_allocation: 0,
            max_vgpr_allocation: 0,
            vgpr_allocation_granularity: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceShaderCorePropertiesAMD<'_> {}

/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceShaderCoreProperties2AMD<'a> {
    pub s_type: StructureType,
    /// Pointer to next structure
    /// Nullable
    pub next: *mut c_void,
    /// features supported by the shader core
    pub shader_core_features: ShaderCorePropertiesFlagsAMD,
    /// number of active compute units across all shader engines/arrays
    pub active_compute_unit_count: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceShaderCoreProperties2AMD<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceShaderCoreProperties2AMD,
            next: ptr::null_mut(),
            shader_core_features: Default::default(),
            active_compute_unit_count: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceShaderCoreProperties2AMD<'_> {}

/// Extends: `PipelineRasterizationStateCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PipelineRasterizationConservativeStateCreateInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    /// Reserved
    pub flags: PipelineRasterizationConservativeStateCreateFlagsEXT,
    /// Conservative rasterization mode
    pub conservative_rasterization_mode: ConservativeRasterizationModeEXT,
    /// Extra overestimation to add to the primitive
    pub extra_primitive_overestimation_size: f32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PipelineRasterizationConservativeStateCreateInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PipelineRasterizationConservativeStateCreateInfoEXT,
            next: ptr::null_mut(),
            flags: Default::default(),
            conservative_rasterization_mode: Default::default(),
            extra_primitive_overestimation_size: 0.0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPipelineRasterizationStateCreateInfo
    for PipelineRasterizationConservativeStateCreateInfoEXT<'_>
{
}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceDescriptorIndexingFeatures<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub shader_input_attachment_array_dynamic_indexing: Bool32,
    pub shader_uniform_texel_buffer_array_dynamic_indexing: Bool32,
    pub shader_storage_texel_buffer_array_dynamic_indexing: Bool32,
    pub shader_uniform_buffer_array_non_uniform_indexing: Bool32,
    pub shader_sampled_image_array_non_uniform_indexing: Bool32,
    pub shader_storage_buffer_array_non_uniform_indexing: Bool32,
    pub shader_storage_image_array_non_uniform_indexing: Bool32,
    pub shader_input_attachment_array_non_uniform_indexing: Bool32,
    pub shader_uniform_texel_buffer_array_non_uniform_indexing: Bool32,
    pub shader_storage_texel_buffer_array_non_uniform_indexing: Bool32,
    pub descriptor_binding_uniform_buffer_update_after_bind: Bool32,
    pub descriptor_binding_sampled_image_update_after_bind: Bool32,
    pub descriptor_binding_storage_image_update_after_bind: Bool32,
    pub descriptor_binding_storage_buffer_update_after_bind: Bool32,
    pub descriptor_binding_uniform_texel_buffer_update_after_bind: Bool32,
    pub descriptor_binding_storage_texel_buffer_update_after_bind: Bool32,
    pub descriptor_binding_update_unused_while_pending: Bool32,
    pub descriptor_binding_partially_bound: Bool32,
    pub descriptor_binding_variable_descriptor_count: Bool32,
    pub runtime_descriptor_array: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceDescriptorIndexingFeatures<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceDescriptorIndexingFeatures,
            next: ptr::null_mut(),
            shader_input_attachment_array_dynamic_indexing: FALSE,
            shader_uniform_texel_buffer_array_dynamic_indexing: FALSE,
            shader_storage_texel_buffer_array_dynamic_indexing: FALSE,
            shader_uniform_buffer_array_non_uniform_indexing: FALSE,
            shader_sampled_image_array_non_uniform_indexing: FALSE,
            shader_storage_buffer_array_non_uniform_indexing: FALSE,
            shader_storage_image_array_non_uniform_indexing: FALSE,
            shader_input_attachment_array_non_uniform_indexing: FALSE,
            shader_uniform_texel_buffer_array_non_uniform_indexing: FALSE,
            shader_storage_texel_buffer_array_non_uniform_indexing: FALSE,
            descriptor_binding_uniform_buffer_update_after_bind: FALSE,
            descriptor_binding_sampled_image_update_after_bind: FALSE,
            descriptor_binding_storage_image_update_after_bind: FALSE,
            descriptor_binding_storage_buffer_update_after_bind: FALSE,
            descriptor_binding_uniform_texel_buffer_update_after_bind: FALSE,
            descriptor_binding_storage_texel_buffer_update_after_bind: FALSE,
            descriptor_binding_update_unused_while_pending: FALSE,
            descriptor_binding_partially_bound: FALSE,
            descriptor_binding_variable_descriptor_count: FALSE,
            runtime_descriptor_array: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDescriptorIndexingFeatures<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceDescriptorIndexingFeatures<'_> {}

pub type PhysicalDeviceDescriptorIndexingFeaturesEXT<'a> =
    PhysicalDeviceDescriptorIndexingFeatures<'a>;
/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceDescriptorIndexingProperties<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub max_update_after_bind_descriptors_in_all_pools: u32,
    pub shader_uniform_buffer_array_non_uniform_indexing_native: Bool32,
    pub shader_sampled_image_array_non_uniform_indexing_native: Bool32,
    pub shader_storage_buffer_array_non_uniform_indexing_native: Bool32,
    pub shader_storage_image_array_non_uniform_indexing_native: Bool32,
    pub shader_input_attachment_array_non_uniform_indexing_native: Bool32,
    pub robust_buffer_access_update_after_bind: Bool32,
    pub quad_divergent_implicit_lod: Bool32,
    pub max_per_stage_descriptor_update_after_bind_samplers: u32,
    pub max_per_stage_descriptor_update_after_bind_uniform_buffers: u32,
    pub max_per_stage_descriptor_update_after_bind_storage_buffers: u32,
    pub max_per_stage_descriptor_update_after_bind_sampled_images: u32,
    pub max_per_stage_descriptor_update_after_bind_storage_images: u32,
    pub max_per_stage_descriptor_update_after_bind_input_attachments: u32,
    pub max_per_stage_update_after_bind_resources: u32,
    pub max_descriptor_set_update_after_bind_samplers: u32,
    pub max_descriptor_set_update_after_bind_uniform_buffers: u32,
    pub max_descriptor_set_update_after_bind_uniform_buffers_dynamic: u32,
    pub max_descriptor_set_update_after_bind_storage_buffers: u32,
    pub max_descriptor_set_update_after_bind_storage_buffers_dynamic: u32,
    pub max_descriptor_set_update_after_bind_sampled_images: u32,
    pub max_descriptor_set_update_after_bind_storage_images: u32,
    pub max_descriptor_set_update_after_bind_input_attachments: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceDescriptorIndexingProperties<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceDescriptorIndexingProperties,
            next: ptr::null_mut(),
            max_update_after_bind_descriptors_in_all_pools: 0,
            shader_uniform_buffer_array_non_uniform_indexing_native: FALSE,
            shader_sampled_image_array_non_uniform_indexing_native: FALSE,
            shader_storage_buffer_array_non_uniform_indexing_native: FALSE,
            shader_storage_image_array_non_uniform_indexing_native: FALSE,
            shader_input_attachment_array_non_uniform_indexing_native: FALSE,
            robust_buffer_access_update_after_bind: FALSE,
            quad_divergent_implicit_lod: FALSE,
            max_per_stage_descriptor_update_after_bind_samplers: 0,
            max_per_stage_descriptor_update_after_bind_uniform_buffers: 0,
            max_per_stage_descriptor_update_after_bind_storage_buffers: 0,
            max_per_stage_descriptor_update_after_bind_sampled_images: 0,
            max_per_stage_descriptor_update_after_bind_storage_images: 0,
            max_per_stage_descriptor_update_after_bind_input_attachments: 0,
            max_per_stage_update_after_bind_resources: 0,
            max_descriptor_set_update_after_bind_samplers: 0,
            max_descriptor_set_update_after_bind_uniform_buffers: 0,
            max_descriptor_set_update_after_bind_uniform_buffers_dynamic: 0,
            max_descriptor_set_update_after_bind_storage_buffers: 0,
            max_descriptor_set_update_after_bind_storage_buffers_dynamic: 0,
            max_descriptor_set_update_after_bind_sampled_images: 0,
            max_descriptor_set_update_after_bind_storage_images: 0,
            max_descriptor_set_update_after_bind_input_attachments: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDescriptorIndexingProperties<'_> {}

pub type PhysicalDeviceDescriptorIndexingPropertiesEXT<'a> =
    PhysicalDeviceDescriptorIndexingProperties<'a>;
/// Extends: `DescriptorSetLayoutCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DescriptorSetLayoutBindingFlagsCreateInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub binding_count: u32,
    /// Nullable
    /// Len: `binding_count`
    pub binding_flags: *const DescriptorBindingFlags,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for DescriptorSetLayoutBindingFlagsCreateInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::DescriptorSetLayoutBindingFlagsCreateInfo,
            next: ptr::null_mut(),
            binding_count: 0,
            binding_flags: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsDescriptorSetLayoutCreateInfo for DescriptorSetLayoutBindingFlagsCreateInfo<'_> {}

pub type DescriptorSetLayoutBindingFlagsCreateInfoEXT<'a> =
    DescriptorSetLayoutBindingFlagsCreateInfo<'a>;
/// Extends: `DescriptorSetAllocateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DescriptorSetVariableDescriptorCountAllocateInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub descriptor_set_count: u32,
    /// Len: `descriptor_set_count`
    pub descriptor_counts: *const u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for DescriptorSetVariableDescriptorCountAllocateInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::DescriptorSetVariableDescriptorCountAllocateInfo,
            next: ptr::null_mut(),
            descriptor_set_count: 0,
            descriptor_counts: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsDescriptorSetAllocateInfo for DescriptorSetVariableDescriptorCountAllocateInfo<'_> {}

pub type DescriptorSetVariableDescriptorCountAllocateInfoEXT<'a> =
    DescriptorSetVariableDescriptorCountAllocateInfo<'a>;
/// Extends: `DescriptorSetLayoutSupport`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DescriptorSetVariableDescriptorCountLayoutSupport<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub max_variable_descriptor_count: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for DescriptorSetVariableDescriptorCountLayoutSupport<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::DescriptorSetVariableDescriptorCountLayoutSupport,
            next: ptr::null_mut(),
            max_variable_descriptor_count: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsDescriptorSetLayoutSupport for DescriptorSetVariableDescriptorCountLayoutSupport<'_> {}

pub type DescriptorSetVariableDescriptorCountLayoutSupportEXT<'a> =
    DescriptorSetVariableDescriptorCountLayoutSupport<'a>;
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct AttachmentDescription2<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub flags: AttachmentDescriptionFlags,
    pub format: Format,
    pub samples: SampleCountFlags,
    /// Load operation for color or depth data
    pub load_op: AttachmentLoadOp,
    /// Store operation for color or depth data
    pub store_op: AttachmentStoreOp,
    /// Load operation for stencil data
    pub stencil_load_op: AttachmentLoadOp,
    /// Store operation for stencil data
    pub stencil_store_op: AttachmentStoreOp,
    pub initial_layout: ImageLayout,
    pub final_layout: ImageLayout,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for AttachmentDescription2<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::AttachmentDescription2,
            next: ptr::null_mut(),
            flags: Default::default(),
            format: Default::default(),
            samples: Default::default(),
            load_op: Default::default(),
            store_op: Default::default(),
            stencil_load_op: Default::default(),
            stencil_store_op: Default::default(),
            initial_layout: Default::default(),
            final_layout: Default::default(),
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsAttachmentDescription2 {}
impl<'a> AttachmentDescription2<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsAttachmentDescription2>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

pub type AttachmentDescription2KHR<'a> = AttachmentDescription2<'a>;
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct AttachmentReference2<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub attachment: u32,
    pub layout: ImageLayout,
    pub aspect_mask: ImageAspectFlags,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for AttachmentReference2<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::AttachmentReference2,
            next: ptr::null_mut(),
            attachment: 0,
            layout: Default::default(),
            aspect_mask: Default::default(),
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsAttachmentReference2 {}
impl<'a> AttachmentReference2<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsAttachmentReference2>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

pub type AttachmentReference2KHR<'a> = AttachmentReference2<'a>;
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct SubpassDescription2<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub flags: SubpassDescriptionFlags,
    pub pipeline_bind_point: PipelineBindPoint,
    pub view_mask: u32,
    pub input_attachment_count: u32,
    /// Len: `input_attachment_count`
    pub input_attachments: *const AttachmentReference2<'a>,
    pub color_attachment_count: u32,
    /// Len: `color_attachment_count`
    pub color_attachments: *const AttachmentReference2<'a>,
    /// Nullable
    /// Len: `color_attachment_count`
    pub resolve_attachments: *const AttachmentReference2<'a>,
    /// Nullable
    pub depth_stencil_attachment: *const AttachmentReference2<'a>,
    pub preserve_attachment_count: u32,
    /// Len: `preserve_attachment_count`
    pub preserve_attachments: *const u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for SubpassDescription2<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::SubpassDescription2,
            next: ptr::null_mut(),
            flags: Default::default(),
            pipeline_bind_point: Default::default(),
            view_mask: 0,
            input_attachment_count: 0,
            input_attachments: ptr::null_mut(),
            color_attachment_count: 0,
            color_attachments: ptr::null_mut(),
            resolve_attachments: ptr::null_mut(),
            depth_stencil_attachment: ptr::null_mut(),
            preserve_attachment_count: 0,
            preserve_attachments: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsSubpassDescription2 {}
impl<'a> SubpassDescription2<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsSubpassDescription2>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

pub type SubpassDescription2KHR<'a> = SubpassDescription2<'a>;
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct SubpassDependency2<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub src_subpass: u32,
    pub dst_subpass: u32,
    pub src_stage_mask: PipelineStageFlags,
    pub dst_stage_mask: PipelineStageFlags,
    pub src_access_mask: AccessFlags,
    pub dst_access_mask: AccessFlags,
    pub dependency_flags: DependencyFlags,
    pub view_offset: i32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for SubpassDependency2<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::SubpassDependency2,
            next: ptr::null_mut(),
            src_subpass: 0,
            dst_subpass: 0,
            src_stage_mask: Default::default(),
            dst_stage_mask: Default::default(),
            src_access_mask: Default::default(),
            dst_access_mask: Default::default(),
            dependency_flags: Default::default(),
            view_offset: 0,
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsSubpassDependency2 {}
impl<'a> SubpassDependency2<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsSubpassDependency2>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

pub type SubpassDependency2KHR<'a> = SubpassDependency2<'a>;
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct RenderPassCreateInfo2<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub flags: RenderPassCreateFlags,
    pub attachment_count: u32,
    /// Len: `attachment_count`
    pub attachments: *const AttachmentDescription2<'a>,
    pub subpass_count: u32,
    /// Len: `subpass_count`
    pub subpasses: *const SubpassDescription2<'a>,
    pub dependency_count: u32,
    /// Len: `dependency_count`
    pub dependencies: *const SubpassDependency2<'a>,
    pub correlated_view_mask_count: u32,
    /// Len: `correlated_view_mask_count`
    pub correlated_view_masks: *const u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for RenderPassCreateInfo2<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::RenderPassCreateInfo2,
            next: ptr::null_mut(),
            flags: Default::default(),
            attachment_count: 0,
            attachments: ptr::null_mut(),
            subpass_count: 0,
            subpasses: ptr::null_mut(),
            dependency_count: 0,
            dependencies: ptr::null_mut(),
            correlated_view_mask_count: 0,
            correlated_view_masks: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsRenderPassCreateInfo2 {}
impl<'a> RenderPassCreateInfo2<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsRenderPassCreateInfo2>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

pub type RenderPassCreateInfo2KHR<'a> = RenderPassCreateInfo2<'a>;
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct SubpassBeginInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub contents: SubpassContents,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for SubpassBeginInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::SubpassBeginInfo,
            next: ptr::null_mut(),
            contents: Default::default(),
            _marker: PhantomData,
        }
    }
}

pub type SubpassBeginInfoKHR<'a> = SubpassBeginInfo<'a>;
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct SubpassEndInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for SubpassEndInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::SubpassEndInfo,
            next: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsSubpassEndInfo {}
impl<'a> SubpassEndInfo<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsSubpassEndInfo>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

pub type SubpassEndInfoKHR<'a> = SubpassEndInfo<'a>;
/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceTimelineSemaphoreFeatures<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub timeline_semaphore: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceTimelineSemaphoreFeatures<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceTimelineSemaphoreFeatures,
            next: ptr::null_mut(),
            timeline_semaphore: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceTimelineSemaphoreFeatures<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceTimelineSemaphoreFeatures<'_> {}

pub type PhysicalDeviceTimelineSemaphoreFeaturesKHR<'a> =
    PhysicalDeviceTimelineSemaphoreFeatures<'a>;
/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceTimelineSemaphoreProperties<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub max_timeline_semaphore_value_difference: u64,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceTimelineSemaphoreProperties<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceTimelineSemaphoreProperties,
            next: ptr::null_mut(),
            max_timeline_semaphore_value_difference: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceTimelineSemaphoreProperties<'_> {}

pub type PhysicalDeviceTimelineSemaphorePropertiesKHR<'a> =
    PhysicalDeviceTimelineSemaphoreProperties<'a>;
/// Extends: `SemaphoreCreateInfo`, `PhysicalDeviceExternalSemaphoreInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct SemaphoreTypeCreateInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub semaphore_type: SemaphoreType,
    pub initial_value: u64,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for SemaphoreTypeCreateInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::SemaphoreTypeCreateInfo,
            next: ptr::null_mut(),
            semaphore_type: Default::default(),
            initial_value: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsSemaphoreCreateInfo for SemaphoreTypeCreateInfo<'_> {}
impl ExtendsPhysicalDeviceExternalSemaphoreInfo for SemaphoreTypeCreateInfo<'_> {}

pub type SemaphoreTypeCreateInfoKHR<'a> = SemaphoreTypeCreateInfo<'a>;
/// Extends: `SubmitInfo`, `BindSparseInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct TimelineSemaphoreSubmitInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub wait_semaphore_value_count: u32,
    /// Nullable
    /// Len: `wait_semaphore_value_count`
    pub wait_semaphore_values: *const u64,
    pub signal_semaphore_value_count: u32,
    /// Nullable
    /// Len: `signal_semaphore_value_count`
    pub signal_semaphore_values: *const u64,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for TimelineSemaphoreSubmitInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::TimelineSemaphoreSubmitInfo,
            next: ptr::null_mut(),
            wait_semaphore_value_count: 0,
            wait_semaphore_values: ptr::null_mut(),
            signal_semaphore_value_count: 0,
            signal_semaphore_values: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsSubmitInfo for TimelineSemaphoreSubmitInfo<'_> {}
impl ExtendsBindSparseInfo for TimelineSemaphoreSubmitInfo<'_> {}

pub type TimelineSemaphoreSubmitInfoKHR<'a> = TimelineSemaphoreSubmitInfo<'a>;
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct SemaphoreWaitInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub flags: SemaphoreWaitFlags,
    pub semaphore_count: u32,
    /// Len: `semaphore_count`
    pub semaphores: *const Semaphore,
    /// Len: `semaphore_count`
    pub values: *const u64,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for SemaphoreWaitInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::SemaphoreWaitInfo,
            next: ptr::null_mut(),
            flags: Default::default(),
            semaphore_count: 0,
            semaphores: ptr::null_mut(),
            values: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

pub type SemaphoreWaitInfoKHR<'a> = SemaphoreWaitInfo<'a>;
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct SemaphoreSignalInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub semaphore: Semaphore,
    pub value: u64,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for SemaphoreSignalInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::SemaphoreSignalInfo,
            next: ptr::null_mut(),
            semaphore: Default::default(),
            value: 0,
            _marker: PhantomData,
        }
    }
}

pub type SemaphoreSignalInfoKHR<'a> = SemaphoreSignalInfo<'a>;
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VertexInputBindingDivisorDescription {
    pub binding: u32,
    pub divisor: u32,
}
impl Default for VertexInputBindingDivisorDescription {
    fn default() -> Self {
        Self {
            binding: 0,
            divisor: 0,
        }
    }
}

pub type VertexInputBindingDivisorDescriptionKHR = VertexInputBindingDivisorDescription;
pub type VertexInputBindingDivisorDescriptionEXT = VertexInputBindingDivisorDescription;
/// Extends: `PipelineVertexInputStateCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PipelineVertexInputDivisorStateCreateInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub vertex_binding_divisor_count: u32,
    /// Len: `vertex_binding_divisor_count`
    pub vertex_binding_divisors: *const VertexInputBindingDivisorDescription,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PipelineVertexInputDivisorStateCreateInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PipelineVertexInputDivisorStateCreateInfo,
            next: ptr::null_mut(),
            vertex_binding_divisor_count: 0,
            vertex_binding_divisors: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsPipelineVertexInputStateCreateInfo for PipelineVertexInputDivisorStateCreateInfo<'_> {}

pub type PipelineVertexInputDivisorStateCreateInfoKHR<'a> =
    PipelineVertexInputDivisorStateCreateInfo<'a>;
pub type PipelineVertexInputDivisorStateCreateInfoEXT<'a> =
    PipelineVertexInputDivisorStateCreateInfo<'a>;
/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceVertexAttributeDivisorPropertiesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    /// max value of vertex attribute divisor
    pub max_vertex_attrib_divisor: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceVertexAttributeDivisorPropertiesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceVertexAttributeDivisorPropertiesEXT,
            next: ptr::null_mut(),
            max_vertex_attrib_divisor: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceVertexAttributeDivisorPropertiesEXT<'_> {}

/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceVertexAttributeDivisorProperties<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    /// max value of vertex attribute divisor
    pub max_vertex_attrib_divisor: u32,
    pub supports_non_zero_first_instance: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceVertexAttributeDivisorProperties<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceVertexAttributeDivisorProperties,
            next: ptr::null_mut(),
            max_vertex_attrib_divisor: 0,
            supports_non_zero_first_instance: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceVertexAttributeDivisorProperties<'_> {}

pub type PhysicalDeviceVertexAttributeDivisorPropertiesKHR<'a> =
    PhysicalDeviceVertexAttributeDivisorProperties<'a>;
/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDevicePCIBusInfoPropertiesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub pci_domain: u32,
    pub pci_bus: u32,
    pub pci_device: u32,
    pub pci_function: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDevicePCIBusInfoPropertiesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDevicePCIBusInfoPropertiesEXT,
            next: ptr::null_mut(),
            pci_domain: 0,
            pci_bus: 0,
            pci_device: 0,
            pci_function: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2 for PhysicalDevicePCIBusInfoPropertiesEXT<'_> {}

/// Extends: `MemoryAllocateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ImportAndroidHardwareBufferInfoANDROID<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub buffer: *mut AHardwareBuffer,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ImportAndroidHardwareBufferInfoANDROID<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ImportAndroidHardwareBufferInfoANDROID,
            next: ptr::null_mut(),
            buffer: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsMemoryAllocateInfo for ImportAndroidHardwareBufferInfoANDROID<'_> {}

/// Extends: `ImageFormatProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct AndroidHardwareBufferUsageANDROID<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub android_hardware_buffer_usage: u64,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for AndroidHardwareBufferUsageANDROID<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::AndroidHardwareBufferUsageANDROID,
            next: ptr::null_mut(),
            android_hardware_buffer_usage: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsImageFormatProperties2 for AndroidHardwareBufferUsageANDROID<'_> {}

/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct AndroidHardwareBufferPropertiesANDROID<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub allocation_size: DeviceSize,
    pub memory_type_bits: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for AndroidHardwareBufferPropertiesANDROID<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::AndroidHardwareBufferPropertiesANDROID,
            next: ptr::null_mut(),
            allocation_size: Default::default(),
            memory_type_bits: 0,
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsAndroidHardwareBufferPropertiesANDROID {}
impl<'a> AndroidHardwareBufferPropertiesANDROID<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsAndroidHardwareBufferPropertiesANDROID>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct MemoryGetAndroidHardwareBufferInfoANDROID<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub memory: DeviceMemory,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for MemoryGetAndroidHardwareBufferInfoANDROID<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::MemoryGetAndroidHardwareBufferInfoANDROID,
            next: ptr::null_mut(),
            memory: Default::default(),
            _marker: PhantomData,
        }
    }
}

/// Extends: `AndroidHardwareBufferPropertiesANDROID`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct AndroidHardwareBufferFormatPropertiesANDROID<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub format: Format,
    pub external_format: u64,
    pub format_features: FormatFeatureFlags,
    pub sampler_ycbcr_conversion_components: ComponentMapping,
    pub suggested_ycbcr_model: SamplerYcbcrModelConversion,
    pub suggested_ycbcr_range: SamplerYcbcrRange,
    pub suggested_x_chroma_offset: ChromaLocation,
    pub suggested_y_chroma_offset: ChromaLocation,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for AndroidHardwareBufferFormatPropertiesANDROID<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::AndroidHardwareBufferFormatPropertiesANDROID,
            next: ptr::null_mut(),
            format: Default::default(),
            external_format: 0,
            format_features: Default::default(),
            sampler_ycbcr_conversion_components: Default::default(),
            suggested_ycbcr_model: Default::default(),
            suggested_ycbcr_range: Default::default(),
            suggested_x_chroma_offset: Default::default(),
            suggested_y_chroma_offset: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsAndroidHardwareBufferPropertiesANDROID
    for AndroidHardwareBufferFormatPropertiesANDROID<'_>
{
}

/// Extends: `CommandBufferInheritanceInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct CommandBufferInheritanceConditionalRenderingInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    /// Whether this secondary command buffer may be executed during an active conditional rendering
    pub conditional_rendering_enable: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for CommandBufferInheritanceConditionalRenderingInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::CommandBufferInheritanceConditionalRenderingInfoEXT,
            next: ptr::null_mut(),
            conditional_rendering_enable: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsCommandBufferInheritanceInfo
    for CommandBufferInheritanceConditionalRenderingInfoEXT<'_>
{
}

/// Extends: `ImageCreateInfo`, `SamplerYcbcrConversionCreateInfo`, `AttachmentDescription2`, `GraphicsPipelineCreateInfo`, `CommandBufferInheritanceInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ExternalFormatANDROID<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub external_format: u64,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ExternalFormatANDROID<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ExternalFormatANDROID,
            next: ptr::null_mut(),
            external_format: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsImageCreateInfo for ExternalFormatANDROID<'_> {}
impl ExtendsSamplerYcbcrConversionCreateInfo for ExternalFormatANDROID<'_> {}
impl ExtendsAttachmentDescription2 for ExternalFormatANDROID<'_> {}
impl ExtendsGraphicsPipelineCreateInfo for ExternalFormatANDROID<'_> {}
impl ExtendsCommandBufferInheritanceInfo for ExternalFormatANDROID<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDevice8BitStorageFeatures<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    /// 8-bit integer variables supported in StorageBuffer
    pub storage_buffer8_bit_access: Bool32,
    /// 8-bit integer variables supported in StorageBuffer and Uniform
    pub uniform_and_storage_buffer8_bit_access: Bool32,
    /// 8-bit integer variables supported in PushConstant
    pub storage_push_constant8: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDevice8BitStorageFeatures<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDevice8BitStorageFeatures,
            next: ptr::null_mut(),
            storage_buffer8_bit_access: FALSE,
            uniform_and_storage_buffer8_bit_access: FALSE,
            storage_push_constant8: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevice8BitStorageFeatures<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDevice8BitStorageFeatures<'_> {}

pub type PhysicalDevice8BitStorageFeaturesKHR<'a> = PhysicalDevice8BitStorageFeatures<'a>;
/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceConditionalRenderingFeaturesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub conditional_rendering: Bool32,
    pub inherited_conditional_rendering: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceConditionalRenderingFeaturesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceConditionalRenderingFeaturesEXT,
            next: ptr::null_mut(),
            conditional_rendering: FALSE,
            inherited_conditional_rendering: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceConditionalRenderingFeaturesEXT<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceConditionalRenderingFeaturesEXT<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceVulkanMemoryModelFeatures<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub vulkan_memory_model: Bool32,
    pub vulkan_memory_model_device_scope: Bool32,
    pub vulkan_memory_model_availability_visibility_chains: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceVulkanMemoryModelFeatures<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceVulkanMemoryModelFeatures,
            next: ptr::null_mut(),
            vulkan_memory_model: FALSE,
            vulkan_memory_model_device_scope: FALSE,
            vulkan_memory_model_availability_visibility_chains: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVulkanMemoryModelFeatures<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceVulkanMemoryModelFeatures<'_> {}

pub type PhysicalDeviceVulkanMemoryModelFeaturesKHR<'a> =
    PhysicalDeviceVulkanMemoryModelFeatures<'a>;
/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceShaderAtomicInt64Features<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub shader_buffer_int64_atomics: Bool32,
    pub shader_shared_int64_atomics: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceShaderAtomicInt64Features<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceShaderAtomicInt64Features,
            next: ptr::null_mut(),
            shader_buffer_int64_atomics: FALSE,
            shader_shared_int64_atomics: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderAtomicInt64Features<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderAtomicInt64Features<'_> {}

pub type PhysicalDeviceShaderAtomicInt64FeaturesKHR<'a> =
    PhysicalDeviceShaderAtomicInt64Features<'a>;
/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceShaderAtomicFloatFeaturesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub shader_buffer_float32_atomics: Bool32,
    pub shader_buffer_float32_atomic_add: Bool32,
    pub shader_buffer_float64_atomics: Bool32,
    pub shader_buffer_float64_atomic_add: Bool32,
    pub shader_shared_float32_atomics: Bool32,
    pub shader_shared_float32_atomic_add: Bool32,
    pub shader_shared_float64_atomics: Bool32,
    pub shader_shared_float64_atomic_add: Bool32,
    pub shader_image_float32_atomics: Bool32,
    pub shader_image_float32_atomic_add: Bool32,
    pub sparse_image_float32_atomics: Bool32,
    pub sparse_image_float32_atomic_add: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceShaderAtomicFloatFeaturesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceShaderAtomicFloatFeaturesEXT,
            next: ptr::null_mut(),
            shader_buffer_float32_atomics: FALSE,
            shader_buffer_float32_atomic_add: FALSE,
            shader_buffer_float64_atomics: FALSE,
            shader_buffer_float64_atomic_add: FALSE,
            shader_shared_float32_atomics: FALSE,
            shader_shared_float32_atomic_add: FALSE,
            shader_shared_float64_atomics: FALSE,
            shader_shared_float64_atomic_add: FALSE,
            shader_image_float32_atomics: FALSE,
            shader_image_float32_atomic_add: FALSE,
            sparse_image_float32_atomics: FALSE,
            sparse_image_float32_atomic_add: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderAtomicFloatFeaturesEXT<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderAtomicFloatFeaturesEXT<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceShaderAtomicFloat2FeaturesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub shader_buffer_float16_atomics: Bool32,
    pub shader_buffer_float16_atomic_add: Bool32,
    pub shader_buffer_float16_atomic_min_max: Bool32,
    pub shader_buffer_float32_atomic_min_max: Bool32,
    pub shader_buffer_float64_atomic_min_max: Bool32,
    pub shader_shared_float16_atomics: Bool32,
    pub shader_shared_float16_atomic_add: Bool32,
    pub shader_shared_float16_atomic_min_max: Bool32,
    pub shader_shared_float32_atomic_min_max: Bool32,
    pub shader_shared_float64_atomic_min_max: Bool32,
    pub shader_image_float32_atomic_min_max: Bool32,
    pub sparse_image_float32_atomic_min_max: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceShaderAtomicFloat2FeaturesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceShaderAtomicFloat2FeaturesEXT,
            next: ptr::null_mut(),
            shader_buffer_float16_atomics: FALSE,
            shader_buffer_float16_atomic_add: FALSE,
            shader_buffer_float16_atomic_min_max: FALSE,
            shader_buffer_float32_atomic_min_max: FALSE,
            shader_buffer_float64_atomic_min_max: FALSE,
            shader_shared_float16_atomics: FALSE,
            shader_shared_float16_atomic_add: FALSE,
            shader_shared_float16_atomic_min_max: FALSE,
            shader_shared_float32_atomic_min_max: FALSE,
            shader_shared_float64_atomic_min_max: FALSE,
            shader_image_float32_atomic_min_max: FALSE,
            sparse_image_float32_atomic_min_max: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderAtomicFloat2FeaturesEXT<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderAtomicFloat2FeaturesEXT<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceVertexAttributeDivisorFeatures<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub vertex_attribute_instance_rate_divisor: Bool32,
    pub vertex_attribute_instance_rate_zero_divisor: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceVertexAttributeDivisorFeatures<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceVertexAttributeDivisorFeatures,
            next: ptr::null_mut(),
            vertex_attribute_instance_rate_divisor: FALSE,
            vertex_attribute_instance_rate_zero_divisor: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVertexAttributeDivisorFeatures<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceVertexAttributeDivisorFeatures<'_> {}

pub type PhysicalDeviceVertexAttributeDivisorFeaturesKHR<'a> =
    PhysicalDeviceVertexAttributeDivisorFeatures<'a>;
pub type PhysicalDeviceVertexAttributeDivisorFeaturesEXT<'a> =
    PhysicalDeviceVertexAttributeDivisorFeatures<'a>;
/// Extends: `QueueFamilyProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct QueueFamilyCheckpointPropertiesNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub checkpoint_execution_stage_mask: PipelineStageFlags,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for QueueFamilyCheckpointPropertiesNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::QueueFamilyCheckpointPropertiesNV,
            next: ptr::null_mut(),
            checkpoint_execution_stage_mask: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsQueueFamilyProperties2 for QueueFamilyCheckpointPropertiesNV<'_> {}

/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct CheckpointDataNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub stage: PipelineStageFlags,
    pub checkpoint_marker: *mut c_void,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for CheckpointDataNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::CheckpointDataNV,
            next: ptr::null_mut(),
            stage: Default::default(),
            checkpoint_marker: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceDepthStencilResolveProperties<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    /// supported depth resolve modes
    pub supported_depth_resolve_modes: ResolveModeFlags,
    /// supported stencil resolve modes
    pub supported_stencil_resolve_modes: ResolveModeFlags,
    /// depth and stencil resolve modes can be set independently if one of them is none
    pub independent_resolve_none: Bool32,
    /// depth and stencil resolve modes can be set independently
    pub independent_resolve: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceDepthStencilResolveProperties<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceDepthStencilResolveProperties,
            next: ptr::null_mut(),
            supported_depth_resolve_modes: Default::default(),
            supported_stencil_resolve_modes: Default::default(),
            independent_resolve_none: FALSE,
            independent_resolve: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDepthStencilResolveProperties<'_> {}

pub type PhysicalDeviceDepthStencilResolvePropertiesKHR<'a> =
    PhysicalDeviceDepthStencilResolveProperties<'a>;
/// Extends: `SubpassDescription2`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct SubpassDescriptionDepthStencilResolve<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    /// depth resolve mode
    pub depth_resolve_mode: ResolveModeFlags,
    /// stencil resolve mode
    pub stencil_resolve_mode: ResolveModeFlags,
    /// depth/stencil resolve attachment
    /// Nullable
    pub depth_stencil_resolve_attachment: *const AttachmentReference2<'a>,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for SubpassDescriptionDepthStencilResolve<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::SubpassDescriptionDepthStencilResolve,
            next: ptr::null_mut(),
            depth_resolve_mode: Default::default(),
            stencil_resolve_mode: Default::default(),
            depth_stencil_resolve_attachment: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsSubpassDescription2 for SubpassDescriptionDepthStencilResolve<'_> {}

pub type SubpassDescriptionDepthStencilResolveKHR<'a> = SubpassDescriptionDepthStencilResolve<'a>;
/// Extends: `ImageViewCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ImageViewASTCDecodeModeEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub decode_mode: Format,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ImageViewASTCDecodeModeEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ImageViewASTCDecodeModeEXT,
            next: ptr::null_mut(),
            decode_mode: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsImageViewCreateInfo for ImageViewASTCDecodeModeEXT<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceASTCDecodeFeaturesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub decode_mode_shared_exponent: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceASTCDecodeFeaturesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceASTCDecodeFeaturesEXT,
            next: ptr::null_mut(),
            decode_mode_shared_exponent: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceASTCDecodeFeaturesEXT<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceASTCDecodeFeaturesEXT<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceTransformFeedbackFeaturesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub transform_feedback: Bool32,
    pub geometry_streams: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceTransformFeedbackFeaturesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceTransformFeedbackFeaturesEXT,
            next: ptr::null_mut(),
            transform_feedback: FALSE,
            geometry_streams: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceTransformFeedbackFeaturesEXT<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceTransformFeedbackFeaturesEXT<'_> {}

/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceTransformFeedbackPropertiesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub max_transform_feedback_streams: u32,
    pub max_transform_feedback_buffers: u32,
    pub max_transform_feedback_buffer_size: DeviceSize,
    pub max_transform_feedback_stream_data_size: u32,
    pub max_transform_feedback_buffer_data_size: u32,
    pub max_transform_feedback_buffer_data_stride: u32,
    pub transform_feedback_queries: Bool32,
    pub transform_feedback_streams_lines_triangles: Bool32,
    pub transform_feedback_rasterization_stream_select: Bool32,
    pub transform_feedback_draw: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceTransformFeedbackPropertiesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceTransformFeedbackPropertiesEXT,
            next: ptr::null_mut(),
            max_transform_feedback_streams: 0,
            max_transform_feedback_buffers: 0,
            max_transform_feedback_buffer_size: Default::default(),
            max_transform_feedback_stream_data_size: 0,
            max_transform_feedback_buffer_data_size: 0,
            max_transform_feedback_buffer_data_stride: 0,
            transform_feedback_queries: FALSE,
            transform_feedback_streams_lines_triangles: FALSE,
            transform_feedback_rasterization_stream_select: FALSE,
            transform_feedback_draw: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceTransformFeedbackPropertiesEXT<'_> {}

/// Extends: `PipelineRasterizationStateCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PipelineRasterizationStateStreamCreateInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub flags: PipelineRasterizationStateStreamCreateFlagsEXT,
    pub rasterization_stream: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PipelineRasterizationStateStreamCreateInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PipelineRasterizationStateStreamCreateInfoEXT,
            next: ptr::null_mut(),
            flags: Default::default(),
            rasterization_stream: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPipelineRasterizationStateCreateInfo
    for PipelineRasterizationStateStreamCreateInfoEXT<'_>
{
}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceRepresentativeFragmentTestFeaturesNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub representative_fragment_test: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceRepresentativeFragmentTestFeaturesNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceRepresentativeFragmentTestFeaturesNV,
            next: ptr::null_mut(),
            representative_fragment_test: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceRepresentativeFragmentTestFeaturesNV<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceRepresentativeFragmentTestFeaturesNV<'_> {}

/// Extends: `GraphicsPipelineCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PipelineRepresentativeFragmentTestStateCreateInfoNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub representative_fragment_test_enable: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PipelineRepresentativeFragmentTestStateCreateInfoNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PipelineRepresentativeFragmentTestStateCreateInfoNV,
            next: ptr::null_mut(),
            representative_fragment_test_enable: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsGraphicsPipelineCreateInfo for PipelineRepresentativeFragmentTestStateCreateInfoNV<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceExclusiveScissorFeaturesNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub exclusive_scissor: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceExclusiveScissorFeaturesNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceExclusiveScissorFeaturesNV,
            next: ptr::null_mut(),
            exclusive_scissor: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceExclusiveScissorFeaturesNV<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceExclusiveScissorFeaturesNV<'_> {}

/// Extends: `PipelineViewportStateCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PipelineViewportExclusiveScissorStateCreateInfoNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub exclusive_scissor_count: u32,
    /// Len: `exclusive_scissor_count`
    pub exclusive_scissors: *const Rect2D,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PipelineViewportExclusiveScissorStateCreateInfoNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PipelineViewportExclusiveScissorStateCreateInfoNV,
            next: ptr::null_mut(),
            exclusive_scissor_count: 0,
            exclusive_scissors: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsPipelineViewportStateCreateInfo
    for PipelineViewportExclusiveScissorStateCreateInfoNV<'_>
{
}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceCornerSampledImageFeaturesNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub corner_sampled_image: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceCornerSampledImageFeaturesNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceCornerSampledImageFeaturesNV,
            next: ptr::null_mut(),
            corner_sampled_image: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceCornerSampledImageFeaturesNV<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceCornerSampledImageFeaturesNV<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceComputeShaderDerivativesFeaturesKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub compute_derivative_group_quads: Bool32,
    pub compute_derivative_group_linear: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceComputeShaderDerivativesFeaturesKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceComputeShaderDerivativesFeaturesKHR,
            next: ptr::null_mut(),
            compute_derivative_group_quads: FALSE,
            compute_derivative_group_linear: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceComputeShaderDerivativesFeaturesKHR<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceComputeShaderDerivativesFeaturesKHR<'_> {}

pub type PhysicalDeviceComputeShaderDerivativesFeaturesNV<'a> =
    PhysicalDeviceComputeShaderDerivativesFeaturesKHR<'a>;
/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceComputeShaderDerivativesPropertiesKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub mesh_and_task_shader_derivatives: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceComputeShaderDerivativesPropertiesKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceComputeShaderDerivativesPropertiesKHR,
            next: ptr::null_mut(),
            mesh_and_task_shader_derivatives: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceComputeShaderDerivativesPropertiesKHR<'_> {}

pub type PhysicalDeviceFragmentShaderBarycentricFeaturesNV<'a> =
    PhysicalDeviceFragmentShaderBarycentricFeaturesKHR<'a>;
/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceShaderImageFootprintFeaturesNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub image_footprint: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceShaderImageFootprintFeaturesNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceShaderImageFootprintFeaturesNV,
            next: ptr::null_mut(),
            image_footprint: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderImageFootprintFeaturesNV<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderImageFootprintFeaturesNV<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub dedicated_allocation_image_aliasing: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV,
            next: ptr::null_mut(),
            dedicated_allocation_image_aliasing: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2
    for PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV<'_>
{
}
impl ExtendsDeviceCreateInfo for PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceCopyMemoryIndirectFeaturesKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub indirect_memory_copy: Bool32,
    pub indirect_memory_to_image_copy: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceCopyMemoryIndirectFeaturesKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceCopyMemoryIndirectFeaturesKHR,
            next: ptr::null_mut(),
            indirect_memory_copy: FALSE,
            indirect_memory_to_image_copy: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceCopyMemoryIndirectFeaturesKHR<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceCopyMemoryIndirectFeaturesKHR<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceCopyMemoryIndirectFeaturesNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub indirect_copy: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceCopyMemoryIndirectFeaturesNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceCopyMemoryIndirectFeaturesNV,
            next: ptr::null_mut(),
            indirect_copy: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceCopyMemoryIndirectFeaturesNV<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceCopyMemoryIndirectFeaturesNV<'_> {}

/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceCopyMemoryIndirectPropertiesKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    /// Bitmask of VkQueueFlagBits indicating the family of queues that support indirect copy
    pub supported_queues: QueueFlags,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceCopyMemoryIndirectPropertiesKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceCopyMemoryIndirectPropertiesKHR,
            next: ptr::null_mut(),
            supported_queues: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceCopyMemoryIndirectPropertiesKHR<'_> {}

pub type PhysicalDeviceCopyMemoryIndirectPropertiesNV<'a> =
    PhysicalDeviceCopyMemoryIndirectPropertiesKHR<'a>;
/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceMemoryDecompressionFeaturesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub memory_decompression: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceMemoryDecompressionFeaturesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceMemoryDecompressionFeaturesEXT,
            next: ptr::null_mut(),
            memory_decompression: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMemoryDecompressionFeaturesEXT<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceMemoryDecompressionFeaturesEXT<'_> {}

pub type PhysicalDeviceMemoryDecompressionFeaturesNV<'a> =
    PhysicalDeviceMemoryDecompressionFeaturesEXT<'a>;
/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceMemoryDecompressionPropertiesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub decompression_methods: MemoryDecompressionMethodFlagsEXT,
    pub max_decompression_indirect_count: u64,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceMemoryDecompressionPropertiesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceMemoryDecompressionPropertiesEXT,
            next: ptr::null_mut(),
            decompression_methods: Default::default(),
            max_decompression_indirect_count: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMemoryDecompressionPropertiesEXT<'_> {}

pub type PhysicalDeviceMemoryDecompressionPropertiesNV<'a> =
    PhysicalDeviceMemoryDecompressionPropertiesEXT<'a>;
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ShadingRatePaletteNV<'a> {
    pub shading_rate_palette_entry_count: u32,
    /// Len: `shading_rate_palette_entry_count`
    pub shading_rate_palette_entries: *const ShadingRatePaletteEntryNV,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ShadingRatePaletteNV<'_> {
    fn default() -> Self {
        Self {
            shading_rate_palette_entry_count: 0,
            shading_rate_palette_entries: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

/// Extends: `PipelineViewportStateCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PipelineViewportShadingRateImageStateCreateInfoNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub shading_rate_image_enable: Bool32,
    pub viewport_count: u32,
    /// Len: `viewport_count`
    pub shading_rate_palettes: *const ShadingRatePaletteNV<'a>,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PipelineViewportShadingRateImageStateCreateInfoNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PipelineViewportShadingRateImageStateCreateInfoNV,
            next: ptr::null_mut(),
            shading_rate_image_enable: FALSE,
            viewport_count: 0,
            shading_rate_palettes: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsPipelineViewportStateCreateInfo
    for PipelineViewportShadingRateImageStateCreateInfoNV<'_>
{
}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceShadingRateImageFeaturesNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub shading_rate_image: Bool32,
    pub shading_rate_coarse_sample_order: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceShadingRateImageFeaturesNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceShadingRateImageFeaturesNV,
            next: ptr::null_mut(),
            shading_rate_image: FALSE,
            shading_rate_coarse_sample_order: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShadingRateImageFeaturesNV<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceShadingRateImageFeaturesNV<'_> {}

/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceShadingRateImagePropertiesNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub shading_rate_texel_size: Extent2D,
    pub shading_rate_palette_size: u32,
    pub shading_rate_max_coarse_samples: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceShadingRateImagePropertiesNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceShadingRateImagePropertiesNV,
            next: ptr::null_mut(),
            shading_rate_texel_size: Default::default(),
            shading_rate_palette_size: 0,
            shading_rate_max_coarse_samples: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceShadingRateImagePropertiesNV<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceInvocationMaskFeaturesHUAWEI<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub invocation_mask: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceInvocationMaskFeaturesHUAWEI<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceInvocationMaskFeaturesHUAWEI,
            next: ptr::null_mut(),
            invocation_mask: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceInvocationMaskFeaturesHUAWEI<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceInvocationMaskFeaturesHUAWEI<'_> {}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct CoarseSampleLocationNV {
    pub pixel_x: u32,
    pub pixel_y: u32,
    pub sample: u32,
}
impl Default for CoarseSampleLocationNV {
    fn default() -> Self {
        Self {
            pixel_x: 0,
            pixel_y: 0,
            sample: 0,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct CoarseSampleOrderCustomNV<'a> {
    pub shading_rate: ShadingRatePaletteEntryNV,
    pub sample_count: u32,
    pub sample_location_count: u32,
    /// Len: `sample_location_count`
    pub sample_locations: *const CoarseSampleLocationNV,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for CoarseSampleOrderCustomNV<'_> {
    fn default() -> Self {
        Self {
            shading_rate: Default::default(),
            sample_count: 0,
            sample_location_count: 0,
            sample_locations: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

/// Extends: `PipelineViewportStateCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PipelineViewportCoarseSampleOrderStateCreateInfoNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub sample_order_type: CoarseSampleOrderTypeNV,
    pub custom_sample_order_count: u32,
    /// Len: `custom_sample_order_count`
    pub custom_sample_orders: *const CoarseSampleOrderCustomNV<'a>,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PipelineViewportCoarseSampleOrderStateCreateInfoNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PipelineViewportCoarseSampleOrderStateCreateInfoNV,
            next: ptr::null_mut(),
            sample_order_type: Default::default(),
            custom_sample_order_count: 0,
            custom_sample_orders: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsPipelineViewportStateCreateInfo
    for PipelineViewportCoarseSampleOrderStateCreateInfoNV<'_>
{
}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceMeshShaderFeaturesNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub task_shader: Bool32,
    pub mesh_shader: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceMeshShaderFeaturesNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceMeshShaderFeaturesNV,
            next: ptr::null_mut(),
            task_shader: FALSE,
            mesh_shader: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMeshShaderFeaturesNV<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceMeshShaderFeaturesNV<'_> {}

/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceMeshShaderPropertiesNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub max_draw_mesh_tasks_count: u32,
    pub max_task_work_group_invocations: u32,
    pub max_task_work_group_size: [u32; 3],
    pub max_task_total_memory_size: u32,
    pub max_task_output_count: u32,
    pub max_mesh_work_group_invocations: u32,
    pub max_mesh_work_group_size: [u32; 3],
    pub max_mesh_total_memory_size: u32,
    pub max_mesh_output_vertices: u32,
    pub max_mesh_output_primitives: u32,
    pub max_mesh_multiview_view_count: u32,
    pub mesh_output_per_vertex_granularity: u32,
    pub mesh_output_per_primitive_granularity: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceMeshShaderPropertiesNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceMeshShaderPropertiesNV,
            next: ptr::null_mut(),
            max_draw_mesh_tasks_count: 0,
            max_task_work_group_invocations: 0,
            max_task_work_group_size: unsafe { mem::zeroed() },
            max_task_total_memory_size: 0,
            max_task_output_count: 0,
            max_mesh_work_group_invocations: 0,
            max_mesh_work_group_size: unsafe { mem::zeroed() },
            max_mesh_total_memory_size: 0,
            max_mesh_output_vertices: 0,
            max_mesh_output_primitives: 0,
            max_mesh_multiview_view_count: 0,
            mesh_output_per_vertex_granularity: 0,
            mesh_output_per_primitive_granularity: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMeshShaderPropertiesNV<'_> {}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DrawMeshTasksIndirectCommandNV {
    pub task_count: u32,
    pub first_task: u32,
}
impl Default for DrawMeshTasksIndirectCommandNV {
    fn default() -> Self {
        Self {
            task_count: 0,
            first_task: 0,
        }
    }
}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceMeshShaderFeaturesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub task_shader: Bool32,
    pub mesh_shader: Bool32,
    pub multiview_mesh_shader: Bool32,
    pub primitive_fragment_shading_rate_mesh_shader: Bool32,
    pub mesh_shader_queries: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceMeshShaderFeaturesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceMeshShaderFeaturesEXT,
            next: ptr::null_mut(),
            task_shader: FALSE,
            mesh_shader: FALSE,
            multiview_mesh_shader: FALSE,
            primitive_fragment_shading_rate_mesh_shader: FALSE,
            mesh_shader_queries: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMeshShaderFeaturesEXT<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceMeshShaderFeaturesEXT<'_> {}

/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceMeshShaderPropertiesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub max_task_work_group_total_count: u32,
    pub max_task_work_group_count: [u32; 3],
    pub max_task_work_group_invocations: u32,
    pub max_task_work_group_size: [u32; 3],
    pub max_task_payload_size: u32,
    pub max_task_shared_memory_size: u32,
    pub max_task_payload_and_shared_memory_size: u32,
    pub max_mesh_work_group_total_count: u32,
    pub max_mesh_work_group_count: [u32; 3],
    pub max_mesh_work_group_invocations: u32,
    pub max_mesh_work_group_size: [u32; 3],
    pub max_mesh_shared_memory_size: u32,
    pub max_mesh_payload_and_shared_memory_size: u32,
    pub max_mesh_output_memory_size: u32,
    pub max_mesh_payload_and_output_memory_size: u32,
    pub max_mesh_output_components: u32,
    pub max_mesh_output_vertices: u32,
    pub max_mesh_output_primitives: u32,
    pub max_mesh_output_layers: u32,
    pub max_mesh_multiview_view_count: u32,
    pub mesh_output_per_vertex_granularity: u32,
    pub mesh_output_per_primitive_granularity: u32,
    pub max_preferred_task_work_group_invocations: u32,
    pub max_preferred_mesh_work_group_invocations: u32,
    pub prefers_local_invocation_vertex_output: Bool32,
    pub prefers_local_invocation_primitive_output: Bool32,
    pub prefers_compact_vertex_output: Bool32,
    pub prefers_compact_primitive_output: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceMeshShaderPropertiesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceMeshShaderPropertiesEXT,
            next: ptr::null_mut(),
            max_task_work_group_total_count: 0,
            max_task_work_group_count: unsafe { mem::zeroed() },
            max_task_work_group_invocations: 0,
            max_task_work_group_size: unsafe { mem::zeroed() },
            max_task_payload_size: 0,
            max_task_shared_memory_size: 0,
            max_task_payload_and_shared_memory_size: 0,
            max_mesh_work_group_total_count: 0,
            max_mesh_work_group_count: unsafe { mem::zeroed() },
            max_mesh_work_group_invocations: 0,
            max_mesh_work_group_size: unsafe { mem::zeroed() },
            max_mesh_shared_memory_size: 0,
            max_mesh_payload_and_shared_memory_size: 0,
            max_mesh_output_memory_size: 0,
            max_mesh_payload_and_output_memory_size: 0,
            max_mesh_output_components: 0,
            max_mesh_output_vertices: 0,
            max_mesh_output_primitives: 0,
            max_mesh_output_layers: 0,
            max_mesh_multiview_view_count: 0,
            mesh_output_per_vertex_granularity: 0,
            mesh_output_per_primitive_granularity: 0,
            max_preferred_task_work_group_invocations: 0,
            max_preferred_mesh_work_group_invocations: 0,
            prefers_local_invocation_vertex_output: FALSE,
            prefers_local_invocation_primitive_output: FALSE,
            prefers_compact_vertex_output: FALSE,
            prefers_compact_primitive_output: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMeshShaderPropertiesEXT<'_> {}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DrawMeshTasksIndirectCommandEXT {
    pub group_count_x: u32,
    pub group_count_y: u32,
    pub group_count_z: u32,
}
impl Default for DrawMeshTasksIndirectCommandEXT {
    fn default() -> Self {
        Self {
            group_count_x: 0,
            group_count_y: 0,
            group_count_z: 0,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct RayTracingShaderGroupCreateInfoNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub ty: RayTracingShaderGroupTypeKHR,
    pub general_shader: u32,
    pub closest_hit_shader: u32,
    pub any_hit_shader: u32,
    pub intersection_shader: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for RayTracingShaderGroupCreateInfoNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::RayTracingShaderGroupCreateInfoNV,
            next: ptr::null_mut(),
            ty: Default::default(),
            general_shader: 0,
            closest_hit_shader: 0,
            any_hit_shader: 0,
            intersection_shader: 0,
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct RayTracingShaderGroupCreateInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub ty: RayTracingShaderGroupTypeKHR,
    pub general_shader: u32,
    pub closest_hit_shader: u32,
    pub any_hit_shader: u32,
    pub intersection_shader: u32,
    /// Nullable
    pub shader_group_capture_replay_handle: *const c_void,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for RayTracingShaderGroupCreateInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::RayTracingShaderGroupCreateInfoKHR,
            next: ptr::null_mut(),
            ty: Default::default(),
            general_shader: 0,
            closest_hit_shader: 0,
            any_hit_shader: 0,
            intersection_shader: 0,
            shader_group_capture_replay_handle: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct RayTracingPipelineCreateInfoNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    /// Pipeline creation flags
    pub flags: PipelineCreateFlags,
    pub stage_count: u32,
    /// One entry for each active shader stage
    /// Len: `stage_count`
    pub stages: *const PipelineShaderStageCreateInfo<'a>,
    pub group_count: u32,
    /// Len: `group_count`
    pub groups: *const RayTracingShaderGroupCreateInfoNV<'a>,
    pub max_recursion_depth: u32,
    /// Interface layout of the pipeline
    pub layout: PipelineLayout,
    /// If VK_PIPELINE_CREATE_DERIVATIVE_BIT is set and this value is nonzero, it specifies the handle of the base pipeline this is a derivative of
    pub base_pipeline_handle: Pipeline,
    /// If VK_PIPELINE_CREATE_DERIVATIVE_BIT is set and this value is not -1, it specifies an index into pCreateInfos of the base pipeline this is a derivative of
    pub base_pipeline_index: i32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for RayTracingPipelineCreateInfoNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::RayTracingPipelineCreateInfoNV,
            next: ptr::null_mut(),
            flags: Default::default(),
            stage_count: 0,
            stages: ptr::null_mut(),
            group_count: 0,
            groups: ptr::null_mut(),
            max_recursion_depth: 0,
            layout: Default::default(),
            base_pipeline_handle: Default::default(),
            base_pipeline_index: 0,
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsRayTracingPipelineCreateInfoNV {}
impl<'a> RayTracingPipelineCreateInfoNV<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsRayTracingPipelineCreateInfoNV>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct RayTracingPipelineCreateInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    /// Pipeline creation flags
    pub flags: PipelineCreateFlags,
    pub stage_count: u32,
    /// One entry for each active shader stage
    /// Len: `stage_count`
    pub stages: *const PipelineShaderStageCreateInfo<'a>,
    pub group_count: u32,
    /// Len: `group_count`
    pub groups: *const RayTracingShaderGroupCreateInfoKHR<'a>,
    pub max_pipeline_ray_recursion_depth: u32,
    /// Nullable
    pub library_info: *const PipelineLibraryCreateInfoKHR<'a>,
    /// Nullable
    pub library_interface: *const RayTracingPipelineInterfaceCreateInfoKHR<'a>,
    /// Nullable
    pub dynamic_state: *const PipelineDynamicStateCreateInfo<'a>,
    /// Interface layout of the pipeline
    pub layout: PipelineLayout,
    /// If VK_PIPELINE_CREATE_DERIVATIVE_BIT is set and this value is nonzero, it specifies the handle of the base pipeline this is a derivative of
    pub base_pipeline_handle: Pipeline,
    /// If VK_PIPELINE_CREATE_DERIVATIVE_BIT is set and this value is not -1, it specifies an index into pCreateInfos of the base pipeline this is a derivative of
    pub base_pipeline_index: i32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for RayTracingPipelineCreateInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::RayTracingPipelineCreateInfoKHR,
            next: ptr::null_mut(),
            flags: Default::default(),
            stage_count: 0,
            stages: ptr::null_mut(),
            group_count: 0,
            groups: ptr::null_mut(),
            max_pipeline_ray_recursion_depth: 0,
            library_info: ptr::null_mut(),
            library_interface: ptr::null_mut(),
            dynamic_state: ptr::null_mut(),
            layout: Default::default(),
            base_pipeline_handle: Default::default(),
            base_pipeline_index: 0,
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsRayTracingPipelineCreateInfoKHR {}
impl<'a> RayTracingPipelineCreateInfoKHR<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsRayTracingPipelineCreateInfoKHR>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct GeometryTrianglesNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub vertex_data: Buffer,
    pub vertex_offset: DeviceSize,
    pub vertex_count: u32,
    pub vertex_stride: DeviceSize,
    pub vertex_format: Format,
    pub index_data: Buffer,
    pub index_offset: DeviceSize,
    pub index_count: u32,
    pub index_type: IndexType,
    /// Optional reference to array of floats representing a 3x4 row major affine transformation matrix.
    pub transform_data: Buffer,
    pub transform_offset: DeviceSize,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for GeometryTrianglesNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::GeometryTrianglesNV,
            next: ptr::null_mut(),
            vertex_data: Default::default(),
            vertex_offset: Default::default(),
            vertex_count: 0,
            vertex_stride: Default::default(),
            vertex_format: Default::default(),
            index_data: Default::default(),
            index_offset: Default::default(),
            index_count: 0,
            index_type: Default::default(),
            transform_data: Default::default(),
            transform_offset: Default::default(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct GeometryAABBNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub aabb_data: Buffer,
    pub num_aab_bs: u32,
    /// Stride in bytes between AABBs
    pub stride: u32,
    /// Offset in bytes of the first AABB in aabbData
    pub offset: DeviceSize,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for GeometryAABBNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::GeometryAABBNV,
            next: ptr::null_mut(),
            aabb_data: Default::default(),
            num_aab_bs: 0,
            stride: 0,
            offset: Default::default(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct GeometryDataNV<'a> {
    pub triangles: GeometryTrianglesNV<'a>,
    pub aabbs: GeometryAABBNV<'a>,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for GeometryDataNV<'_> {
    fn default() -> Self {
        Self {
            triangles: Default::default(),
            aabbs: Default::default(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct GeometryNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub geometry_type: GeometryTypeKHR,
    pub geometry: GeometryDataNV<'a>,
    pub flags: GeometryFlagsKHR,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for GeometryNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::GeometryNV,
            next: ptr::null_mut(),
            geometry_type: Default::default(),
            geometry: Default::default(),
            flags: Default::default(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct AccelerationStructureInfoNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub ty: AccelerationStructureTypeNV,
    pub flags: BuildAccelerationStructureFlagsNV,
    pub instance_count: u32,
    pub geometry_count: u32,
    /// Len: `geometry_count`
    pub geometries: *const GeometryNV<'a>,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for AccelerationStructureInfoNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::AccelerationStructureInfoNV,
            next: ptr::null_mut(),
            ty: Default::default(),
            flags: Default::default(),
            instance_count: 0,
            geometry_count: 0,
            geometries: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct AccelerationStructureCreateInfoNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub compacted_size: DeviceSize,
    pub info: AccelerationStructureInfoNV<'a>,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for AccelerationStructureCreateInfoNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::AccelerationStructureCreateInfoNV,
            next: ptr::null_mut(),
            compacted_size: Default::default(),
            info: Default::default(),
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsAccelerationStructureCreateInfoNV {}
impl<'a> AccelerationStructureCreateInfoNV<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsAccelerationStructureCreateInfoNV>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct BindAccelerationStructureMemoryInfoNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub acceleration_structure: AccelerationStructureNV,
    pub memory: DeviceMemory,
    pub memory_offset: DeviceSize,
    pub device_index_count: u32,
    /// Len: `device_index_count`
    pub device_indices: *const u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for BindAccelerationStructureMemoryInfoNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::BindAccelerationStructureMemoryInfoNV,
            next: ptr::null_mut(),
            acceleration_structure: Default::default(),
            memory: Default::default(),
            memory_offset: Default::default(),
            device_index_count: 0,
            device_indices: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

/// Extends: `WriteDescriptorSet`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct WriteDescriptorSetAccelerationStructureKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub acceleration_structure_count: u32,
    /// Nullable
    /// Len: `acceleration_structure_count`
    pub acceleration_structures: *const AccelerationStructureKHR,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for WriteDescriptorSetAccelerationStructureKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::WriteDescriptorSetAccelerationStructureKHR,
            next: ptr::null_mut(),
            acceleration_structure_count: 0,
            acceleration_structures: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsWriteDescriptorSet for WriteDescriptorSetAccelerationStructureKHR<'_> {}

/// Extends: `WriteDescriptorSet`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct WriteDescriptorSetAccelerationStructureNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub acceleration_structure_count: u32,
    /// Nullable
    /// Len: `acceleration_structure_count`
    pub acceleration_structures: *const AccelerationStructureNV,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for WriteDescriptorSetAccelerationStructureNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::WriteDescriptorSetAccelerationStructureNV,
            next: ptr::null_mut(),
            acceleration_structure_count: 0,
            acceleration_structures: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsWriteDescriptorSet for WriteDescriptorSetAccelerationStructureNV<'_> {}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct AccelerationStructureMemoryRequirementsInfoNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub ty: AccelerationStructureMemoryRequirementsTypeNV,
    pub acceleration_structure: AccelerationStructureNV,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for AccelerationStructureMemoryRequirementsInfoNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::AccelerationStructureMemoryRequirementsInfoNV,
            next: ptr::null_mut(),
            ty: Default::default(),
            acceleration_structure: Default::default(),
            _marker: PhantomData,
        }
    }
}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceAccelerationStructureFeaturesKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub acceleration_structure: Bool32,
    pub acceleration_structure_capture_replay: Bool32,
    pub acceleration_structure_indirect_build: Bool32,
    pub acceleration_structure_host_commands: Bool32,
    pub descriptor_binding_acceleration_structure_update_after_bind: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceAccelerationStructureFeaturesKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceAccelerationStructureFeaturesKHR,
            next: ptr::null_mut(),
            acceleration_structure: FALSE,
            acceleration_structure_capture_replay: FALSE,
            acceleration_structure_indirect_build: FALSE,
            acceleration_structure_host_commands: FALSE,
            descriptor_binding_acceleration_structure_update_after_bind: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceAccelerationStructureFeaturesKHR<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceAccelerationStructureFeaturesKHR<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceRayTracingPipelineFeaturesKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub ray_tracing_pipeline: Bool32,
    pub ray_tracing_pipeline_shader_group_handle_capture_replay: Bool32,
    pub ray_tracing_pipeline_shader_group_handle_capture_replay_mixed: Bool32,
    pub ray_tracing_pipeline_trace_rays_indirect: Bool32,
    pub ray_traversal_primitive_culling: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceRayTracingPipelineFeaturesKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceRayTracingPipelineFeaturesKHR,
            next: ptr::null_mut(),
            ray_tracing_pipeline: FALSE,
            ray_tracing_pipeline_shader_group_handle_capture_replay: FALSE,
            ray_tracing_pipeline_shader_group_handle_capture_replay_mixed: FALSE,
            ray_tracing_pipeline_trace_rays_indirect: FALSE,
            ray_traversal_primitive_culling: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceRayTracingPipelineFeaturesKHR<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceRayTracingPipelineFeaturesKHR<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceRayQueryFeaturesKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub ray_query: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceRayQueryFeaturesKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceRayQueryFeaturesKHR,
            next: ptr::null_mut(),
            ray_query: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceRayQueryFeaturesKHR<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceRayQueryFeaturesKHR<'_> {}

/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceAccelerationStructurePropertiesKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub max_geometry_count: u64,
    pub max_instance_count: u64,
    pub max_primitive_count: u64,
    pub max_per_stage_descriptor_acceleration_structures: u32,
    pub max_per_stage_descriptor_update_after_bind_acceleration_structures: u32,
    pub max_descriptor_set_acceleration_structures: u32,
    pub max_descriptor_set_update_after_bind_acceleration_structures: u32,
    pub min_acceleration_structure_scratch_offset_alignment: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceAccelerationStructurePropertiesKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceAccelerationStructurePropertiesKHR,
            next: ptr::null_mut(),
            max_geometry_count: 0,
            max_instance_count: 0,
            max_primitive_count: 0,
            max_per_stage_descriptor_acceleration_structures: 0,
            max_per_stage_descriptor_update_after_bind_acceleration_structures: 0,
            max_descriptor_set_acceleration_structures: 0,
            max_descriptor_set_update_after_bind_acceleration_structures: 0,
            min_acceleration_structure_scratch_offset_alignment: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceAccelerationStructurePropertiesKHR<'_> {}

/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceRayTracingPipelinePropertiesKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub shader_group_handle_size: u32,
    pub max_ray_recursion_depth: u32,
    pub max_shader_group_stride: u32,
    pub shader_group_base_alignment: u32,
    pub shader_group_handle_capture_replay_size: u32,
    pub max_ray_dispatch_invocation_count: u32,
    pub shader_group_handle_alignment: u32,
    pub max_ray_hit_attribute_size: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceRayTracingPipelinePropertiesKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceRayTracingPipelinePropertiesKHR,
            next: ptr::null_mut(),
            shader_group_handle_size: 0,
            max_ray_recursion_depth: 0,
            max_shader_group_stride: 0,
            shader_group_base_alignment: 0,
            shader_group_handle_capture_replay_size: 0,
            max_ray_dispatch_invocation_count: 0,
            shader_group_handle_alignment: 0,
            max_ray_hit_attribute_size: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceRayTracingPipelinePropertiesKHR<'_> {}

/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceRayTracingPropertiesNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub shader_group_handle_size: u32,
    pub max_recursion_depth: u32,
    pub max_shader_group_stride: u32,
    pub shader_group_base_alignment: u32,
    pub max_geometry_count: u64,
    pub max_instance_count: u64,
    pub max_triangle_count: u64,
    pub max_descriptor_set_acceleration_structures: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceRayTracingPropertiesNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceRayTracingPropertiesNV,
            next: ptr::null_mut(),
            shader_group_handle_size: 0,
            max_recursion_depth: 0,
            max_shader_group_stride: 0,
            shader_group_base_alignment: 0,
            max_geometry_count: 0,
            max_instance_count: 0,
            max_triangle_count: 0,
            max_descriptor_set_acceleration_structures: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceRayTracingPropertiesNV<'_> {}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct StridedDeviceAddressRegionKHR {
    pub device_address: DeviceAddress,
    pub stride: DeviceSize,
    pub size: DeviceSize,
}
impl Default for StridedDeviceAddressRegionKHR {
    fn default() -> Self {
        Self {
            device_address: Default::default(),
            stride: Default::default(),
            size: Default::default(),
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct TraceRaysIndirectCommandKHR {
    pub width: u32,
    pub height: u32,
    pub depth: u32,
}
impl Default for TraceRaysIndirectCommandKHR {
    fn default() -> Self {
        Self {
            width: 0,
            height: 0,
            depth: 0,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct TraceRaysIndirectCommand2KHR {
    pub raygen_shader_record_address: DeviceAddress,
    pub raygen_shader_record_size: DeviceSize,
    pub miss_shader_binding_table_address: DeviceAddress,
    pub miss_shader_binding_table_size: DeviceSize,
    pub miss_shader_binding_table_stride: DeviceSize,
    pub hit_shader_binding_table_address: DeviceAddress,
    pub hit_shader_binding_table_size: DeviceSize,
    pub hit_shader_binding_table_stride: DeviceSize,
    pub callable_shader_binding_table_address: DeviceAddress,
    pub callable_shader_binding_table_size: DeviceSize,
    pub callable_shader_binding_table_stride: DeviceSize,
    pub width: u32,
    pub height: u32,
    pub depth: u32,
}
impl Default for TraceRaysIndirectCommand2KHR {
    fn default() -> Self {
        Self {
            raygen_shader_record_address: Default::default(),
            raygen_shader_record_size: Default::default(),
            miss_shader_binding_table_address: Default::default(),
            miss_shader_binding_table_size: Default::default(),
            miss_shader_binding_table_stride: Default::default(),
            hit_shader_binding_table_address: Default::default(),
            hit_shader_binding_table_size: Default::default(),
            hit_shader_binding_table_stride: Default::default(),
            callable_shader_binding_table_address: Default::default(),
            callable_shader_binding_table_size: Default::default(),
            callable_shader_binding_table_stride: Default::default(),
            width: 0,
            height: 0,
            depth: 0,
        }
    }
}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceRayTracingMaintenance1FeaturesKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub ray_tracing_maintenance1: Bool32,
    pub ray_tracing_pipeline_trace_rays_indirect2: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceRayTracingMaintenance1FeaturesKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceRayTracingMaintenance1FeaturesKHR,
            next: ptr::null_mut(),
            ray_tracing_maintenance1: FALSE,
            ray_tracing_pipeline_trace_rays_indirect2: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceRayTracingMaintenance1FeaturesKHR<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceRayTracingMaintenance1FeaturesKHR<'_> {}

/// Extends: `FormatProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DrmFormatModifierPropertiesListEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub drm_format_modifier_count: u32,
    /// Nullable
    /// Len: `drm_format_modifier_count`
    pub drm_format_modifier_properties: *mut DrmFormatModifierPropertiesEXT,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for DrmFormatModifierPropertiesListEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::DrmFormatModifierPropertiesListEXT,
            next: ptr::null_mut(),
            drm_format_modifier_count: 0,
            drm_format_modifier_properties: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsFormatProperties2 for DrmFormatModifierPropertiesListEXT<'_> {}

/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DrmFormatModifierPropertiesEXT {
    pub drm_format_modifier: u64,
    pub drm_format_modifier_plane_count: u32,
    pub drm_format_modifier_tiling_features: FormatFeatureFlags,
}
impl Default for DrmFormatModifierPropertiesEXT {
    fn default() -> Self {
        Self {
            drm_format_modifier: 0,
            drm_format_modifier_plane_count: 0,
            drm_format_modifier_tiling_features: Default::default(),
        }
    }
}

/// Extends: `PhysicalDeviceImageFormatInfo2`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceImageDrmFormatModifierInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub drm_format_modifier: u64,
    pub sharing_mode: SharingMode,
    pub queue_family_index_count: u32,
    /// Len: `queue_family_index_count`
    pub queue_family_indices: *const u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceImageDrmFormatModifierInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceImageDrmFormatModifierInfoEXT,
            next: ptr::null_mut(),
            drm_format_modifier: 0,
            sharing_mode: Default::default(),
            queue_family_index_count: 0,
            queue_family_indices: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceImageFormatInfo2 for PhysicalDeviceImageDrmFormatModifierInfoEXT<'_> {}

/// Extends: `ImageCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ImageDrmFormatModifierListCreateInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub drm_format_modifier_count: u32,
    /// Len: `drm_format_modifier_count`
    pub drm_format_modifiers: *const u64,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ImageDrmFormatModifierListCreateInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ImageDrmFormatModifierListCreateInfoEXT,
            next: ptr::null_mut(),
            drm_format_modifier_count: 0,
            drm_format_modifiers: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsImageCreateInfo for ImageDrmFormatModifierListCreateInfoEXT<'_> {}

/// Extends: `ImageCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ImageDrmFormatModifierExplicitCreateInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub drm_format_modifier: u64,
    pub drm_format_modifier_plane_count: u32,
    /// Len: `drm_format_modifier_plane_count`
    pub plane_layouts: *const SubresourceLayout,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ImageDrmFormatModifierExplicitCreateInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ImageDrmFormatModifierExplicitCreateInfoEXT,
            next: ptr::null_mut(),
            drm_format_modifier: 0,
            drm_format_modifier_plane_count: 0,
            plane_layouts: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsImageCreateInfo for ImageDrmFormatModifierExplicitCreateInfoEXT<'_> {}

/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ImageDrmFormatModifierPropertiesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub drm_format_modifier: u64,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ImageDrmFormatModifierPropertiesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ImageDrmFormatModifierPropertiesEXT,
            next: ptr::null_mut(),
            drm_format_modifier: 0,
            _marker: PhantomData,
        }
    }
}

/// Extends: `ImageCreateInfo`, `PhysicalDeviceImageFormatInfo2`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ImageStencilUsageCreateInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub stencil_usage: ImageUsageFlags,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ImageStencilUsageCreateInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ImageStencilUsageCreateInfo,
            next: ptr::null_mut(),
            stencil_usage: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsImageCreateInfo for ImageStencilUsageCreateInfo<'_> {}
impl ExtendsPhysicalDeviceImageFormatInfo2 for ImageStencilUsageCreateInfo<'_> {}

pub type ImageStencilUsageCreateInfoEXT<'a> = ImageStencilUsageCreateInfo<'a>;
/// Extends: `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DeviceMemoryOverallocationCreateInfoAMD<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub overallocation_behavior: MemoryOverallocationBehaviorAMD,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for DeviceMemoryOverallocationCreateInfoAMD<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::DeviceMemoryOverallocationCreateInfoAMD,
            next: ptr::null_mut(),
            overallocation_behavior: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsDeviceCreateInfo for DeviceMemoryOverallocationCreateInfoAMD<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceFragmentDensityMapFeaturesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub fragment_density_map: Bool32,
    pub fragment_density_map_dynamic: Bool32,
    pub fragment_density_map_non_subsampled_images: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceFragmentDensityMapFeaturesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceFragmentDensityMapFeaturesEXT,
            next: ptr::null_mut(),
            fragment_density_map: FALSE,
            fragment_density_map_dynamic: FALSE,
            fragment_density_map_non_subsampled_images: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceFragmentDensityMapFeaturesEXT<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentDensityMapFeaturesEXT<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceFragmentDensityMap2FeaturesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub fragment_density_map_deferred: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceFragmentDensityMap2FeaturesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceFragmentDensityMap2FeaturesEXT,
            next: ptr::null_mut(),
            fragment_density_map_deferred: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceFragmentDensityMap2FeaturesEXT<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentDensityMap2FeaturesEXT<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub fragment_density_map_offset: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT,
            next: ptr::null_mut(),
            fragment_density_map_offset: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT<'_> {}

pub type PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM<'a> =
    PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT<'a>;
/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceFragmentDensityMapPropertiesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub min_fragment_density_texel_size: Extent2D,
    pub max_fragment_density_texel_size: Extent2D,
    pub fragment_density_invocations: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceFragmentDensityMapPropertiesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceFragmentDensityMapPropertiesEXT,
            next: ptr::null_mut(),
            min_fragment_density_texel_size: Default::default(),
            max_fragment_density_texel_size: Default::default(),
            fragment_density_invocations: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceFragmentDensityMapPropertiesEXT<'_> {}

/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceFragmentDensityMap2PropertiesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub subsampled_loads: Bool32,
    pub subsampled_coarse_reconstruction_early_access: Bool32,
    pub max_subsampled_array_layers: u32,
    pub max_descriptor_set_subsampled_samplers: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceFragmentDensityMap2PropertiesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceFragmentDensityMap2PropertiesEXT,
            next: ptr::null_mut(),
            subsampled_loads: FALSE,
            subsampled_coarse_reconstruction_early_access: FALSE,
            max_subsampled_array_layers: 0,
            max_descriptor_set_subsampled_samplers: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceFragmentDensityMap2PropertiesEXT<'_> {}

/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub fragment_density_offset_granularity: Extent2D,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT,
            next: ptr::null_mut(),
            fragment_density_offset_granularity: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT<'_> {}

pub type PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM<'a> =
    PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT<'a>;
/// Extends: `RenderPassCreateInfo`, `RenderPassCreateInfo2`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct RenderPassFragmentDensityMapCreateInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub fragment_density_map_attachment: AttachmentReference,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for RenderPassFragmentDensityMapCreateInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::RenderPassFragmentDensityMapCreateInfoEXT,
            next: ptr::null_mut(),
            fragment_density_map_attachment: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsRenderPassCreateInfo for RenderPassFragmentDensityMapCreateInfoEXT<'_> {}
impl ExtendsRenderPassCreateInfo2 for RenderPassFragmentDensityMapCreateInfoEXT<'_> {}

/// Extends: `SubpassEndInfo`, `RenderingEndInfoKHR`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct RenderPassFragmentDensityMapOffsetEndInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub fragment_density_offset_count: u32,
    /// Len: `fragment_density_offset_count`
    pub fragment_density_offsets: *const Offset2D,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for RenderPassFragmentDensityMapOffsetEndInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::RenderPassFragmentDensityMapOffsetEndInfoEXT,
            next: ptr::null_mut(),
            fragment_density_offset_count: 0,
            fragment_density_offsets: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsSubpassEndInfo for RenderPassFragmentDensityMapOffsetEndInfoEXT<'_> {}
impl ExtendsRenderingEndInfoKHR for RenderPassFragmentDensityMapOffsetEndInfoEXT<'_> {}

pub type SubpassFragmentDensityMapOffsetEndInfoQCOM<'a> =
    RenderPassFragmentDensityMapOffsetEndInfoEXT<'a>;
/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceScalarBlockLayoutFeatures<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub scalar_block_layout: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceScalarBlockLayoutFeatures<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceScalarBlockLayoutFeatures,
            next: ptr::null_mut(),
            scalar_block_layout: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceScalarBlockLayoutFeatures<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceScalarBlockLayoutFeatures<'_> {}

pub type PhysicalDeviceScalarBlockLayoutFeaturesEXT<'a> =
    PhysicalDeviceScalarBlockLayoutFeatures<'a>;
/// Extends: `SurfaceCapabilities2KHR`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct SurfaceProtectedCapabilitiesKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    /// Represents if surface can be protected
    pub supports_protected: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for SurfaceProtectedCapabilitiesKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::SurfaceProtectedCapabilitiesKHR,
            next: ptr::null_mut(),
            supports_protected: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsSurfaceCapabilities2KHR for SurfaceProtectedCapabilitiesKHR<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceUniformBufferStandardLayoutFeatures<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub uniform_buffer_standard_layout: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceUniformBufferStandardLayoutFeatures<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceUniformBufferStandardLayoutFeatures,
            next: ptr::null_mut(),
            uniform_buffer_standard_layout: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceUniformBufferStandardLayoutFeatures<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceUniformBufferStandardLayoutFeatures<'_> {}

pub type PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR<'a> =
    PhysicalDeviceUniformBufferStandardLayoutFeatures<'a>;
/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceDepthClipEnableFeaturesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub depth_clip_enable: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceDepthClipEnableFeaturesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceDepthClipEnableFeaturesEXT,
            next: ptr::null_mut(),
            depth_clip_enable: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDepthClipEnableFeaturesEXT<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceDepthClipEnableFeaturesEXT<'_> {}

/// Extends: `PipelineRasterizationStateCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PipelineRasterizationDepthClipStateCreateInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    /// Reserved
    pub flags: PipelineRasterizationDepthClipStateCreateFlagsEXT,
    pub depth_clip_enable: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PipelineRasterizationDepthClipStateCreateInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PipelineRasterizationDepthClipStateCreateInfoEXT,
            next: ptr::null_mut(),
            flags: Default::default(),
            depth_clip_enable: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPipelineRasterizationStateCreateInfo
    for PipelineRasterizationDepthClipStateCreateInfoEXT<'_>
{
}

/// Extends: `PhysicalDeviceMemoryProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceMemoryBudgetPropertiesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub heap_budget: [DeviceSize; MAX_MEMORY_HEAPS as usize],
    pub heap_usage: [DeviceSize; MAX_MEMORY_HEAPS as usize],
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceMemoryBudgetPropertiesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceMemoryBudgetPropertiesEXT,
            next: ptr::null_mut(),
            heap_budget: unsafe { mem::zeroed() },
            heap_usage: unsafe { mem::zeroed() },
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceMemoryProperties2 for PhysicalDeviceMemoryBudgetPropertiesEXT<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceMemoryPriorityFeaturesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub memory_priority: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceMemoryPriorityFeaturesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceMemoryPriorityFeaturesEXT,
            next: ptr::null_mut(),
            memory_priority: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMemoryPriorityFeaturesEXT<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceMemoryPriorityFeaturesEXT<'_> {}

/// Extends: `MemoryAllocateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct MemoryPriorityAllocateInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub priority: f32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for MemoryPriorityAllocateInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::MemoryPriorityAllocateInfoEXT,
            next: ptr::null_mut(),
            priority: 0.0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsMemoryAllocateInfo for MemoryPriorityAllocateInfoEXT<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub pageable_device_local_memory: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT,
            next: ptr::null_mut(),
            pageable_device_local_memory: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceBufferDeviceAddressFeatures<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub buffer_device_address: Bool32,
    pub buffer_device_address_capture_replay: Bool32,
    pub buffer_device_address_multi_device: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceBufferDeviceAddressFeatures<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceBufferDeviceAddressFeatures,
            next: ptr::null_mut(),
            buffer_device_address: FALSE,
            buffer_device_address_capture_replay: FALSE,
            buffer_device_address_multi_device: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceBufferDeviceAddressFeatures<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceBufferDeviceAddressFeatures<'_> {}

pub type PhysicalDeviceBufferDeviceAddressFeaturesKHR<'a> =
    PhysicalDeviceBufferDeviceAddressFeatures<'a>;
/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceBufferDeviceAddressFeaturesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub buffer_device_address: Bool32,
    pub buffer_device_address_capture_replay: Bool32,
    pub buffer_device_address_multi_device: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceBufferDeviceAddressFeaturesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceBufferDeviceAddressFeaturesEXT,
            next: ptr::null_mut(),
            buffer_device_address: FALSE,
            buffer_device_address_capture_replay: FALSE,
            buffer_device_address_multi_device: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceBufferDeviceAddressFeaturesEXT<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceBufferDeviceAddressFeaturesEXT<'_> {}

pub type PhysicalDeviceBufferAddressFeaturesEXT<'a> =
    PhysicalDeviceBufferDeviceAddressFeaturesEXT<'a>;
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct BufferDeviceAddressInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub buffer: Buffer,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for BufferDeviceAddressInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::BufferDeviceAddressInfo,
            next: ptr::null_mut(),
            buffer: Default::default(),
            _marker: PhantomData,
        }
    }
}

pub type BufferDeviceAddressInfoKHR<'a> = BufferDeviceAddressInfo<'a>;
pub type BufferDeviceAddressInfoEXT<'a> = BufferDeviceAddressInfo<'a>;
/// Extends: `BufferCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct BufferOpaqueCaptureAddressCreateInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub opaque_capture_address: u64,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for BufferOpaqueCaptureAddressCreateInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::BufferOpaqueCaptureAddressCreateInfo,
            next: ptr::null_mut(),
            opaque_capture_address: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsBufferCreateInfo for BufferOpaqueCaptureAddressCreateInfo<'_> {}

pub type BufferOpaqueCaptureAddressCreateInfoKHR<'a> = BufferOpaqueCaptureAddressCreateInfo<'a>;
/// Extends: `BufferCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct BufferDeviceAddressCreateInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub device_address: DeviceAddress,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for BufferDeviceAddressCreateInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::BufferDeviceAddressCreateInfoEXT,
            next: ptr::null_mut(),
            device_address: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsBufferCreateInfo for BufferDeviceAddressCreateInfoEXT<'_> {}

/// Extends: `PhysicalDeviceImageFormatInfo2`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceImageViewImageFormatInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub image_view_type: ImageViewType,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceImageViewImageFormatInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceImageViewImageFormatInfoEXT,
            next: ptr::null_mut(),
            image_view_type: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceImageFormatInfo2 for PhysicalDeviceImageViewImageFormatInfoEXT<'_> {}

/// Extends: `ImageFormatProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct FilterCubicImageViewImageFormatPropertiesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    /// The combinations of format, image type (and image view type if provided) can be filtered with VK_FILTER_CUBIC_EXT
    pub filter_cubic: Bool32,
    /// The combination of format, image type (and image view type if provided) can be filtered with VK_FILTER_CUBIC_EXT and ReductionMode of Min or Max
    pub filter_cubic_minmax: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for FilterCubicImageViewImageFormatPropertiesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::FilterCubicImageViewImageFormatPropertiesEXT,
            next: ptr::null_mut(),
            filter_cubic: FALSE,
            filter_cubic_minmax: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsImageFormatProperties2 for FilterCubicImageViewImageFormatPropertiesEXT<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceImagelessFramebufferFeatures<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub imageless_framebuffer: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceImagelessFramebufferFeatures<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceImagelessFramebufferFeatures,
            next: ptr::null_mut(),
            imageless_framebuffer: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceImagelessFramebufferFeatures<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceImagelessFramebufferFeatures<'_> {}

pub type PhysicalDeviceImagelessFramebufferFeaturesKHR<'a> =
    PhysicalDeviceImagelessFramebufferFeatures<'a>;
/// Extends: `FramebufferCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct FramebufferAttachmentsCreateInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub attachment_image_info_count: u32,
    /// Len: `attachment_image_info_count`
    pub attachment_image_infos: *const FramebufferAttachmentImageInfo<'a>,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for FramebufferAttachmentsCreateInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::FramebufferAttachmentsCreateInfo,
            next: ptr::null_mut(),
            attachment_image_info_count: 0,
            attachment_image_infos: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsFramebufferCreateInfo for FramebufferAttachmentsCreateInfo<'_> {}

pub type FramebufferAttachmentsCreateInfoKHR<'a> = FramebufferAttachmentsCreateInfo<'a>;
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct FramebufferAttachmentImageInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    /// Image creation flags
    pub flags: ImageCreateFlags,
    /// Image usage flags
    pub usage: ImageUsageFlags,
    pub width: u32,
    pub height: u32,
    pub layer_count: u32,
    pub view_format_count: u32,
    /// Len: `view_format_count`
    pub view_formats: *const Format,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for FramebufferAttachmentImageInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::FramebufferAttachmentImageInfo,
            next: ptr::null_mut(),
            flags: Default::default(),
            usage: Default::default(),
            width: 0,
            height: 0,
            layer_count: 0,
            view_format_count: 0,
            view_formats: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

pub type FramebufferAttachmentImageInfoKHR<'a> = FramebufferAttachmentImageInfo<'a>;
/// Extends: `RenderPassBeginInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct RenderPassAttachmentBeginInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub attachment_count: u32,
    /// Len: `attachment_count`
    pub attachments: *const ImageView,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for RenderPassAttachmentBeginInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::RenderPassAttachmentBeginInfo,
            next: ptr::null_mut(),
            attachment_count: 0,
            attachments: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsRenderPassBeginInfo for RenderPassAttachmentBeginInfo<'_> {}

pub type RenderPassAttachmentBeginInfoKHR<'a> = RenderPassAttachmentBeginInfo<'a>;
/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceTextureCompressionASTCHDRFeatures<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub texture_compression_astc_hdr: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceTextureCompressionASTCHDRFeatures<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceTextureCompressionASTCHDRFeatures,
            next: ptr::null_mut(),
            texture_compression_astc_hdr: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceTextureCompressionASTCHDRFeatures<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceTextureCompressionASTCHDRFeatures<'_> {}

pub type PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT<'a> =
    PhysicalDeviceTextureCompressionASTCHDRFeatures<'a>;
/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceCooperativeMatrixFeaturesNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub cooperative_matrix: Bool32,
    pub cooperative_matrix_robust_buffer_access: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceCooperativeMatrixFeaturesNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceCooperativeMatrixFeaturesNV,
            next: ptr::null_mut(),
            cooperative_matrix: FALSE,
            cooperative_matrix_robust_buffer_access: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceCooperativeMatrixFeaturesNV<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceCooperativeMatrixFeaturesNV<'_> {}

/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceCooperativeMatrixPropertiesNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub cooperative_matrix_supported_stages: ShaderStageFlags,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceCooperativeMatrixPropertiesNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceCooperativeMatrixPropertiesNV,
            next: ptr::null_mut(),
            cooperative_matrix_supported_stages: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceCooperativeMatrixPropertiesNV<'_> {}

/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct CooperativeMatrixPropertiesNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub m_size: u32,
    pub n_size: u32,
    pub k_size: u32,
    pub a_type: ComponentTypeNV,
    pub b_type: ComponentTypeNV,
    pub c_type: ComponentTypeNV,
    pub d_type: ComponentTypeNV,
    pub scope: ScopeNV,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for CooperativeMatrixPropertiesNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::CooperativeMatrixPropertiesNV,
            next: ptr::null_mut(),
            m_size: 0,
            n_size: 0,
            k_size: 0,
            a_type: Default::default(),
            b_type: Default::default(),
            c_type: Default::default(),
            d_type: Default::default(),
            scope: Default::default(),
            _marker: PhantomData,
        }
    }
}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceYcbcrImageArraysFeaturesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub ycbcr_image_arrays: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceYcbcrImageArraysFeaturesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceYcbcrImageArraysFeaturesEXT,
            next: ptr::null_mut(),
            ycbcr_image_arrays: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceYcbcrImageArraysFeaturesEXT<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceYcbcrImageArraysFeaturesEXT<'_> {}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ImageViewHandleInfoNVX<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub image_view: ImageView,
    pub descriptor_type: DescriptorType,
    pub sampler: Sampler,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ImageViewHandleInfoNVX<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ImageViewHandleInfoNVX,
            next: ptr::null_mut(),
            image_view: Default::default(),
            descriptor_type: Default::default(),
            sampler: Default::default(),
            _marker: PhantomData,
        }
    }
}

/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ImageViewAddressPropertiesNVX<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub device_address: DeviceAddress,
    pub size: DeviceSize,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ImageViewAddressPropertiesNVX<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ImageViewAddressPropertiesNVX,
            next: ptr::null_mut(),
            device_address: Default::default(),
            size: Default::default(),
            _marker: PhantomData,
        }
    }
}

/// Extends: `PresentInfoKHR`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PresentFrameTokenGGP<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub frame_token: GgpFrameToken,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PresentFrameTokenGGP<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PresentFrameTokenGGP,
            next: ptr::null_mut(),
            frame_token: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsPresentInfoKHR for PresentFrameTokenGGP<'_> {}

/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PipelineCreationFeedback {
    pub flags: PipelineCreationFeedbackFlags,
    pub duration: u64,
}
impl Default for PipelineCreationFeedback {
    fn default() -> Self {
        Self {
            flags: Default::default(),
            duration: 0,
        }
    }
}

pub type PipelineCreationFeedbackEXT = PipelineCreationFeedback;
/// Extends: `GraphicsPipelineCreateInfo`, `ComputePipelineCreateInfo`, `RayTracingPipelineCreateInfoNV`, `RayTracingPipelineCreateInfoKHR`, `ExecutionGraphPipelineCreateInfoAMDX`, `DataGraphPipelineCreateInfoARM`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PipelineCreationFeedbackCreateInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    /// Output pipeline creation feedback.
    pub pipeline_creation_feedback: *mut PipelineCreationFeedback,
    pub pipeline_stage_creation_feedback_count: u32,
    /// One entry for each shader stage specified in the parent Vk*PipelineCreateInfo struct
    /// Len: `pipeline_stage_creation_feedback_count`
    pub pipeline_stage_creation_feedbacks: *mut PipelineCreationFeedback,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PipelineCreationFeedbackCreateInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PipelineCreationFeedbackCreateInfo,
            next: ptr::null_mut(),
            pipeline_creation_feedback: ptr::null_mut(),
            pipeline_stage_creation_feedback_count: 0,
            pipeline_stage_creation_feedbacks: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsGraphicsPipelineCreateInfo for PipelineCreationFeedbackCreateInfo<'_> {}
impl ExtendsComputePipelineCreateInfo for PipelineCreationFeedbackCreateInfo<'_> {}
impl ExtendsRayTracingPipelineCreateInfoNV for PipelineCreationFeedbackCreateInfo<'_> {}
impl ExtendsRayTracingPipelineCreateInfoKHR for PipelineCreationFeedbackCreateInfo<'_> {}
impl ExtendsExecutionGraphPipelineCreateInfoAMDX for PipelineCreationFeedbackCreateInfo<'_> {}
impl ExtendsDataGraphPipelineCreateInfoARM for PipelineCreationFeedbackCreateInfo<'_> {}

pub type PipelineCreationFeedbackCreateInfoEXT<'a> = PipelineCreationFeedbackCreateInfo<'a>;
/// Extends: `PhysicalDeviceSurfaceInfo2KHR`, `SwapchainCreateInfoKHR`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct SurfaceFullScreenExclusiveInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub full_screen_exclusive: FullScreenExclusiveEXT,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for SurfaceFullScreenExclusiveInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::SurfaceFullScreenExclusiveInfoEXT,
            next: ptr::null_mut(),
            full_screen_exclusive: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceSurfaceInfo2KHR for SurfaceFullScreenExclusiveInfoEXT<'_> {}
impl ExtendsSwapchainCreateInfoKHR for SurfaceFullScreenExclusiveInfoEXT<'_> {}

/// Extends: `PhysicalDeviceSurfaceInfo2KHR`, `SwapchainCreateInfoKHR`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct SurfaceFullScreenExclusiveWin32InfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub hmonitor: HMONITOR,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for SurfaceFullScreenExclusiveWin32InfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::SurfaceFullScreenExclusiveWin32InfoEXT,
            next: ptr::null_mut(),
            hmonitor: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceSurfaceInfo2KHR for SurfaceFullScreenExclusiveWin32InfoEXT<'_> {}
impl ExtendsSwapchainCreateInfoKHR for SurfaceFullScreenExclusiveWin32InfoEXT<'_> {}

/// Extends: `SurfaceCapabilities2KHR`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct SurfaceCapabilitiesFullScreenExclusiveEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub full_screen_exclusive_supported: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for SurfaceCapabilitiesFullScreenExclusiveEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::SurfaceCapabilitiesFullScreenExclusiveEXT,
            next: ptr::null_mut(),
            full_screen_exclusive_supported: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsSurfaceCapabilities2KHR for SurfaceCapabilitiesFullScreenExclusiveEXT<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDevicePresentBarrierFeaturesNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub present_barrier: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDevicePresentBarrierFeaturesNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDevicePresentBarrierFeaturesNV,
            next: ptr::null_mut(),
            present_barrier: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePresentBarrierFeaturesNV<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDevicePresentBarrierFeaturesNV<'_> {}

/// Extends: `SurfaceCapabilities2KHR`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct SurfaceCapabilitiesPresentBarrierNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub present_barrier_supported: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for SurfaceCapabilitiesPresentBarrierNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::SurfaceCapabilitiesPresentBarrierNV,
            next: ptr::null_mut(),
            present_barrier_supported: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsSurfaceCapabilities2KHR for SurfaceCapabilitiesPresentBarrierNV<'_> {}

/// Extends: `SwapchainCreateInfoKHR`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct SwapchainPresentBarrierCreateInfoNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub present_barrier_enable: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for SwapchainPresentBarrierCreateInfoNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::SwapchainPresentBarrierCreateInfoNV,
            next: ptr::null_mut(),
            present_barrier_enable: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsSwapchainCreateInfoKHR for SwapchainPresentBarrierCreateInfoNV<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDevicePerformanceQueryFeaturesKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    /// performance counters supported in query pools
    pub performance_counter_query_pools: Bool32,
    /// performance counters from multiple query pools can be accessed in the same primary command buffer
    pub performance_counter_multiple_query_pools: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDevicePerformanceQueryFeaturesKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDevicePerformanceQueryFeaturesKHR,
            next: ptr::null_mut(),
            performance_counter_query_pools: FALSE,
            performance_counter_multiple_query_pools: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePerformanceQueryFeaturesKHR<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDevicePerformanceQueryFeaturesKHR<'_> {}

/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDevicePerformanceQueryPropertiesKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    /// Flag to specify whether performance queries are allowed to be used in vkCmdCopyQueryPoolResults
    pub allow_command_buffer_query_copies: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDevicePerformanceQueryPropertiesKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDevicePerformanceQueryPropertiesKHR,
            next: ptr::null_mut(),
            allow_command_buffer_query_copies: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2 for PhysicalDevicePerformanceQueryPropertiesKHR<'_> {}

/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PerformanceCounterKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub unit: PerformanceCounterUnitKHR,
    pub scope: PerformanceCounterScopeKHR,
    pub storage: PerformanceCounterStorageKHR,
    pub uuid: [u8; UUID_SIZE as usize],
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PerformanceCounterKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PerformanceCounterKHR,
            next: ptr::null_mut(),
            unit: Default::default(),
            scope: Default::default(),
            storage: Default::default(),
            uuid: unsafe { mem::zeroed() },
            _marker: PhantomData,
        }
    }
}

/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PerformanceCounterDescriptionKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub flags: PerformanceCounterDescriptionFlagsKHR,
    /// Len: null-terminated
    pub name: [c_char; MAX_DESCRIPTION_SIZE as usize],
    /// Len: null-terminated
    pub category: [c_char; MAX_DESCRIPTION_SIZE as usize],
    /// Len: null-terminated
    pub description: [c_char; MAX_DESCRIPTION_SIZE as usize],
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PerformanceCounterDescriptionKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PerformanceCounterDescriptionKHR,
            next: ptr::null_mut(),
            flags: Default::default(),
            name: unsafe { mem::zeroed() },
            category: unsafe { mem::zeroed() },
            description: unsafe { mem::zeroed() },
            _marker: PhantomData,
        }
    }
}

/// Extends: `QueryPoolCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct QueryPoolPerformanceCreateInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub queue_family_index: u32,
    pub counter_index_count: u32,
    /// Len: `counter_index_count`
    pub counter_indices: *const u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for QueryPoolPerformanceCreateInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::QueryPoolPerformanceCreateInfoKHR,
            next: ptr::null_mut(),
            queue_family_index: 0,
            counter_index_count: 0,
            counter_indices: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsQueryPoolCreateInfo for QueryPoolPerformanceCreateInfoKHR<'_> {}

#[repr(C)]
#[derive(Copy, Clone)]
pub union PerformanceCounterResultKHR {
    pub int32: i32,
    pub int64: i64,
    pub uint32: u32,
    pub uint64: u64,
    pub float32: f32,
    pub float64: f64,
}
impl Default for PerformanceCounterResultKHR {
    fn default() -> Self {
        unsafe { mem::zeroed() }
    }
}

impl fmt::Debug for PerformanceCounterResultKHR {
    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
        fmt.debug_struct("PerformanceCounterResultKHR").finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct AcquireProfilingLockInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    /// Acquire profiling lock flags
    pub flags: AcquireProfilingLockFlagsKHR,
    pub timeout: u64,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for AcquireProfilingLockInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::AcquireProfilingLockInfoKHR,
            next: ptr::null_mut(),
            flags: Default::default(),
            timeout: 0,
            _marker: PhantomData,
        }
    }
}

/// Extends: `SubmitInfo`, `SubmitInfo2`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PerformanceQuerySubmitInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    /// Index for which counter pass to submit
    pub counter_pass_index: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PerformanceQuerySubmitInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PerformanceQuerySubmitInfoKHR,
            next: ptr::null_mut(),
            counter_pass_index: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsSubmitInfo for PerformanceQuerySubmitInfoKHR<'_> {}
impl ExtendsSubmitInfo2 for PerformanceQuerySubmitInfoKHR<'_> {}

/// Extends: `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PerformanceQueryReservationInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    /// Maximum number of VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR queries in a query pool
    pub max_performance_queries_per_pool: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PerformanceQueryReservationInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PerformanceQueryReservationInfoKHR,
            next: ptr::null_mut(),
            max_performance_queries_per_pool: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsDeviceCreateInfo for PerformanceQueryReservationInfoKHR<'_> {}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct HeadlessSurfaceCreateInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub flags: HeadlessSurfaceCreateFlagsEXT,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for HeadlessSurfaceCreateInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::HeadlessSurfaceCreateInfoEXT,
            next: ptr::null_mut(),
            flags: Default::default(),
            _marker: PhantomData,
        }
    }
}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceCoverageReductionModeFeaturesNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub coverage_reduction_mode: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceCoverageReductionModeFeaturesNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceCoverageReductionModeFeaturesNV,
            next: ptr::null_mut(),
            coverage_reduction_mode: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceCoverageReductionModeFeaturesNV<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceCoverageReductionModeFeaturesNV<'_> {}

/// Extends: `PipelineMultisampleStateCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PipelineCoverageReductionStateCreateInfoNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub flags: PipelineCoverageReductionStateCreateFlagsNV,
    pub coverage_reduction_mode: CoverageReductionModeNV,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PipelineCoverageReductionStateCreateInfoNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PipelineCoverageReductionStateCreateInfoNV,
            next: ptr::null_mut(),
            flags: Default::default(),
            coverage_reduction_mode: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsPipelineMultisampleStateCreateInfo for PipelineCoverageReductionStateCreateInfoNV<'_> {}

/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct FramebufferMixedSamplesCombinationNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub coverage_reduction_mode: CoverageReductionModeNV,
    pub rasterization_samples: SampleCountFlags,
    pub depth_stencil_samples: SampleCountFlags,
    pub color_samples: SampleCountFlags,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for FramebufferMixedSamplesCombinationNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::FramebufferMixedSamplesCombinationNV,
            next: ptr::null_mut(),
            coverage_reduction_mode: Default::default(),
            rasterization_samples: Default::default(),
            depth_stencil_samples: Default::default(),
            color_samples: Default::default(),
            _marker: PhantomData,
        }
    }
}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub shader_integer_functions2: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL,
            next: ptr::null_mut(),
            shader_integer_functions2: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL<'_> {}

#[repr(C)]
#[derive(Copy, Clone)]
pub union PerformanceValueDataINTEL {
    pub value32: u32,
    pub value64: u64,
    pub value_float: f32,
    pub value_bool: Bool32,
    pub value_string: *const c_char,
}
impl Default for PerformanceValueDataINTEL {
    fn default() -> Self {
        unsafe { mem::zeroed() }
    }
}

impl fmt::Debug for PerformanceValueDataINTEL {
    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
        fmt.debug_struct("PerformanceValueDataINTEL").finish()
    }
}

/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PerformanceValueINTEL {
    pub ty: PerformanceValueTypeINTEL,
    pub data: PerformanceValueDataINTEL,
}
impl Default for PerformanceValueINTEL {
    fn default() -> Self {
        Self {
            ty: Default::default(),
            data: Default::default(),
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct InitializePerformanceApiInfoINTEL<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    /// Nullable
    pub user_data: *mut c_void,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for InitializePerformanceApiInfoINTEL<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::InitializePerformanceApiInfoINTEL,
            next: ptr::null_mut(),
            user_data: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

/// Extends: `QueryPoolCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct QueryPoolPerformanceQueryCreateInfoINTEL<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub performance_counters_sampling: QueryPoolSamplingModeINTEL,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for QueryPoolPerformanceQueryCreateInfoINTEL<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::QueryPoolPerformanceQueryCreateInfoINTEL,
            next: ptr::null_mut(),
            performance_counters_sampling: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsQueryPoolCreateInfo for QueryPoolPerformanceQueryCreateInfoINTEL<'_> {}

pub type QueryPoolCreateInfoINTEL<'a> = QueryPoolPerformanceQueryCreateInfoINTEL<'a>;
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PerformanceMarkerInfoINTEL<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub marker: u64,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PerformanceMarkerInfoINTEL<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PerformanceMarkerInfoINTEL,
            next: ptr::null_mut(),
            marker: 0,
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PerformanceStreamMarkerInfoINTEL<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub marker: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PerformanceStreamMarkerInfoINTEL<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PerformanceStreamMarkerInfoINTEL,
            next: ptr::null_mut(),
            marker: 0,
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PerformanceOverrideInfoINTEL<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub ty: PerformanceOverrideTypeINTEL,
    pub enable: Bool32,
    pub parameter: u64,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PerformanceOverrideInfoINTEL<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PerformanceOverrideInfoINTEL,
            next: ptr::null_mut(),
            ty: Default::default(),
            enable: FALSE,
            parameter: 0,
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PerformanceConfigurationAcquireInfoINTEL<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub ty: PerformanceConfigurationTypeINTEL,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PerformanceConfigurationAcquireInfoINTEL<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PerformanceConfigurationAcquireInfoINTEL,
            next: ptr::null_mut(),
            ty: Default::default(),
            _marker: PhantomData,
        }
    }
}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceShaderClockFeaturesKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub shader_subgroup_clock: Bool32,
    pub shader_device_clock: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceShaderClockFeaturesKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceShaderClockFeaturesKHR,
            next: ptr::null_mut(),
            shader_subgroup_clock: FALSE,
            shader_device_clock: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderClockFeaturesKHR<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderClockFeaturesKHR<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceIndexTypeUint8Features<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub index_type_uint8: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceIndexTypeUint8Features<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceIndexTypeUint8Features,
            next: ptr::null_mut(),
            index_type_uint8: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceIndexTypeUint8Features<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceIndexTypeUint8Features<'_> {}

pub type PhysicalDeviceIndexTypeUint8FeaturesKHR<'a> = PhysicalDeviceIndexTypeUint8Features<'a>;
pub type PhysicalDeviceIndexTypeUint8FeaturesEXT<'a> = PhysicalDeviceIndexTypeUint8Features<'a>;
/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceShaderSMBuiltinsPropertiesNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub shader_sm_count: u32,
    pub shader_warps_per_sm: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceShaderSMBuiltinsPropertiesNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceShaderSMBuiltinsPropertiesNV,
            next: ptr::null_mut(),
            shader_sm_count: 0,
            shader_warps_per_sm: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceShaderSMBuiltinsPropertiesNV<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceShaderSMBuiltinsFeaturesNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub shader_sm_builtins: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceShaderSMBuiltinsFeaturesNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceShaderSMBuiltinsFeaturesNV,
            next: ptr::null_mut(),
            shader_sm_builtins: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderSMBuiltinsFeaturesNV<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderSMBuiltinsFeaturesNV<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceFragmentShaderInterlockFeaturesEXT<'a> {
    pub s_type: StructureType,
    /// Pointer to next structure
    /// Nullable
    pub next: *mut c_void,
    pub fragment_shader_sample_interlock: Bool32,
    pub fragment_shader_pixel_interlock: Bool32,
    pub fragment_shader_shading_rate_interlock: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceFragmentShaderInterlockFeaturesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceFragmentShaderInterlockFeaturesEXT,
            next: ptr::null_mut(),
            fragment_shader_sample_interlock: FALSE,
            fragment_shader_pixel_interlock: FALSE,
            fragment_shader_shading_rate_interlock: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceFragmentShaderInterlockFeaturesEXT<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentShaderInterlockFeaturesEXT<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceSeparateDepthStencilLayoutsFeatures<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub separate_depth_stencil_layouts: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceSeparateDepthStencilLayoutsFeatures<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceSeparateDepthStencilLayoutsFeatures,
            next: ptr::null_mut(),
            separate_depth_stencil_layouts: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceSeparateDepthStencilLayoutsFeatures<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceSeparateDepthStencilLayoutsFeatures<'_> {}

pub type PhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR<'a> =
    PhysicalDeviceSeparateDepthStencilLayoutsFeatures<'a>;
/// Extends: `AttachmentReference2`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct AttachmentReferenceStencilLayout<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub stencil_layout: ImageLayout,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for AttachmentReferenceStencilLayout<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::AttachmentReferenceStencilLayout,
            next: ptr::null_mut(),
            stencil_layout: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsAttachmentReference2 for AttachmentReferenceStencilLayout<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub primitive_topology_list_restart: Bool32,
    pub primitive_topology_patch_list_restart: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT,
            next: ptr::null_mut(),
            primitive_topology_list_restart: FALSE,
            primitive_topology_patch_list_restart: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT<'_> {}

pub type AttachmentReferenceStencilLayoutKHR<'a> = AttachmentReferenceStencilLayout<'a>;
/// Extends: `AttachmentDescription2`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct AttachmentDescriptionStencilLayout<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub stencil_initial_layout: ImageLayout,
    pub stencil_final_layout: ImageLayout,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for AttachmentDescriptionStencilLayout<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::AttachmentDescriptionStencilLayout,
            next: ptr::null_mut(),
            stencil_initial_layout: Default::default(),
            stencil_final_layout: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsAttachmentDescription2 for AttachmentDescriptionStencilLayout<'_> {}

pub type AttachmentDescriptionStencilLayoutKHR<'a> = AttachmentDescriptionStencilLayout<'a>;
/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDevicePipelineExecutablePropertiesFeaturesKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub pipeline_executable_info: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDevicePipelineExecutablePropertiesFeaturesKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDevicePipelineExecutablePropertiesFeaturesKHR,
            next: ptr::null_mut(),
            pipeline_executable_info: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePipelineExecutablePropertiesFeaturesKHR<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDevicePipelineExecutablePropertiesFeaturesKHR<'_> {}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PipelineInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub pipeline: Pipeline,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PipelineInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PipelineInfoKHR,
            next: ptr::null_mut(),
            pipeline: Default::default(),
            _marker: PhantomData,
        }
    }
}

pub type PipelineInfoEXT<'a> = PipelineInfoKHR<'a>;
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PipelineExecutablePropertiesKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub stages: ShaderStageFlags,
    /// Len: null-terminated
    pub name: [c_char; MAX_DESCRIPTION_SIZE as usize],
    /// Len: null-terminated
    pub description: [c_char; MAX_DESCRIPTION_SIZE as usize],
    pub subgroup_size: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PipelineExecutablePropertiesKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PipelineExecutablePropertiesKHR,
            next: ptr::null_mut(),
            stages: Default::default(),
            name: unsafe { mem::zeroed() },
            description: unsafe { mem::zeroed() },
            subgroup_size: 0,
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PipelineExecutableInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub pipeline: Pipeline,
    pub executable_index: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PipelineExecutableInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PipelineExecutableInfoKHR,
            next: ptr::null_mut(),
            pipeline: Default::default(),
            executable_index: 0,
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub union PipelineExecutableStatisticValueKHR {
    pub b32: Bool32,
    pub i64: i64,
    pub u64: u64,
    pub f64: f64,
}
impl Default for PipelineExecutableStatisticValueKHR {
    fn default() -> Self {
        unsafe { mem::zeroed() }
    }
}

impl fmt::Debug for PipelineExecutableStatisticValueKHR {
    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
        fmt.debug_struct("PipelineExecutableStatisticValueKHR")
            .finish()
    }
}

/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PipelineExecutableStatisticKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    /// Len: null-terminated
    pub name: [c_char; MAX_DESCRIPTION_SIZE as usize],
    /// Len: null-terminated
    pub description: [c_char; MAX_DESCRIPTION_SIZE as usize],
    pub format: PipelineExecutableStatisticFormatKHR,
    pub value: PipelineExecutableStatisticValueKHR,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PipelineExecutableStatisticKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PipelineExecutableStatisticKHR,
            next: ptr::null_mut(),
            name: unsafe { mem::zeroed() },
            description: unsafe { mem::zeroed() },
            format: Default::default(),
            value: Default::default(),
            _marker: PhantomData,
        }
    }
}

/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PipelineExecutableInternalRepresentationKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    /// Len: null-terminated
    pub name: [c_char; MAX_DESCRIPTION_SIZE as usize],
    /// Len: null-terminated
    pub description: [c_char; MAX_DESCRIPTION_SIZE as usize],
    pub is_text: Bool32,
    pub data_size: usize,
    /// Nullable
    /// Len: `data_size`
    pub data: *mut c_void,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PipelineExecutableInternalRepresentationKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PipelineExecutableInternalRepresentationKHR,
            next: ptr::null_mut(),
            name: unsafe { mem::zeroed() },
            description: unsafe { mem::zeroed() },
            is_text: FALSE,
            data_size: 0,
            data: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceShaderDemoteToHelperInvocationFeatures<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub shader_demote_to_helper_invocation: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceShaderDemoteToHelperInvocationFeatures<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceShaderDemoteToHelperInvocationFeatures,
            next: ptr::null_mut(),
            shader_demote_to_helper_invocation: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderDemoteToHelperInvocationFeatures<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderDemoteToHelperInvocationFeatures<'_> {}

pub type PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT<'a> =
    PhysicalDeviceShaderDemoteToHelperInvocationFeatures<'a>;
/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceTexelBufferAlignmentFeaturesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub texel_buffer_alignment: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceTexelBufferAlignmentFeaturesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceTexelBufferAlignmentFeaturesEXT,
            next: ptr::null_mut(),
            texel_buffer_alignment: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceTexelBufferAlignmentFeaturesEXT<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceTexelBufferAlignmentFeaturesEXT<'_> {}

/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceTexelBufferAlignmentProperties<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub storage_texel_buffer_offset_alignment_bytes: DeviceSize,
    pub storage_texel_buffer_offset_single_texel_alignment: Bool32,
    pub uniform_texel_buffer_offset_alignment_bytes: DeviceSize,
    pub uniform_texel_buffer_offset_single_texel_alignment: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceTexelBufferAlignmentProperties<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceTexelBufferAlignmentProperties,
            next: ptr::null_mut(),
            storage_texel_buffer_offset_alignment_bytes: Default::default(),
            storage_texel_buffer_offset_single_texel_alignment: FALSE,
            uniform_texel_buffer_offset_alignment_bytes: Default::default(),
            uniform_texel_buffer_offset_single_texel_alignment: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceTexelBufferAlignmentProperties<'_> {}

pub type PhysicalDeviceTexelBufferAlignmentPropertiesEXT<'a> =
    PhysicalDeviceTexelBufferAlignmentProperties<'a>;
/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceSubgroupSizeControlFeatures<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub subgroup_size_control: Bool32,
    pub compute_full_subgroups: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceSubgroupSizeControlFeatures<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceSubgroupSizeControlFeatures,
            next: ptr::null_mut(),
            subgroup_size_control: FALSE,
            compute_full_subgroups: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceSubgroupSizeControlFeatures<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceSubgroupSizeControlFeatures<'_> {}

pub type PhysicalDeviceSubgroupSizeControlFeaturesEXT<'a> =
    PhysicalDeviceSubgroupSizeControlFeatures<'a>;
/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceSubgroupSizeControlProperties<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    /// The minimum subgroup size supported by this device
    pub min_subgroup_size: u32,
    /// The maximum subgroup size supported by this device
    pub max_subgroup_size: u32,
    /// The maximum number of subgroups supported in a workgroup
    pub max_compute_workgroup_subgroups: u32,
    /// The shader stages that support specifying a subgroup size
    pub required_subgroup_size_stages: ShaderStageFlags,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceSubgroupSizeControlProperties<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceSubgroupSizeControlProperties,
            next: ptr::null_mut(),
            min_subgroup_size: 0,
            max_subgroup_size: 0,
            max_compute_workgroup_subgroups: 0,
            required_subgroup_size_stages: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceSubgroupSizeControlProperties<'_> {}

pub type PhysicalDeviceSubgroupSizeControlPropertiesEXT<'a> =
    PhysicalDeviceSubgroupSizeControlProperties<'a>;
/// Extends: `PipelineShaderStageCreateInfo`, `ShaderCreateInfoEXT`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PipelineShaderStageRequiredSubgroupSizeCreateInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub required_subgroup_size: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PipelineShaderStageRequiredSubgroupSizeCreateInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PipelineShaderStageRequiredSubgroupSizeCreateInfo,
            next: ptr::null_mut(),
            required_subgroup_size: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPipelineShaderStageCreateInfo
    for PipelineShaderStageRequiredSubgroupSizeCreateInfo<'_>
{
}
impl ExtendsShaderCreateInfoEXT for PipelineShaderStageRequiredSubgroupSizeCreateInfo<'_> {}

pub type PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT<'a> =
    PipelineShaderStageRequiredSubgroupSizeCreateInfo<'a>;
pub type ShaderRequiredSubgroupSizeCreateInfoEXT<'a> =
    PipelineShaderStageRequiredSubgroupSizeCreateInfo<'a>;
/// Extends: `ComputePipelineCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct SubpassShadingPipelineCreateInfoHUAWEI<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub render_pass: RenderPass,
    pub subpass: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for SubpassShadingPipelineCreateInfoHUAWEI<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::SubpassShadingPipelineCreateInfoHUAWEI,
            next: ptr::null_mut(),
            render_pass: Default::default(),
            subpass: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsComputePipelineCreateInfo for SubpassShadingPipelineCreateInfoHUAWEI<'_> {}

/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceSubpassShadingPropertiesHUAWEI<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub max_subpass_shading_workgroup_size_aspect_ratio: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceSubpassShadingPropertiesHUAWEI<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceSubpassShadingPropertiesHUAWEI,
            next: ptr::null_mut(),
            max_subpass_shading_workgroup_size_aspect_ratio: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceSubpassShadingPropertiesHUAWEI<'_> {}

/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceClusterCullingShaderPropertiesHUAWEI<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub max_work_group_count: [u32; 3],
    pub max_work_group_size: [u32; 3],
    pub max_output_cluster_count: u32,
    pub indirect_buffer_offset_alignment: DeviceSize,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceClusterCullingShaderPropertiesHUAWEI<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceClusterCullingShaderPropertiesHUAWEI,
            next: ptr::null_mut(),
            max_work_group_count: unsafe { mem::zeroed() },
            max_work_group_size: unsafe { mem::zeroed() },
            max_output_cluster_count: 0,
            indirect_buffer_offset_alignment: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceClusterCullingShaderPropertiesHUAWEI<'_> {}

/// Extends: `MemoryAllocateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct MemoryOpaqueCaptureAddressAllocateInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub opaque_capture_address: u64,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for MemoryOpaqueCaptureAddressAllocateInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::MemoryOpaqueCaptureAddressAllocateInfo,
            next: ptr::null_mut(),
            opaque_capture_address: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsMemoryAllocateInfo for MemoryOpaqueCaptureAddressAllocateInfo<'_> {}

pub type MemoryOpaqueCaptureAddressAllocateInfoKHR<'a> = MemoryOpaqueCaptureAddressAllocateInfo<'a>;
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DeviceMemoryOpaqueCaptureAddressInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub memory: DeviceMemory,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for DeviceMemoryOpaqueCaptureAddressInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::DeviceMemoryOpaqueCaptureAddressInfo,
            next: ptr::null_mut(),
            memory: Default::default(),
            _marker: PhantomData,
        }
    }
}

pub type DeviceMemoryOpaqueCaptureAddressInfoKHR<'a> = DeviceMemoryOpaqueCaptureAddressInfo<'a>;
/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceLineRasterizationFeatures<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub rectangular_lines: Bool32,
    pub bresenham_lines: Bool32,
    pub smooth_lines: Bool32,
    pub stippled_rectangular_lines: Bool32,
    pub stippled_bresenham_lines: Bool32,
    pub stippled_smooth_lines: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceLineRasterizationFeatures<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceLineRasterizationFeatures,
            next: ptr::null_mut(),
            rectangular_lines: FALSE,
            bresenham_lines: FALSE,
            smooth_lines: FALSE,
            stippled_rectangular_lines: FALSE,
            stippled_bresenham_lines: FALSE,
            stippled_smooth_lines: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceLineRasterizationFeatures<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceLineRasterizationFeatures<'_> {}

pub type PhysicalDeviceLineRasterizationFeaturesKHR<'a> =
    PhysicalDeviceLineRasterizationFeatures<'a>;
pub type PhysicalDeviceLineRasterizationFeaturesEXT<'a> =
    PhysicalDeviceLineRasterizationFeatures<'a>;
/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceLineRasterizationProperties<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub line_sub_pixel_precision_bits: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceLineRasterizationProperties<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceLineRasterizationProperties,
            next: ptr::null_mut(),
            line_sub_pixel_precision_bits: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceLineRasterizationProperties<'_> {}

pub type PhysicalDeviceLineRasterizationPropertiesKHR<'a> =
    PhysicalDeviceLineRasterizationProperties<'a>;
pub type PhysicalDeviceLineRasterizationPropertiesEXT<'a> =
    PhysicalDeviceLineRasterizationProperties<'a>;
/// Extends: `PipelineRasterizationStateCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PipelineRasterizationLineStateCreateInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub line_rasterization_mode: LineRasterizationMode,
    pub stippled_line_enable: Bool32,
    pub line_stipple_factor: u32,
    pub line_stipple_pattern: u16,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PipelineRasterizationLineStateCreateInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PipelineRasterizationLineStateCreateInfo,
            next: ptr::null_mut(),
            line_rasterization_mode: Default::default(),
            stippled_line_enable: FALSE,
            line_stipple_factor: 0,
            line_stipple_pattern: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPipelineRasterizationStateCreateInfo for PipelineRasterizationLineStateCreateInfo<'_> {}

pub type PipelineRasterizationLineStateCreateInfoKHR<'a> =
    PipelineRasterizationLineStateCreateInfo<'a>;
pub type PipelineRasterizationLineStateCreateInfoEXT<'a> =
    PipelineRasterizationLineStateCreateInfo<'a>;
/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDevicePipelineCreationCacheControlFeatures<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub pipeline_creation_cache_control: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDevicePipelineCreationCacheControlFeatures<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDevicePipelineCreationCacheControlFeatures,
            next: ptr::null_mut(),
            pipeline_creation_cache_control: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePipelineCreationCacheControlFeatures<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDevicePipelineCreationCacheControlFeatures<'_> {}

pub type PhysicalDevicePipelineCreationCacheControlFeaturesEXT<'a> =
    PhysicalDevicePipelineCreationCacheControlFeatures<'a>;
/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceVulkan11Features<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    /// 16-bit integer/floating-point variables supported in BufferBlock
    pub storage_buffer16_bit_access: Bool32,
    /// 16-bit integer/floating-point variables supported in BufferBlock and Block
    pub uniform_and_storage_buffer16_bit_access: Bool32,
    /// 16-bit integer/floating-point variables supported in PushConstant
    pub storage_push_constant16: Bool32,
    /// 16-bit integer/floating-point variables supported in shader inputs and outputs
    pub storage_input_output16: Bool32,
    /// Multiple views in a render pass
    pub multiview: Bool32,
    /// Multiple views in a render pass w/ geometry shader
    pub multiview_geometry_shader: Bool32,
    /// Multiple views in a render pass w/ tessellation shader
    pub multiview_tessellation_shader: Bool32,
    pub variable_pointers_storage_buffer: Bool32,
    pub variable_pointers: Bool32,
    pub protected_memory: Bool32,
    /// Sampler color conversion supported
    pub sampler_ycbcr_conversion: Bool32,
    pub shader_draw_parameters: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceVulkan11Features<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceVulkan11Features,
            next: ptr::null_mut(),
            storage_buffer16_bit_access: FALSE,
            uniform_and_storage_buffer16_bit_access: FALSE,
            storage_push_constant16: FALSE,
            storage_input_output16: FALSE,
            multiview: FALSE,
            multiview_geometry_shader: FALSE,
            multiview_tessellation_shader: FALSE,
            variable_pointers_storage_buffer: FALSE,
            variable_pointers: FALSE,
            protected_memory: FALSE,
            sampler_ycbcr_conversion: FALSE,
            shader_draw_parameters: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVulkan11Features<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceVulkan11Features<'_> {}

/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceVulkan11Properties<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub device_uuid: [u8; UUID_SIZE as usize],
    pub driver_uuid: [u8; UUID_SIZE as usize],
    pub device_luid: [u8; LUID_SIZE as usize],
    pub device_node_mask: u32,
    pub device_luid_valid: Bool32,
    /// The size of a subgroup for this queue.
    pub subgroup_size: u32,
    /// Bitfield of what shader stages support subgroup operations
    pub subgroup_supported_stages: ShaderStageFlags,
    /// Bitfield of what subgroup operations are supported.
    pub subgroup_supported_operations: SubgroupFeatureFlags,
    /// Flag to specify whether quad operations are available in all stages.
    pub subgroup_quad_operations_in_all_stages: Bool32,
    pub point_clipping_behavior: PointClippingBehavior,
    /// max number of views in a subpass
    pub max_multiview_view_count: u32,
    /// max instance index for a draw in a multiview subpass
    pub max_multiview_instance_index: u32,
    pub protected_no_fault: Bool32,
    pub max_per_set_descriptors: u32,
    pub max_memory_allocation_size: DeviceSize,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceVulkan11Properties<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceVulkan11Properties,
            next: ptr::null_mut(),
            device_uuid: unsafe { mem::zeroed() },
            driver_uuid: unsafe { mem::zeroed() },
            device_luid: unsafe { mem::zeroed() },
            device_node_mask: 0,
            device_luid_valid: FALSE,
            subgroup_size: 0,
            subgroup_supported_stages: Default::default(),
            subgroup_supported_operations: Default::default(),
            subgroup_quad_operations_in_all_stages: FALSE,
            point_clipping_behavior: Default::default(),
            max_multiview_view_count: 0,
            max_multiview_instance_index: 0,
            protected_no_fault: FALSE,
            max_per_set_descriptors: 0,
            max_memory_allocation_size: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceVulkan11Properties<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceVulkan12Features<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub sampler_mirror_clamp_to_edge: Bool32,
    pub draw_indirect_count: Bool32,
    /// 8-bit integer variables supported in StorageBuffer
    pub storage_buffer8_bit_access: Bool32,
    /// 8-bit integer variables supported in StorageBuffer and Uniform
    pub uniform_and_storage_buffer8_bit_access: Bool32,
    /// 8-bit integer variables supported in PushConstant
    pub storage_push_constant8: Bool32,
    pub shader_buffer_int64_atomics: Bool32,
    pub shader_shared_int64_atomics: Bool32,
    /// 16-bit floats (halfs) in shaders
    pub shader_float16: Bool32,
    /// 8-bit integers in shaders
    pub shader_int8: Bool32,
    pub descriptor_indexing: Bool32,
    pub shader_input_attachment_array_dynamic_indexing: Bool32,
    pub shader_uniform_texel_buffer_array_dynamic_indexing: Bool32,
    pub shader_storage_texel_buffer_array_dynamic_indexing: Bool32,
    pub shader_uniform_buffer_array_non_uniform_indexing: Bool32,
    pub shader_sampled_image_array_non_uniform_indexing: Bool32,
    pub shader_storage_buffer_array_non_uniform_indexing: Bool32,
    pub shader_storage_image_array_non_uniform_indexing: Bool32,
    pub shader_input_attachment_array_non_uniform_indexing: Bool32,
    pub shader_uniform_texel_buffer_array_non_uniform_indexing: Bool32,
    pub shader_storage_texel_buffer_array_non_uniform_indexing: Bool32,
    pub descriptor_binding_uniform_buffer_update_after_bind: Bool32,
    pub descriptor_binding_sampled_image_update_after_bind: Bool32,
    pub descriptor_binding_storage_image_update_after_bind: Bool32,
    pub descriptor_binding_storage_buffer_update_after_bind: Bool32,
    pub descriptor_binding_uniform_texel_buffer_update_after_bind: Bool32,
    pub descriptor_binding_storage_texel_buffer_update_after_bind: Bool32,
    pub descriptor_binding_update_unused_while_pending: Bool32,
    pub descriptor_binding_partially_bound: Bool32,
    pub descriptor_binding_variable_descriptor_count: Bool32,
    pub runtime_descriptor_array: Bool32,
    pub sampler_filter_minmax: Bool32,
    pub scalar_block_layout: Bool32,
    pub imageless_framebuffer: Bool32,
    pub uniform_buffer_standard_layout: Bool32,
    pub shader_subgroup_extended_types: Bool32,
    pub separate_depth_stencil_layouts: Bool32,
    pub host_query_reset: Bool32,
    pub timeline_semaphore: Bool32,
    pub buffer_device_address: Bool32,
    pub buffer_device_address_capture_replay: Bool32,
    pub buffer_device_address_multi_device: Bool32,
    pub vulkan_memory_model: Bool32,
    pub vulkan_memory_model_device_scope: Bool32,
    pub vulkan_memory_model_availability_visibility_chains: Bool32,
    pub shader_output_viewport_index: Bool32,
    pub shader_output_layer: Bool32,
    pub subgroup_broadcast_dynamic_id: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceVulkan12Features<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceVulkan12Features,
            next: ptr::null_mut(),
            sampler_mirror_clamp_to_edge: FALSE,
            draw_indirect_count: FALSE,
            storage_buffer8_bit_access: FALSE,
            uniform_and_storage_buffer8_bit_access: FALSE,
            storage_push_constant8: FALSE,
            shader_buffer_int64_atomics: FALSE,
            shader_shared_int64_atomics: FALSE,
            shader_float16: FALSE,
            shader_int8: FALSE,
            descriptor_indexing: FALSE,
            shader_input_attachment_array_dynamic_indexing: FALSE,
            shader_uniform_texel_buffer_array_dynamic_indexing: FALSE,
            shader_storage_texel_buffer_array_dynamic_indexing: FALSE,
            shader_uniform_buffer_array_non_uniform_indexing: FALSE,
            shader_sampled_image_array_non_uniform_indexing: FALSE,
            shader_storage_buffer_array_non_uniform_indexing: FALSE,
            shader_storage_image_array_non_uniform_indexing: FALSE,
            shader_input_attachment_array_non_uniform_indexing: FALSE,
            shader_uniform_texel_buffer_array_non_uniform_indexing: FALSE,
            shader_storage_texel_buffer_array_non_uniform_indexing: FALSE,
            descriptor_binding_uniform_buffer_update_after_bind: FALSE,
            descriptor_binding_sampled_image_update_after_bind: FALSE,
            descriptor_binding_storage_image_update_after_bind: FALSE,
            descriptor_binding_storage_buffer_update_after_bind: FALSE,
            descriptor_binding_uniform_texel_buffer_update_after_bind: FALSE,
            descriptor_binding_storage_texel_buffer_update_after_bind: FALSE,
            descriptor_binding_update_unused_while_pending: FALSE,
            descriptor_binding_partially_bound: FALSE,
            descriptor_binding_variable_descriptor_count: FALSE,
            runtime_descriptor_array: FALSE,
            sampler_filter_minmax: FALSE,
            scalar_block_layout: FALSE,
            imageless_framebuffer: FALSE,
            uniform_buffer_standard_layout: FALSE,
            shader_subgroup_extended_types: FALSE,
            separate_depth_stencil_layouts: FALSE,
            host_query_reset: FALSE,
            timeline_semaphore: FALSE,
            buffer_device_address: FALSE,
            buffer_device_address_capture_replay: FALSE,
            buffer_device_address_multi_device: FALSE,
            vulkan_memory_model: FALSE,
            vulkan_memory_model_device_scope: FALSE,
            vulkan_memory_model_availability_visibility_chains: FALSE,
            shader_output_viewport_index: FALSE,
            shader_output_layer: FALSE,
            subgroup_broadcast_dynamic_id: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVulkan12Features<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceVulkan12Features<'_> {}

/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceVulkan12Properties<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub driver_id: DriverId,
    /// Len: null-terminated
    pub driver_name: [c_char; MAX_DRIVER_NAME_SIZE as usize],
    /// Len: null-terminated
    pub driver_info: [c_char; MAX_DRIVER_INFO_SIZE as usize],
    pub conformance_version: ConformanceVersion,
    pub denorm_behavior_independence: ShaderFloatControlsIndependence,
    pub rounding_mode_independence: ShaderFloatControlsIndependence,
    /// An implementation can preserve signed zero, nan, inf
    pub shader_signed_zero_inf_nan_preserve_float16: Bool32,
    /// An implementation can preserve signed zero, nan, inf
    pub shader_signed_zero_inf_nan_preserve_float32: Bool32,
    /// An implementation can preserve signed zero, nan, inf
    pub shader_signed_zero_inf_nan_preserve_float64: Bool32,
    /// An implementation can preserve  denormals
    pub shader_denorm_preserve_float16: Bool32,
    /// An implementation can preserve  denormals
    pub shader_denorm_preserve_float32: Bool32,
    /// An implementation can preserve  denormals
    pub shader_denorm_preserve_float64: Bool32,
    /// An implementation can flush to zero  denormals
    pub shader_denorm_flush_to_zero_float16: Bool32,
    /// An implementation can flush to zero  denormals
    pub shader_denorm_flush_to_zero_float32: Bool32,
    /// An implementation can flush to zero  denormals
    pub shader_denorm_flush_to_zero_float64: Bool32,
    /// An implementation can support RTE
    pub shader_rounding_mode_rte_float16: Bool32,
    /// An implementation can support RTE
    pub shader_rounding_mode_rte_float32: Bool32,
    /// An implementation can support RTE
    pub shader_rounding_mode_rte_float64: Bool32,
    /// An implementation can support RTZ
    pub shader_rounding_mode_rtz_float16: Bool32,
    /// An implementation can support RTZ
    pub shader_rounding_mode_rtz_float32: Bool32,
    /// An implementation can support RTZ
    pub shader_rounding_mode_rtz_float64: Bool32,
    pub max_update_after_bind_descriptors_in_all_pools: u32,
    pub shader_uniform_buffer_array_non_uniform_indexing_native: Bool32,
    pub shader_sampled_image_array_non_uniform_indexing_native: Bool32,
    pub shader_storage_buffer_array_non_uniform_indexing_native: Bool32,
    pub shader_storage_image_array_non_uniform_indexing_native: Bool32,
    pub shader_input_attachment_array_non_uniform_indexing_native: Bool32,
    pub robust_buffer_access_update_after_bind: Bool32,
    pub quad_divergent_implicit_lod: Bool32,
    pub max_per_stage_descriptor_update_after_bind_samplers: u32,
    pub max_per_stage_descriptor_update_after_bind_uniform_buffers: u32,
    pub max_per_stage_descriptor_update_after_bind_storage_buffers: u32,
    pub max_per_stage_descriptor_update_after_bind_sampled_images: u32,
    pub max_per_stage_descriptor_update_after_bind_storage_images: u32,
    pub max_per_stage_descriptor_update_after_bind_input_attachments: u32,
    pub max_per_stage_update_after_bind_resources: u32,
    pub max_descriptor_set_update_after_bind_samplers: u32,
    pub max_descriptor_set_update_after_bind_uniform_buffers: u32,
    pub max_descriptor_set_update_after_bind_uniform_buffers_dynamic: u32,
    pub max_descriptor_set_update_after_bind_storage_buffers: u32,
    pub max_descriptor_set_update_after_bind_storage_buffers_dynamic: u32,
    pub max_descriptor_set_update_after_bind_sampled_images: u32,
    pub max_descriptor_set_update_after_bind_storage_images: u32,
    pub max_descriptor_set_update_after_bind_input_attachments: u32,
    /// supported depth resolve modes
    pub supported_depth_resolve_modes: ResolveModeFlags,
    /// supported stencil resolve modes
    pub supported_stencil_resolve_modes: ResolveModeFlags,
    /// depth and stencil resolve modes can be set independently if one of them is none
    pub independent_resolve_none: Bool32,
    /// depth and stencil resolve modes can be set independently
    pub independent_resolve: Bool32,
    pub filter_minmax_single_component_formats: Bool32,
    pub filter_minmax_image_component_mapping: Bool32,
    pub max_timeline_semaphore_value_difference: u64,
    pub framebuffer_integer_color_sample_counts: SampleCountFlags,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceVulkan12Properties<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceVulkan12Properties,
            next: ptr::null_mut(),
            driver_id: Default::default(),
            driver_name: unsafe { mem::zeroed() },
            driver_info: unsafe { mem::zeroed() },
            conformance_version: Default::default(),
            denorm_behavior_independence: Default::default(),
            rounding_mode_independence: Default::default(),
            shader_signed_zero_inf_nan_preserve_float16: FALSE,
            shader_signed_zero_inf_nan_preserve_float32: FALSE,
            shader_signed_zero_inf_nan_preserve_float64: FALSE,
            shader_denorm_preserve_float16: FALSE,
            shader_denorm_preserve_float32: FALSE,
            shader_denorm_preserve_float64: FALSE,
            shader_denorm_flush_to_zero_float16: FALSE,
            shader_denorm_flush_to_zero_float32: FALSE,
            shader_denorm_flush_to_zero_float64: FALSE,
            shader_rounding_mode_rte_float16: FALSE,
            shader_rounding_mode_rte_float32: FALSE,
            shader_rounding_mode_rte_float64: FALSE,
            shader_rounding_mode_rtz_float16: FALSE,
            shader_rounding_mode_rtz_float32: FALSE,
            shader_rounding_mode_rtz_float64: FALSE,
            max_update_after_bind_descriptors_in_all_pools: 0,
            shader_uniform_buffer_array_non_uniform_indexing_native: FALSE,
            shader_sampled_image_array_non_uniform_indexing_native: FALSE,
            shader_storage_buffer_array_non_uniform_indexing_native: FALSE,
            shader_storage_image_array_non_uniform_indexing_native: FALSE,
            shader_input_attachment_array_non_uniform_indexing_native: FALSE,
            robust_buffer_access_update_after_bind: FALSE,
            quad_divergent_implicit_lod: FALSE,
            max_per_stage_descriptor_update_after_bind_samplers: 0,
            max_per_stage_descriptor_update_after_bind_uniform_buffers: 0,
            max_per_stage_descriptor_update_after_bind_storage_buffers: 0,
            max_per_stage_descriptor_update_after_bind_sampled_images: 0,
            max_per_stage_descriptor_update_after_bind_storage_images: 0,
            max_per_stage_descriptor_update_after_bind_input_attachments: 0,
            max_per_stage_update_after_bind_resources: 0,
            max_descriptor_set_update_after_bind_samplers: 0,
            max_descriptor_set_update_after_bind_uniform_buffers: 0,
            max_descriptor_set_update_after_bind_uniform_buffers_dynamic: 0,
            max_descriptor_set_update_after_bind_storage_buffers: 0,
            max_descriptor_set_update_after_bind_storage_buffers_dynamic: 0,
            max_descriptor_set_update_after_bind_sampled_images: 0,
            max_descriptor_set_update_after_bind_storage_images: 0,
            max_descriptor_set_update_after_bind_input_attachments: 0,
            supported_depth_resolve_modes: Default::default(),
            supported_stencil_resolve_modes: Default::default(),
            independent_resolve_none: FALSE,
            independent_resolve: FALSE,
            filter_minmax_single_component_formats: FALSE,
            filter_minmax_image_component_mapping: FALSE,
            max_timeline_semaphore_value_difference: 0,
            framebuffer_integer_color_sample_counts: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceVulkan12Properties<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceVulkan13Features<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub robust_image_access: Bool32,
    pub inline_uniform_block: Bool32,
    pub descriptor_binding_inline_uniform_block_update_after_bind: Bool32,
    pub pipeline_creation_cache_control: Bool32,
    pub private_data: Bool32,
    pub shader_demote_to_helper_invocation: Bool32,
    pub shader_terminate_invocation: Bool32,
    pub subgroup_size_control: Bool32,
    pub compute_full_subgroups: Bool32,
    pub synchronization2: Bool32,
    pub texture_compression_astc_hdr: Bool32,
    pub shader_zero_initialize_workgroup_memory: Bool32,
    pub dynamic_rendering: Bool32,
    pub shader_integer_dot_product: Bool32,
    pub maintenance4: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceVulkan13Features<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceVulkan13Features,
            next: ptr::null_mut(),
            robust_image_access: FALSE,
            inline_uniform_block: FALSE,
            descriptor_binding_inline_uniform_block_update_after_bind: FALSE,
            pipeline_creation_cache_control: FALSE,
            private_data: FALSE,
            shader_demote_to_helper_invocation: FALSE,
            shader_terminate_invocation: FALSE,
            subgroup_size_control: FALSE,
            compute_full_subgroups: FALSE,
            synchronization2: FALSE,
            texture_compression_astc_hdr: FALSE,
            shader_zero_initialize_workgroup_memory: FALSE,
            dynamic_rendering: FALSE,
            shader_integer_dot_product: FALSE,
            maintenance4: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVulkan13Features<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceVulkan13Features<'_> {}

/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceVulkan13Properties<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    /// The minimum subgroup size supported by this device
    pub min_subgroup_size: u32,
    /// The maximum subgroup size supported by this device
    pub max_subgroup_size: u32,
    /// The maximum number of subgroups supported in a workgroup
    pub max_compute_workgroup_subgroups: u32,
    /// The shader stages that support specifying a subgroup size
    pub required_subgroup_size_stages: ShaderStageFlags,
    pub max_inline_uniform_block_size: u32,
    pub max_per_stage_descriptor_inline_uniform_blocks: u32,
    pub max_per_stage_descriptor_update_after_bind_inline_uniform_blocks: u32,
    pub max_descriptor_set_inline_uniform_blocks: u32,
    pub max_descriptor_set_update_after_bind_inline_uniform_blocks: u32,
    pub max_inline_uniform_total_size: u32,
    pub integer_dot_product8_bit_unsigned_accelerated: Bool32,
    pub integer_dot_product8_bit_signed_accelerated: Bool32,
    pub integer_dot_product8_bit_mixed_signedness_accelerated: Bool32,
    pub integer_dot_product4x8_bit_packed_unsigned_accelerated: Bool32,
    pub integer_dot_product4x8_bit_packed_signed_accelerated: Bool32,
    pub integer_dot_product4x8_bit_packed_mixed_signedness_accelerated: Bool32,
    pub integer_dot_product16_bit_unsigned_accelerated: Bool32,
    pub integer_dot_product16_bit_signed_accelerated: Bool32,
    pub integer_dot_product16_bit_mixed_signedness_accelerated: Bool32,
    pub integer_dot_product32_bit_unsigned_accelerated: Bool32,
    pub integer_dot_product32_bit_signed_accelerated: Bool32,
    pub integer_dot_product32_bit_mixed_signedness_accelerated: Bool32,
    pub integer_dot_product64_bit_unsigned_accelerated: Bool32,
    pub integer_dot_product64_bit_signed_accelerated: Bool32,
    pub integer_dot_product64_bit_mixed_signedness_accelerated: Bool32,
    pub integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated: Bool32,
    pub integer_dot_product_accumulating_saturating8_bit_signed_accelerated: Bool32,
    pub integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated: Bool32,
    pub integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated: Bool32,
    pub integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated: Bool32,
    pub integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated:
        Bool32,
    pub integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated: Bool32,
    pub integer_dot_product_accumulating_saturating16_bit_signed_accelerated: Bool32,
    pub integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated: Bool32,
    pub integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated: Bool32,
    pub integer_dot_product_accumulating_saturating32_bit_signed_accelerated: Bool32,
    pub integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated: Bool32,
    pub integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated: Bool32,
    pub integer_dot_product_accumulating_saturating64_bit_signed_accelerated: Bool32,
    pub integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated: Bool32,
    pub storage_texel_buffer_offset_alignment_bytes: DeviceSize,
    pub storage_texel_buffer_offset_single_texel_alignment: Bool32,
    pub uniform_texel_buffer_offset_alignment_bytes: DeviceSize,
    pub uniform_texel_buffer_offset_single_texel_alignment: Bool32,
    pub max_buffer_size: DeviceSize,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceVulkan13Properties<'_> {
    fn default() -> Self {
        Self {
s_type: StructureType::PhysicalDeviceVulkan13Properties,
next: ptr::null_mut(),
min_subgroup_size: 0,
max_subgroup_size: 0,
max_compute_workgroup_subgroups: 0,
required_subgroup_size_stages: Default::default(),
max_inline_uniform_block_size: 0,
max_per_stage_descriptor_inline_uniform_blocks: 0,
max_per_stage_descriptor_update_after_bind_inline_uniform_blocks: 0,
max_descriptor_set_inline_uniform_blocks: 0,
max_descriptor_set_update_after_bind_inline_uniform_blocks: 0,
max_inline_uniform_total_size: 0,
integer_dot_product8_bit_unsigned_accelerated: FALSE,
integer_dot_product8_bit_signed_accelerated: FALSE,
integer_dot_product8_bit_mixed_signedness_accelerated: FALSE,
integer_dot_product4x8_bit_packed_unsigned_accelerated: FALSE,
integer_dot_product4x8_bit_packed_signed_accelerated: FALSE,
integer_dot_product4x8_bit_packed_mixed_signedness_accelerated: FALSE,
integer_dot_product16_bit_unsigned_accelerated: FALSE,
integer_dot_product16_bit_signed_accelerated: FALSE,
integer_dot_product16_bit_mixed_signedness_accelerated: FALSE,
integer_dot_product32_bit_unsigned_accelerated: FALSE,
integer_dot_product32_bit_signed_accelerated: FALSE,
integer_dot_product32_bit_mixed_signedness_accelerated: FALSE,
integer_dot_product64_bit_unsigned_accelerated: FALSE,
integer_dot_product64_bit_signed_accelerated: FALSE,
integer_dot_product64_bit_mixed_signedness_accelerated: FALSE,
integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated: FALSE,
integer_dot_product_accumulating_saturating8_bit_signed_accelerated: FALSE,
integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated: FALSE,
integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated: FALSE,
integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated: FALSE,
integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated: FALSE,
integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated: FALSE,
integer_dot_product_accumulating_saturating16_bit_signed_accelerated: FALSE,
integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated: FALSE,
integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated: FALSE,
integer_dot_product_accumulating_saturating32_bit_signed_accelerated: FALSE,
integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated: FALSE,
integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated: FALSE,
integer_dot_product_accumulating_saturating64_bit_signed_accelerated: FALSE,
integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated: FALSE,
storage_texel_buffer_offset_alignment_bytes: Default::default(),
storage_texel_buffer_offset_single_texel_alignment: FALSE,
uniform_texel_buffer_offset_alignment_bytes: Default::default(),
uniform_texel_buffer_offset_single_texel_alignment: FALSE,
max_buffer_size: Default::default(),
_marker: PhantomData,
}
    }
}

impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceVulkan13Properties<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceVulkan14Features<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub global_priority_query: Bool32,
    pub shader_subgroup_rotate: Bool32,
    pub shader_subgroup_rotate_clustered: Bool32,
    pub shader_float_controls2: Bool32,
    pub shader_expect_assume: Bool32,
    pub rectangular_lines: Bool32,
    pub bresenham_lines: Bool32,
    pub smooth_lines: Bool32,
    pub stippled_rectangular_lines: Bool32,
    pub stippled_bresenham_lines: Bool32,
    pub stippled_smooth_lines: Bool32,
    pub vertex_attribute_instance_rate_divisor: Bool32,
    pub vertex_attribute_instance_rate_zero_divisor: Bool32,
    pub index_type_uint8: Bool32,
    pub dynamic_rendering_local_read: Bool32,
    pub maintenance5: Bool32,
    pub maintenance6: Bool32,
    pub pipeline_protected_access: Bool32,
    pub pipeline_robustness: Bool32,
    pub host_image_copy: Bool32,
    pub push_descriptor: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceVulkan14Features<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceVulkan14Features,
            next: ptr::null_mut(),
            global_priority_query: FALSE,
            shader_subgroup_rotate: FALSE,
            shader_subgroup_rotate_clustered: FALSE,
            shader_float_controls2: FALSE,
            shader_expect_assume: FALSE,
            rectangular_lines: FALSE,
            bresenham_lines: FALSE,
            smooth_lines: FALSE,
            stippled_rectangular_lines: FALSE,
            stippled_bresenham_lines: FALSE,
            stippled_smooth_lines: FALSE,
            vertex_attribute_instance_rate_divisor: FALSE,
            vertex_attribute_instance_rate_zero_divisor: FALSE,
            index_type_uint8: FALSE,
            dynamic_rendering_local_read: FALSE,
            maintenance5: FALSE,
            maintenance6: FALSE,
            pipeline_protected_access: FALSE,
            pipeline_robustness: FALSE,
            host_image_copy: FALSE,
            push_descriptor: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVulkan14Features<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceVulkan14Features<'_> {}

/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceVulkan14Properties<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub line_sub_pixel_precision_bits: u32,
    /// max value of vertex attribute divisor
    pub max_vertex_attrib_divisor: u32,
    pub supports_non_zero_first_instance: Bool32,
    pub max_push_descriptors: u32,
    pub dynamic_rendering_local_read_depth_stencil_attachments: Bool32,
    pub dynamic_rendering_local_read_multisampled_attachments: Bool32,
    pub early_fragment_multisample_coverage_after_sample_counting: Bool32,
    pub early_fragment_sample_mask_test_before_sample_counting: Bool32,
    pub depth_stencil_swizzle_one_support: Bool32,
    pub polygon_mode_point_size: Bool32,
    pub non_strict_single_pixel_wide_lines_use_parallelogram: Bool32,
    pub non_strict_wide_lines_use_parallelogram: Bool32,
    pub block_texel_view_compatible_multiple_layers: Bool32,
    pub max_combined_image_sampler_descriptor_count: u32,
    pub fragment_shading_rate_clamp_combiner_inputs: Bool32,
    pub default_robustness_storage_buffers: PipelineRobustnessBufferBehavior,
    pub default_robustness_uniform_buffers: PipelineRobustnessBufferBehavior,
    pub default_robustness_vertex_inputs: PipelineRobustnessBufferBehavior,
    pub default_robustness_images: PipelineRobustnessImageBehavior,
    pub copy_src_layout_count: u32,
    /// Nullable
    /// Len: `copy_src_layout_count`
    pub copy_src_layouts: *mut ImageLayout,
    pub copy_dst_layout_count: u32,
    /// Nullable
    /// Len: `copy_dst_layout_count`
    pub copy_dst_layouts: *mut ImageLayout,
    pub optimal_tiling_layout_uuid: [u8; UUID_SIZE as usize],
    pub identical_memory_type_requirements: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceVulkan14Properties<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceVulkan14Properties,
            next: ptr::null_mut(),
            line_sub_pixel_precision_bits: 0,
            max_vertex_attrib_divisor: 0,
            supports_non_zero_first_instance: FALSE,
            max_push_descriptors: 0,
            dynamic_rendering_local_read_depth_stencil_attachments: FALSE,
            dynamic_rendering_local_read_multisampled_attachments: FALSE,
            early_fragment_multisample_coverage_after_sample_counting: FALSE,
            early_fragment_sample_mask_test_before_sample_counting: FALSE,
            depth_stencil_swizzle_one_support: FALSE,
            polygon_mode_point_size: FALSE,
            non_strict_single_pixel_wide_lines_use_parallelogram: FALSE,
            non_strict_wide_lines_use_parallelogram: FALSE,
            block_texel_view_compatible_multiple_layers: FALSE,
            max_combined_image_sampler_descriptor_count: 0,
            fragment_shading_rate_clamp_combiner_inputs: FALSE,
            default_robustness_storage_buffers: Default::default(),
            default_robustness_uniform_buffers: Default::default(),
            default_robustness_vertex_inputs: Default::default(),
            default_robustness_images: Default::default(),
            copy_src_layout_count: 0,
            copy_src_layouts: ptr::null_mut(),
            copy_dst_layout_count: 0,
            copy_dst_layouts: ptr::null_mut(),
            optimal_tiling_layout_uuid: unsafe { mem::zeroed() },
            identical_memory_type_requirements: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceVulkan14Properties<'_> {}

/// Extends: `GraphicsPipelineCreateInfo`, `ComputePipelineCreateInfo`, `ExecutionGraphPipelineCreateInfoAMDX`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PipelineCompilerControlCreateInfoAMD<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub compiler_control_flags: PipelineCompilerControlFlagsAMD,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PipelineCompilerControlCreateInfoAMD<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PipelineCompilerControlCreateInfoAMD,
            next: ptr::null_mut(),
            compiler_control_flags: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsGraphicsPipelineCreateInfo for PipelineCompilerControlCreateInfoAMD<'_> {}
impl ExtendsComputePipelineCreateInfo for PipelineCompilerControlCreateInfoAMD<'_> {}
impl ExtendsExecutionGraphPipelineCreateInfoAMDX for PipelineCompilerControlCreateInfoAMD<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceCoherentMemoryFeaturesAMD<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub device_coherent_memory: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceCoherentMemoryFeaturesAMD<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceCoherentMemoryFeaturesAMD,
            next: ptr::null_mut(),
            device_coherent_memory: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceCoherentMemoryFeaturesAMD<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceCoherentMemoryFeaturesAMD<'_> {}

/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct FaultData<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub fault_level: FaultLevel,
    pub fault_type: FaultType,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for FaultData<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::FaultData,
            next: ptr::null_mut(),
            fault_level: Default::default(),
            fault_type: Default::default(),
            _marker: PhantomData,
        }
    }
}

/// Extends: `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct FaultCallbackInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub fault_count: u32,
    /// Nullable
    /// Len: `fault_count`
    pub faults: *mut FaultData<'a>,
    pub pfn_fault_callback: PFN_vkFaultCallbackFunction,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for FaultCallbackInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::FaultCallbackInfo,
            next: ptr::null_mut(),
            fault_count: 0,
            faults: ptr::null_mut(),
            pfn_fault_callback: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsDeviceCreateInfo for FaultCallbackInfo<'_> {}

/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceToolProperties<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    /// Len: null-terminated
    pub name: [c_char; MAX_EXTENSION_NAME_SIZE as usize],
    /// Len: null-terminated
    pub version: [c_char; MAX_EXTENSION_NAME_SIZE as usize],
    pub purposes: ToolPurposeFlags,
    /// Len: null-terminated
    pub description: [c_char; MAX_DESCRIPTION_SIZE as usize],
    /// Len: null-terminated
    pub layer: [c_char; MAX_EXTENSION_NAME_SIZE as usize],
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceToolProperties<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceToolProperties,
            next: ptr::null_mut(),
            name: unsafe { mem::zeroed() },
            version: unsafe { mem::zeroed() },
            purposes: Default::default(),
            description: unsafe { mem::zeroed() },
            layer: unsafe { mem::zeroed() },
            _marker: PhantomData,
        }
    }
}

pub type PhysicalDeviceToolPropertiesEXT<'a> = PhysicalDeviceToolProperties<'a>;
/// Extends: `SamplerCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct SamplerCustomBorderColorCreateInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub custom_border_color: ClearColorValue,
    pub format: Format,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for SamplerCustomBorderColorCreateInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::SamplerCustomBorderColorCreateInfoEXT,
            next: ptr::null_mut(),
            custom_border_color: Default::default(),
            format: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsSamplerCreateInfo for SamplerCustomBorderColorCreateInfoEXT<'_> {}

/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceCustomBorderColorPropertiesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub max_custom_border_color_samplers: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceCustomBorderColorPropertiesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceCustomBorderColorPropertiesEXT,
            next: ptr::null_mut(),
            max_custom_border_color_samplers: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceCustomBorderColorPropertiesEXT<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceCustomBorderColorFeaturesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub custom_border_colors: Bool32,
    pub custom_border_color_without_format: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceCustomBorderColorFeaturesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceCustomBorderColorFeaturesEXT,
            next: ptr::null_mut(),
            custom_border_colors: FALSE,
            custom_border_color_without_format: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceCustomBorderColorFeaturesEXT<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceCustomBorderColorFeaturesEXT<'_> {}

/// Extends: `SamplerCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct SamplerBorderColorComponentMappingCreateInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub components: ComponentMapping,
    pub srgb: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for SamplerBorderColorComponentMappingCreateInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::SamplerBorderColorComponentMappingCreateInfoEXT,
            next: ptr::null_mut(),
            components: Default::default(),
            srgb: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsSamplerCreateInfo for SamplerBorderColorComponentMappingCreateInfoEXT<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceBorderColorSwizzleFeaturesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub border_color_swizzle: Bool32,
    pub border_color_swizzle_from_image: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceBorderColorSwizzleFeaturesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceBorderColorSwizzleFeaturesEXT,
            next: ptr::null_mut(),
            border_color_swizzle: FALSE,
            border_color_swizzle_from_image: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceBorderColorSwizzleFeaturesEXT<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceBorderColorSwizzleFeaturesEXT<'_> {}

#[repr(C)]
#[derive(Copy, Clone)]
pub union DeviceOrHostAddressKHR {
    pub device_address: DeviceAddress,
    pub host_address: *mut c_void,
}
impl Default for DeviceOrHostAddressKHR {
    fn default() -> Self {
        unsafe { mem::zeroed() }
    }
}

impl fmt::Debug for DeviceOrHostAddressKHR {
    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
        fmt.debug_struct("DeviceOrHostAddressKHR").finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub union DeviceOrHostAddressConstKHR {
    pub device_address: DeviceAddress,
    pub host_address: *const c_void,
}
impl Default for DeviceOrHostAddressConstKHR {
    fn default() -> Self {
        unsafe { mem::zeroed() }
    }
}

impl fmt::Debug for DeviceOrHostAddressConstKHR {
    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
        fmt.debug_struct("DeviceOrHostAddressConstKHR").finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub union DeviceOrHostAddressConstAMDX {
    pub device_address: DeviceAddress,
    pub host_address: *const c_void,
}
impl Default for DeviceOrHostAddressConstAMDX {
    fn default() -> Self {
        unsafe { mem::zeroed() }
    }
}

impl fmt::Debug for DeviceOrHostAddressConstAMDX {
    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
        fmt.debug_struct("DeviceOrHostAddressConstAMDX").finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct AccelerationStructureGeometryTrianglesDataKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub vertex_format: Format,
    pub vertex_data: DeviceOrHostAddressConstKHR,
    pub vertex_stride: DeviceSize,
    pub max_vertex: u32,
    pub index_type: IndexType,
    pub index_data: DeviceOrHostAddressConstKHR,
    pub transform_data: DeviceOrHostAddressConstKHR,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for AccelerationStructureGeometryTrianglesDataKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::AccelerationStructureGeometryTrianglesDataKHR,
            next: ptr::null_mut(),
            vertex_format: Default::default(),
            vertex_data: Default::default(),
            vertex_stride: Default::default(),
            max_vertex: 0,
            index_type: Default::default(),
            index_data: Default::default(),
            transform_data: Default::default(),
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsAccelerationStructureGeometryTrianglesDataKHR {}
impl<'a> AccelerationStructureGeometryTrianglesDataKHR<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsAccelerationStructureGeometryTrianglesDataKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct AccelerationStructureGeometryAabbsDataKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub data: DeviceOrHostAddressConstKHR,
    pub stride: DeviceSize,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for AccelerationStructureGeometryAabbsDataKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::AccelerationStructureGeometryAabbsDataKHR,
            next: ptr::null_mut(),
            data: Default::default(),
            stride: Default::default(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct AccelerationStructureGeometryInstancesDataKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub array_of_pointers: Bool32,
    pub data: DeviceOrHostAddressConstKHR,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for AccelerationStructureGeometryInstancesDataKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::AccelerationStructureGeometryInstancesDataKHR,
            next: ptr::null_mut(),
            array_of_pointers: FALSE,
            data: Default::default(),
            _marker: PhantomData,
        }
    }
}

/// Extends: `AccelerationStructureGeometryKHR`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct AccelerationStructureGeometryLinearSweptSpheresDataNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub vertex_format: Format,
    pub vertex_data: DeviceOrHostAddressConstKHR,
    pub vertex_stride: DeviceSize,
    pub radius_format: Format,
    pub radius_data: DeviceOrHostAddressConstKHR,
    pub radius_stride: DeviceSize,
    pub index_type: IndexType,
    pub index_data: DeviceOrHostAddressConstKHR,
    pub index_stride: DeviceSize,
    pub indexing_mode: RayTracingLssIndexingModeNV,
    pub end_caps_mode: RayTracingLssPrimitiveEndCapsModeNV,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for AccelerationStructureGeometryLinearSweptSpheresDataNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::AccelerationStructureGeometryLinearSweptSpheresDataNV,
            next: ptr::null_mut(),
            vertex_format: Default::default(),
            vertex_data: Default::default(),
            vertex_stride: Default::default(),
            radius_format: Default::default(),
            radius_data: Default::default(),
            radius_stride: Default::default(),
            index_type: Default::default(),
            index_data: Default::default(),
            index_stride: Default::default(),
            indexing_mode: Default::default(),
            end_caps_mode: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsAccelerationStructureGeometryKHR
    for AccelerationStructureGeometryLinearSweptSpheresDataNV<'_>
{
}

/// Extends: `AccelerationStructureGeometryKHR`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct AccelerationStructureGeometrySpheresDataNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub vertex_format: Format,
    pub vertex_data: DeviceOrHostAddressConstKHR,
    pub vertex_stride: DeviceSize,
    pub radius_format: Format,
    pub radius_data: DeviceOrHostAddressConstKHR,
    pub radius_stride: DeviceSize,
    pub index_type: IndexType,
    pub index_data: DeviceOrHostAddressConstKHR,
    pub index_stride: DeviceSize,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for AccelerationStructureGeometrySpheresDataNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::AccelerationStructureGeometrySpheresDataNV,
            next: ptr::null_mut(),
            vertex_format: Default::default(),
            vertex_data: Default::default(),
            vertex_stride: Default::default(),
            radius_format: Default::default(),
            radius_data: Default::default(),
            radius_stride: Default::default(),
            index_type: Default::default(),
            index_data: Default::default(),
            index_stride: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsAccelerationStructureGeometryKHR for AccelerationStructureGeometrySpheresDataNV<'_> {}

#[repr(C)]
#[derive(Copy, Clone)]
pub union AccelerationStructureGeometryDataKHR<'a> {
    pub triangles: AccelerationStructureGeometryTrianglesDataKHR<'a>,
    pub aabbs: AccelerationStructureGeometryAabbsDataKHR<'a>,
    pub instances: AccelerationStructureGeometryInstancesDataKHR<'a>,
}
impl Default for AccelerationStructureGeometryDataKHR<'_> {
    fn default() -> Self {
        unsafe { mem::zeroed() }
    }
}

impl fmt::Debug for AccelerationStructureGeometryDataKHR<'_> {
    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
        fmt.debug_struct("AccelerationStructureGeometryDataKHR")
            .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct AccelerationStructureGeometryKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub geometry_type: GeometryTypeKHR,
    pub geometry: AccelerationStructureGeometryDataKHR<'a>,
    pub flags: GeometryFlagsKHR,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for AccelerationStructureGeometryKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::AccelerationStructureGeometryKHR,
            next: ptr::null_mut(),
            geometry_type: Default::default(),
            geometry: Default::default(),
            flags: Default::default(),
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsAccelerationStructureGeometryKHR {}
impl<'a> AccelerationStructureGeometryKHR<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsAccelerationStructureGeometryKHR>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct AccelerationStructureBuildGeometryInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub ty: AccelerationStructureTypeKHR,
    pub flags: BuildAccelerationStructureFlagsKHR,
    pub mode: BuildAccelerationStructureModeKHR,
    pub src_acceleration_structure: AccelerationStructureKHR,
    pub dst_acceleration_structure: AccelerationStructureKHR,
    pub geometry_count: u32,
    /// Nullable
    /// Len: `geometry_count`
    pub geometries: *const AccelerationStructureGeometryKHR<'a>,
    /// Nullable
    /// Len: `geometry_count`, `1`
    pub pp_geometries: *const *const AccelerationStructureGeometryKHR<'a>,
    pub scratch_data: DeviceOrHostAddressKHR,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for AccelerationStructureBuildGeometryInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::AccelerationStructureBuildGeometryInfoKHR,
            next: ptr::null_mut(),
            ty: Default::default(),
            flags: Default::default(),
            mode: Default::default(),
            src_acceleration_structure: Default::default(),
            dst_acceleration_structure: Default::default(),
            geometry_count: 0,
            geometries: ptr::null_mut(),
            pp_geometries: ptr::null_mut(),
            scratch_data: Default::default(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct AccelerationStructureBuildRangeInfoKHR {
    pub primitive_count: u32,
    pub primitive_offset: u32,
    pub first_vertex: u32,
    pub transform_offset: u32,
}
impl Default for AccelerationStructureBuildRangeInfoKHR {
    fn default() -> Self {
        Self {
            primitive_count: 0,
            primitive_offset: 0,
            first_vertex: 0,
            transform_offset: 0,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct AccelerationStructureCreateInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub create_flags: AccelerationStructureCreateFlagsKHR,
    pub buffer: Buffer,
    /// Specified in bytes
    pub offset: DeviceSize,
    pub size: DeviceSize,
    pub ty: AccelerationStructureTypeKHR,
    pub device_address: DeviceAddress,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for AccelerationStructureCreateInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::AccelerationStructureCreateInfoKHR,
            next: ptr::null_mut(),
            create_flags: Default::default(),
            buffer: Default::default(),
            offset: Default::default(),
            size: Default::default(),
            ty: Default::default(),
            device_address: Default::default(),
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsAccelerationStructureCreateInfoKHR {}
impl<'a> AccelerationStructureCreateInfoKHR<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsAccelerationStructureCreateInfoKHR>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct AabbPositionsKHR {
    pub min_x: f32,
    pub min_y: f32,
    pub min_z: f32,
    pub max_x: f32,
    pub max_y: f32,
    pub max_z: f32,
}
impl Default for AabbPositionsKHR {
    fn default() -> Self {
        Self {
            min_x: 0.0,
            min_y: 0.0,
            min_z: 0.0,
            max_x: 0.0,
            max_y: 0.0,
            max_z: 0.0,
        }
    }
}

pub type AabbPositionsNV = AabbPositionsKHR;
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct TransformMatrixKHR {
    pub matrix: [[f32; 4]; 3],
}
impl Default for TransformMatrixKHR {
    fn default() -> Self {
        Self {
            matrix: unsafe { mem::zeroed() },
        }
    }
}

pub type TransformMatrixNV = TransformMatrixKHR;
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct AccelerationStructureInstanceKHR {
    pub transform: TransformMatrixKHR,
    pub instance_custom_index: u32,
    pub mask: u32,
    pub instance_shader_binding_table_record_offset: u32,
    pub flags: GeometryInstanceFlagsKHR,
    pub acceleration_structure_reference: u64,
}
impl Default for AccelerationStructureInstanceKHR {
    fn default() -> Self {
        Self {
            transform: Default::default(),
            instance_custom_index: 0,
            mask: 0,
            instance_shader_binding_table_record_offset: 0,
            flags: Default::default(),
            acceleration_structure_reference: 0,
        }
    }
}

pub type AccelerationStructureInstanceNV = AccelerationStructureInstanceKHR;
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct AccelerationStructureDeviceAddressInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub acceleration_structure: AccelerationStructureKHR,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for AccelerationStructureDeviceAddressInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::AccelerationStructureDeviceAddressInfoKHR,
            next: ptr::null_mut(),
            acceleration_structure: Default::default(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct AccelerationStructureVersionInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    /// Len: 2 * UUID_SIZE
    pub version_data: *const u8,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for AccelerationStructureVersionInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::AccelerationStructureVersionInfoKHR,
            next: ptr::null_mut(),
            version_data: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct CopyAccelerationStructureInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub src: AccelerationStructureKHR,
    pub dst: AccelerationStructureKHR,
    pub mode: CopyAccelerationStructureModeKHR,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for CopyAccelerationStructureInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::CopyAccelerationStructureInfoKHR,
            next: ptr::null_mut(),
            src: Default::default(),
            dst: Default::default(),
            mode: Default::default(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct CopyAccelerationStructureToMemoryInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub src: AccelerationStructureKHR,
    pub dst: DeviceOrHostAddressKHR,
    pub mode: CopyAccelerationStructureModeKHR,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for CopyAccelerationStructureToMemoryInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::CopyAccelerationStructureToMemoryInfoKHR,
            next: ptr::null_mut(),
            src: Default::default(),
            dst: Default::default(),
            mode: Default::default(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct CopyMemoryToAccelerationStructureInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub src: DeviceOrHostAddressConstKHR,
    pub dst: AccelerationStructureKHR,
    pub mode: CopyAccelerationStructureModeKHR,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for CopyMemoryToAccelerationStructureInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::CopyMemoryToAccelerationStructureInfoKHR,
            next: ptr::null_mut(),
            src: Default::default(),
            dst: Default::default(),
            mode: Default::default(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct RayTracingPipelineInterfaceCreateInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub max_pipeline_ray_payload_size: u32,
    pub max_pipeline_ray_hit_attribute_size: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for RayTracingPipelineInterfaceCreateInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::RayTracingPipelineInterfaceCreateInfoKHR,
            next: ptr::null_mut(),
            max_pipeline_ray_payload_size: 0,
            max_pipeline_ray_hit_attribute_size: 0,
            _marker: PhantomData,
        }
    }
}

/// Extends: `GraphicsPipelineCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PipelineLibraryCreateInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub library_count: u32,
    /// Len: `library_count`
    pub libraries: *const Pipeline,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PipelineLibraryCreateInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PipelineLibraryCreateInfoKHR,
            next: ptr::null_mut(),
            library_count: 0,
            libraries: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsGraphicsPipelineCreateInfo for PipelineLibraryCreateInfoKHR<'_> {}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct RefreshObjectKHR {
    pub object_type: ObjectType,
    pub object_handle: u64,
    pub flags: RefreshObjectFlagsKHR,
}
impl Default for RefreshObjectKHR {
    fn default() -> Self {
        Self {
            object_type: Default::default(),
            object_handle: 0,
            flags: Default::default(),
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct RefreshObjectListKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub object_count: u32,
    /// Len: `object_count`
    pub objects: *const RefreshObjectKHR,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for RefreshObjectListKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::RefreshObjectListKHR,
            next: ptr::null_mut(),
            object_count: 0,
            objects: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceExtendedDynamicStateFeaturesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub extended_dynamic_state: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceExtendedDynamicStateFeaturesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceExtendedDynamicStateFeaturesEXT,
            next: ptr::null_mut(),
            extended_dynamic_state: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceExtendedDynamicStateFeaturesEXT<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceExtendedDynamicStateFeaturesEXT<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceExtendedDynamicState2FeaturesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub extended_dynamic_state2: Bool32,
    pub extended_dynamic_state2_logic_op: Bool32,
    pub extended_dynamic_state2_patch_control_points: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceExtendedDynamicState2FeaturesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceExtendedDynamicState2FeaturesEXT,
            next: ptr::null_mut(),
            extended_dynamic_state2: FALSE,
            extended_dynamic_state2_logic_op: FALSE,
            extended_dynamic_state2_patch_control_points: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceExtendedDynamicState2FeaturesEXT<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceExtendedDynamicState2FeaturesEXT<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceExtendedDynamicState3FeaturesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub extended_dynamic_state3_tessellation_domain_origin: Bool32,
    pub extended_dynamic_state3_depth_clamp_enable: Bool32,
    pub extended_dynamic_state3_polygon_mode: Bool32,
    pub extended_dynamic_state3_rasterization_samples: Bool32,
    pub extended_dynamic_state3_sample_mask: Bool32,
    pub extended_dynamic_state3_alpha_to_coverage_enable: Bool32,
    pub extended_dynamic_state3_alpha_to_one_enable: Bool32,
    pub extended_dynamic_state3_logic_op_enable: Bool32,
    pub extended_dynamic_state3_color_blend_enable: Bool32,
    pub extended_dynamic_state3_color_blend_equation: Bool32,
    pub extended_dynamic_state3_color_write_mask: Bool32,
    pub extended_dynamic_state3_rasterization_stream: Bool32,
    pub extended_dynamic_state3_conservative_rasterization_mode: Bool32,
    pub extended_dynamic_state3_extra_primitive_overestimation_size: Bool32,
    pub extended_dynamic_state3_depth_clip_enable: Bool32,
    pub extended_dynamic_state3_sample_locations_enable: Bool32,
    pub extended_dynamic_state3_color_blend_advanced: Bool32,
    pub extended_dynamic_state3_provoking_vertex_mode: Bool32,
    pub extended_dynamic_state3_line_rasterization_mode: Bool32,
    pub extended_dynamic_state3_line_stipple_enable: Bool32,
    pub extended_dynamic_state3_depth_clip_negative_one_to_one: Bool32,
    pub extended_dynamic_state3_viewport_w_scaling_enable: Bool32,
    pub extended_dynamic_state3_viewport_swizzle: Bool32,
    pub extended_dynamic_state3_coverage_to_color_enable: Bool32,
    pub extended_dynamic_state3_coverage_to_color_location: Bool32,
    pub extended_dynamic_state3_coverage_modulation_mode: Bool32,
    pub extended_dynamic_state3_coverage_modulation_table_enable: Bool32,
    pub extended_dynamic_state3_coverage_modulation_table: Bool32,
    pub extended_dynamic_state3_coverage_reduction_mode: Bool32,
    pub extended_dynamic_state3_representative_fragment_test_enable: Bool32,
    pub extended_dynamic_state3_shading_rate_image_enable: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceExtendedDynamicState3FeaturesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceExtendedDynamicState3FeaturesEXT,
            next: ptr::null_mut(),
            extended_dynamic_state3_tessellation_domain_origin: FALSE,
            extended_dynamic_state3_depth_clamp_enable: FALSE,
            extended_dynamic_state3_polygon_mode: FALSE,
            extended_dynamic_state3_rasterization_samples: FALSE,
            extended_dynamic_state3_sample_mask: FALSE,
            extended_dynamic_state3_alpha_to_coverage_enable: FALSE,
            extended_dynamic_state3_alpha_to_one_enable: FALSE,
            extended_dynamic_state3_logic_op_enable: FALSE,
            extended_dynamic_state3_color_blend_enable: FALSE,
            extended_dynamic_state3_color_blend_equation: FALSE,
            extended_dynamic_state3_color_write_mask: FALSE,
            extended_dynamic_state3_rasterization_stream: FALSE,
            extended_dynamic_state3_conservative_rasterization_mode: FALSE,
            extended_dynamic_state3_extra_primitive_overestimation_size: FALSE,
            extended_dynamic_state3_depth_clip_enable: FALSE,
            extended_dynamic_state3_sample_locations_enable: FALSE,
            extended_dynamic_state3_color_blend_advanced: FALSE,
            extended_dynamic_state3_provoking_vertex_mode: FALSE,
            extended_dynamic_state3_line_rasterization_mode: FALSE,
            extended_dynamic_state3_line_stipple_enable: FALSE,
            extended_dynamic_state3_depth_clip_negative_one_to_one: FALSE,
            extended_dynamic_state3_viewport_w_scaling_enable: FALSE,
            extended_dynamic_state3_viewport_swizzle: FALSE,
            extended_dynamic_state3_coverage_to_color_enable: FALSE,
            extended_dynamic_state3_coverage_to_color_location: FALSE,
            extended_dynamic_state3_coverage_modulation_mode: FALSE,
            extended_dynamic_state3_coverage_modulation_table_enable: FALSE,
            extended_dynamic_state3_coverage_modulation_table: FALSE,
            extended_dynamic_state3_coverage_reduction_mode: FALSE,
            extended_dynamic_state3_representative_fragment_test_enable: FALSE,
            extended_dynamic_state3_shading_rate_image_enable: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceExtendedDynamicState3FeaturesEXT<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceExtendedDynamicState3FeaturesEXT<'_> {}

/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceExtendedDynamicState3PropertiesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub dynamic_primitive_topology_unrestricted: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceExtendedDynamicState3PropertiesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceExtendedDynamicState3PropertiesEXT,
            next: ptr::null_mut(),
            dynamic_primitive_topology_unrestricted: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceExtendedDynamicState3PropertiesEXT<'_> {}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ColorBlendEquationEXT {
    pub src_color_blend_factor: BlendFactor,
    pub dst_color_blend_factor: BlendFactor,
    pub color_blend_op: BlendOp,
    pub src_alpha_blend_factor: BlendFactor,
    pub dst_alpha_blend_factor: BlendFactor,
    pub alpha_blend_op: BlendOp,
}
impl Default for ColorBlendEquationEXT {
    fn default() -> Self {
        Self {
            src_color_blend_factor: Default::default(),
            dst_color_blend_factor: Default::default(),
            color_blend_op: Default::default(),
            src_alpha_blend_factor: Default::default(),
            dst_alpha_blend_factor: Default::default(),
            alpha_blend_op: Default::default(),
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ColorBlendAdvancedEXT {
    pub advanced_blend_op: BlendOp,
    pub src_premultiplied: Bool32,
    pub dst_premultiplied: Bool32,
    pub blend_overlap: BlendOverlapEXT,
    pub clamp_results: Bool32,
}
impl Default for ColorBlendAdvancedEXT {
    fn default() -> Self {
        Self {
            advanced_blend_op: Default::default(),
            src_premultiplied: FALSE,
            dst_premultiplied: FALSE,
            blend_overlap: Default::default(),
            clamp_results: FALSE,
        }
    }
}

/// Extends: `RenderPassBeginInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct RenderPassTransformBeginInfoQCOM<'a> {
    pub s_type: StructureType,
    /// Pointer to next structure
    /// Nullable
    pub next: *const c_void,
    pub transform: SurfaceTransformFlagsKHR,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for RenderPassTransformBeginInfoQCOM<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::RenderPassTransformBeginInfoQCOM,
            next: ptr::null_mut(),
            transform: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsRenderPassBeginInfo for RenderPassTransformBeginInfoQCOM<'_> {}

/// Extends: `BufferImageCopy2`, `ImageBlit2`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct CopyCommandTransformInfoQCOM<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub transform: SurfaceTransformFlagsKHR,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for CopyCommandTransformInfoQCOM<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::CopyCommandTransformInfoQCOM,
            next: ptr::null_mut(),
            transform: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsBufferImageCopy2 for CopyCommandTransformInfoQCOM<'_> {}
impl ExtendsImageBlit2 for CopyCommandTransformInfoQCOM<'_> {}

/// Extends: `CommandBufferInheritanceInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct CommandBufferInheritanceRenderPassTransformInfoQCOM<'a> {
    pub s_type: StructureType,
    /// Pointer to next structure
    /// Nullable
    pub next: *const c_void,
    pub transform: SurfaceTransformFlagsKHR,
    pub render_area: Rect2D,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for CommandBufferInheritanceRenderPassTransformInfoQCOM<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::CommandBufferInheritanceRenderPassTransformInfoQCOM,
            next: ptr::null_mut(),
            transform: Default::default(),
            render_area: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsCommandBufferInheritanceInfo
    for CommandBufferInheritanceRenderPassTransformInfoQCOM<'_>
{
}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDevicePartitionedAccelerationStructureFeaturesNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub partitioned_acceleration_structure: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDevicePartitionedAccelerationStructureFeaturesNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDevicePartitionedAccelerationStructureFeaturesNV,
            next: ptr::null_mut(),
            partitioned_acceleration_structure: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2
    for PhysicalDevicePartitionedAccelerationStructureFeaturesNV<'_>
{
}
impl ExtendsDeviceCreateInfo for PhysicalDevicePartitionedAccelerationStructureFeaturesNV<'_> {}

/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDevicePartitionedAccelerationStructurePropertiesNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub max_partition_count: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDevicePartitionedAccelerationStructurePropertiesNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDevicePartitionedAccelerationStructurePropertiesNV,
            next: ptr::null_mut(),
            max_partition_count: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2
    for PhysicalDevicePartitionedAccelerationStructurePropertiesNV<'_>
{
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct BuildPartitionedAccelerationStructureIndirectCommandNV {
    pub op_type: PartitionedAccelerationStructureOpTypeNV,
    pub arg_count: u32,
    pub arg_data: StridedDeviceAddressNV,
}
impl Default for BuildPartitionedAccelerationStructureIndirectCommandNV {
    fn default() -> Self {
        Self {
            op_type: Default::default(),
            arg_count: 0,
            arg_data: Default::default(),
        }
    }
}

/// Extends: `PartitionedAccelerationStructureInstancesInputNV`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PartitionedAccelerationStructureFlagsNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub enable_partition_translation: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PartitionedAccelerationStructureFlagsNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PartitionedAccelerationStructureFlagsNV,
            next: ptr::null_mut(),
            enable_partition_translation: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPartitionedAccelerationStructureInstancesInputNV
    for PartitionedAccelerationStructureFlagsNV<'_>
{
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PartitionedAccelerationStructureWriteInstanceDataNV {
    pub transform: TransformMatrixKHR,
    pub explicit_aabb: [f32; 6],
    pub instance_id: u32,
    pub instance_mask: u32,
    pub instance_contribution_to_hit_group_index: u32,
    pub instance_flags: PartitionedAccelerationStructureInstanceFlagsNV,
    pub instance_index: u32,
    pub partition_index: u32,
    pub acceleration_structure: DeviceAddress,
}
impl Default for PartitionedAccelerationStructureWriteInstanceDataNV {
    fn default() -> Self {
        Self {
            transform: Default::default(),
            explicit_aabb: unsafe { mem::zeroed() },
            instance_id: 0,
            instance_mask: 0,
            instance_contribution_to_hit_group_index: 0,
            instance_flags: Default::default(),
            instance_index: 0,
            partition_index: 0,
            acceleration_structure: Default::default(),
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PartitionedAccelerationStructureUpdateInstanceDataNV {
    pub instance_index: u32,
    pub instance_contribution_to_hit_group_index: u32,
    pub acceleration_structure: DeviceAddress,
}
impl Default for PartitionedAccelerationStructureUpdateInstanceDataNV {
    fn default() -> Self {
        Self {
            instance_index: 0,
            instance_contribution_to_hit_group_index: 0,
            acceleration_structure: Default::default(),
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PartitionedAccelerationStructureWritePartitionTranslationDataNV {
    pub partition_index: u32,
    pub partition_translation: [f32; 3],
}
impl Default for PartitionedAccelerationStructureWritePartitionTranslationDataNV {
    fn default() -> Self {
        Self {
            partition_index: 0,
            partition_translation: unsafe { mem::zeroed() },
        }
    }
}

/// Extends: `WriteDescriptorSet`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct WriteDescriptorSetPartitionedAccelerationStructureNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub acceleration_structure_count: u32,
    /// Nullable
    /// Len: `acceleration_structure_count`
    pub acceleration_structures: *const DeviceAddress,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for WriteDescriptorSetPartitionedAccelerationStructureNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::WriteDescriptorSetPartitionedAccelerationStructureNV,
            next: ptr::null_mut(),
            acceleration_structure_count: 0,
            acceleration_structures: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsWriteDescriptorSet for WriteDescriptorSetPartitionedAccelerationStructureNV<'_> {}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PartitionedAccelerationStructureInstancesInputNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub flags: BuildAccelerationStructureFlagsKHR,
    pub instance_count: u32,
    pub max_instance_per_partition_count: u32,
    pub partition_count: u32,
    pub max_instance_in_global_partition_count: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PartitionedAccelerationStructureInstancesInputNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PartitionedAccelerationStructureInstancesInputNV,
            next: ptr::null_mut(),
            flags: Default::default(),
            instance_count: 0,
            max_instance_per_partition_count: 0,
            partition_count: 0,
            max_instance_in_global_partition_count: 0,
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsPartitionedAccelerationStructureInstancesInputNV {}
impl<'a> PartitionedAccelerationStructureInstancesInputNV<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsPartitionedAccelerationStructureInstancesInputNV>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct BuildPartitionedAccelerationStructureInfoNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub input: PartitionedAccelerationStructureInstancesInputNV<'a>,
    pub src_acceleration_structure_data: DeviceAddress,
    pub dst_acceleration_structure_data: DeviceAddress,
    pub scratch_data: DeviceAddress,
    pub src_infos: DeviceAddress,
    pub src_infos_count: DeviceAddress,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for BuildPartitionedAccelerationStructureInfoNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::BuildPartitionedAccelerationStructureInfoNV,
            next: ptr::null_mut(),
            input: Default::default(),
            src_acceleration_structure_data: Default::default(),
            dst_acceleration_structure_data: Default::default(),
            scratch_data: Default::default(),
            src_infos: Default::default(),
            src_infos_count: Default::default(),
            _marker: PhantomData,
        }
    }
}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceDiagnosticsConfigFeaturesNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub diagnostics_config: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceDiagnosticsConfigFeaturesNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceDiagnosticsConfigFeaturesNV,
            next: ptr::null_mut(),
            diagnostics_config: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDiagnosticsConfigFeaturesNV<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceDiagnosticsConfigFeaturesNV<'_> {}

/// Extends: `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DeviceDiagnosticsConfigCreateInfoNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub flags: DeviceDiagnosticsConfigFlagsNV,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for DeviceDiagnosticsConfigCreateInfoNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::DeviceDiagnosticsConfigCreateInfoNV,
            next: ptr::null_mut(),
            flags: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsDeviceCreateInfo for DeviceDiagnosticsConfigCreateInfoNV<'_> {}

/// Extends: `GraphicsPipelineCreateInfo`, `ComputePipelineCreateInfo`, `RayTracingPipelineCreateInfoKHR`, `RayTracingPipelineCreateInfoNV`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PipelineOfflineCreateInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub pipeline_identifier: [u8; UUID_SIZE as usize],
    pub match_control: PipelineMatchControl,
    pub pool_entry_size: DeviceSize,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PipelineOfflineCreateInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PipelineOfflineCreateInfo,
            next: ptr::null_mut(),
            pipeline_identifier: unsafe { mem::zeroed() },
            match_control: Default::default(),
            pool_entry_size: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsGraphicsPipelineCreateInfo for PipelineOfflineCreateInfo<'_> {}
impl ExtendsComputePipelineCreateInfo for PipelineOfflineCreateInfo<'_> {}
impl ExtendsRayTracingPipelineCreateInfoKHR for PipelineOfflineCreateInfo<'_> {}
impl ExtendsRayTracingPipelineCreateInfoNV for PipelineOfflineCreateInfo<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub shader_zero_initialize_workgroup_memory: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures,
            next: ptr::null_mut(),
            shader_zero_initialize_workgroup_memory: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures<'_> {}

pub type PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR<'a> =
    PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures<'a>;
/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub shader_subgroup_uniform_control_flow: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR,
            next: ptr::null_mut(),
            shader_subgroup_uniform_control_flow: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2
    for PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR<'_>
{
}
impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceRobustness2FeaturesKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub robust_buffer_access2: Bool32,
    pub robust_image_access2: Bool32,
    pub null_descriptor: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceRobustness2FeaturesKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceRobustness2FeaturesKHR,
            next: ptr::null_mut(),
            robust_buffer_access2: FALSE,
            robust_image_access2: FALSE,
            null_descriptor: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceRobustness2FeaturesKHR<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceRobustness2FeaturesKHR<'_> {}

pub type PhysicalDeviceRobustness2FeaturesEXT<'a> = PhysicalDeviceRobustness2FeaturesKHR<'a>;
/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceRobustness2PropertiesKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub robust_storage_buffer_access_size_alignment: DeviceSize,
    pub robust_uniform_buffer_access_size_alignment: DeviceSize,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceRobustness2PropertiesKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceRobustness2PropertiesKHR,
            next: ptr::null_mut(),
            robust_storage_buffer_access_size_alignment: Default::default(),
            robust_uniform_buffer_access_size_alignment: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceRobustness2PropertiesKHR<'_> {}

pub type PhysicalDeviceRobustness2PropertiesEXT<'a> = PhysicalDeviceRobustness2PropertiesKHR<'a>;
/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceImageRobustnessFeatures<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub robust_image_access: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceImageRobustnessFeatures<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceImageRobustnessFeatures,
            next: ptr::null_mut(),
            robust_image_access: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceImageRobustnessFeatures<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceImageRobustnessFeatures<'_> {}

pub type PhysicalDeviceImageRobustnessFeaturesEXT<'a> = PhysicalDeviceImageRobustnessFeatures<'a>;
/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub workgroup_memory_explicit_layout: Bool32,
    pub workgroup_memory_explicit_layout_scalar_block_layout: Bool32,
    pub workgroup_memory_explicit_layout8_bit_access: Bool32,
    pub workgroup_memory_explicit_layout16_bit_access: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR,
            next: ptr::null_mut(),
            workgroup_memory_explicit_layout: FALSE,
            workgroup_memory_explicit_layout_scalar_block_layout: FALSE,
            workgroup_memory_explicit_layout8_bit_access: FALSE,
            workgroup_memory_explicit_layout16_bit_access: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDevicePortabilitySubsetFeaturesKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub constant_alpha_color_blend_factors: Bool32,
    pub events: Bool32,
    pub image_view_format_reinterpretation: Bool32,
    pub image_view_format_swizzle: Bool32,
    pub image_view2_d_on3_d_image: Bool32,
    pub multisample_array_image: Bool32,
    pub mutable_comparison_samplers: Bool32,
    pub point_polygons: Bool32,
    pub sampler_mip_lod_bias: Bool32,
    pub separate_stencil_mask_ref: Bool32,
    pub shader_sample_rate_interpolation_functions: Bool32,
    pub tessellation_isolines: Bool32,
    pub tessellation_point_mode: Bool32,
    pub triangle_fans: Bool32,
    pub vertex_attribute_access_beyond_stride: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDevicePortabilitySubsetFeaturesKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDevicePortabilitySubsetFeaturesKHR,
            next: ptr::null_mut(),
            constant_alpha_color_blend_factors: FALSE,
            events: FALSE,
            image_view_format_reinterpretation: FALSE,
            image_view_format_swizzle: FALSE,
            image_view2_d_on3_d_image: FALSE,
            multisample_array_image: FALSE,
            mutable_comparison_samplers: FALSE,
            point_polygons: FALSE,
            sampler_mip_lod_bias: FALSE,
            separate_stencil_mask_ref: FALSE,
            shader_sample_rate_interpolation_functions: FALSE,
            tessellation_isolines: FALSE,
            tessellation_point_mode: FALSE,
            triangle_fans: FALSE,
            vertex_attribute_access_beyond_stride: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePortabilitySubsetFeaturesKHR<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDevicePortabilitySubsetFeaturesKHR<'_> {}

/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDevicePortabilitySubsetPropertiesKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub min_vertex_input_binding_stride_alignment: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDevicePortabilitySubsetPropertiesKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDevicePortabilitySubsetPropertiesKHR,
            next: ptr::null_mut(),
            min_vertex_input_binding_stride_alignment: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2 for PhysicalDevicePortabilitySubsetPropertiesKHR<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDevice4444FormatsFeaturesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub format_a4r4g4b4: Bool32,
    pub format_a4b4g4r4: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDevice4444FormatsFeaturesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDevice4444FormatsFeaturesEXT,
            next: ptr::null_mut(),
            format_a4r4g4b4: FALSE,
            format_a4b4g4r4: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevice4444FormatsFeaturesEXT<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDevice4444FormatsFeaturesEXT<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceSubpassShadingFeaturesHUAWEI<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub subpass_shading: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceSubpassShadingFeaturesHUAWEI<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceSubpassShadingFeaturesHUAWEI,
            next: ptr::null_mut(),
            subpass_shading: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceSubpassShadingFeaturesHUAWEI<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceSubpassShadingFeaturesHUAWEI<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceClusterCullingShaderFeaturesHUAWEI<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub clusterculling_shader: Bool32,
    pub multiview_cluster_culling_shader: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceClusterCullingShaderFeaturesHUAWEI<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceClusterCullingShaderFeaturesHUAWEI,
            next: ptr::null_mut(),
            clusterculling_shader: FALSE,
            multiview_cluster_culling_shader: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceClusterCullingShaderFeaturesHUAWEI<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceClusterCullingShaderFeaturesHUAWEI<'_> {}
pub trait ExtendsPhysicalDeviceClusterCullingShaderFeaturesHUAWEI {}
impl<'a> PhysicalDeviceClusterCullingShaderFeaturesHUAWEI<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsPhysicalDeviceClusterCullingShaderFeaturesHUAWEI>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

/// Extends: `PhysicalDeviceClusterCullingShaderFeaturesHUAWEI`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub cluster_shading_rate: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI,
            next: ptr::null_mut(),
            cluster_shading_rate: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceClusterCullingShaderFeaturesHUAWEI
    for PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI<'_>
{
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct BufferCopy2<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    /// Specified in bytes
    pub src_offset: DeviceSize,
    /// Specified in bytes
    pub dst_offset: DeviceSize,
    /// Specified in bytes
    pub size: DeviceSize,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for BufferCopy2<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::BufferCopy2,
            next: ptr::null_mut(),
            src_offset: Default::default(),
            dst_offset: Default::default(),
            size: Default::default(),
            _marker: PhantomData,
        }
    }
}

pub type BufferCopy2KHR<'a> = BufferCopy2<'a>;
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ImageCopy2<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub src_subresource: ImageSubresourceLayers,
    /// Specified in pixels for both compressed and uncompressed images
    pub src_offset: Offset3D,
    pub dst_subresource: ImageSubresourceLayers,
    /// Specified in pixels for both compressed and uncompressed images
    pub dst_offset: Offset3D,
    /// Specified in pixels for both compressed and uncompressed images
    pub extent: Extent3D,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ImageCopy2<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ImageCopy2,
            next: ptr::null_mut(),
            src_subresource: Default::default(),
            src_offset: Default::default(),
            dst_subresource: Default::default(),
            dst_offset: Default::default(),
            extent: Default::default(),
            _marker: PhantomData,
        }
    }
}

pub type ImageCopy2KHR<'a> = ImageCopy2<'a>;
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ImageBlit2<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub src_subresource: ImageSubresourceLayers,
    /// Specified in pixels for both compressed and uncompressed images
    pub src_offsets: [Offset3D; 2],
    pub dst_subresource: ImageSubresourceLayers,
    /// Specified in pixels for both compressed and uncompressed images
    pub dst_offsets: [Offset3D; 2],
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ImageBlit2<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ImageBlit2,
            next: ptr::null_mut(),
            src_subresource: Default::default(),
            src_offsets: unsafe { mem::zeroed() },
            dst_subresource: Default::default(),
            dst_offsets: unsafe { mem::zeroed() },
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsImageBlit2 {}
impl<'a> ImageBlit2<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsImageBlit2>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

pub type ImageBlit2KHR<'a> = ImageBlit2<'a>;
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct BufferImageCopy2<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    /// Specified in bytes
    pub buffer_offset: DeviceSize,
    /// Specified in texels
    pub buffer_row_length: u32,
    pub buffer_image_height: u32,
    pub image_subresource: ImageSubresourceLayers,
    /// Specified in pixels for both compressed and uncompressed images
    pub image_offset: Offset3D,
    /// Specified in pixels for both compressed and uncompressed images
    pub image_extent: Extent3D,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for BufferImageCopy2<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::BufferImageCopy2,
            next: ptr::null_mut(),
            buffer_offset: Default::default(),
            buffer_row_length: 0,
            buffer_image_height: 0,
            image_subresource: Default::default(),
            image_offset: Default::default(),
            image_extent: Default::default(),
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsBufferImageCopy2 {}
impl<'a> BufferImageCopy2<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsBufferImageCopy2>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

pub type BufferImageCopy2KHR<'a> = BufferImageCopy2<'a>;
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ImageResolve2<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub src_subresource: ImageSubresourceLayers,
    pub src_offset: Offset3D,
    pub dst_subresource: ImageSubresourceLayers,
    pub dst_offset: Offset3D,
    pub extent: Extent3D,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ImageResolve2<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ImageResolve2,
            next: ptr::null_mut(),
            src_subresource: Default::default(),
            src_offset: Default::default(),
            dst_subresource: Default::default(),
            dst_offset: Default::default(),
            extent: Default::default(),
            _marker: PhantomData,
        }
    }
}

pub type ImageResolve2KHR<'a> = ImageResolve2<'a>;
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct CopyBufferInfo2<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub src_buffer: Buffer,
    pub dst_buffer: Buffer,
    pub region_count: u32,
    /// Len: `region_count`
    pub regions: *const BufferCopy2<'a>,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for CopyBufferInfo2<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::CopyBufferInfo2,
            next: ptr::null_mut(),
            src_buffer: Default::default(),
            dst_buffer: Default::default(),
            region_count: 0,
            regions: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

pub type CopyBufferInfo2KHR<'a> = CopyBufferInfo2<'a>;
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct CopyImageInfo2<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub src_image: Image,
    pub src_image_layout: ImageLayout,
    pub dst_image: Image,
    pub dst_image_layout: ImageLayout,
    pub region_count: u32,
    /// Len: `region_count`
    pub regions: *const ImageCopy2<'a>,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for CopyImageInfo2<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::CopyImageInfo2,
            next: ptr::null_mut(),
            src_image: Default::default(),
            src_image_layout: Default::default(),
            dst_image: Default::default(),
            dst_image_layout: Default::default(),
            region_count: 0,
            regions: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

pub type CopyImageInfo2KHR<'a> = CopyImageInfo2<'a>;
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct BlitImageInfo2<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub src_image: Image,
    pub src_image_layout: ImageLayout,
    pub dst_image: Image,
    pub dst_image_layout: ImageLayout,
    pub region_count: u32,
    /// Len: `region_count`
    pub regions: *const ImageBlit2<'a>,
    pub filter: Filter,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for BlitImageInfo2<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::BlitImageInfo2,
            next: ptr::null_mut(),
            src_image: Default::default(),
            src_image_layout: Default::default(),
            dst_image: Default::default(),
            dst_image_layout: Default::default(),
            region_count: 0,
            regions: ptr::null_mut(),
            filter: Default::default(),
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsBlitImageInfo2 {}
impl<'a> BlitImageInfo2<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsBlitImageInfo2>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

pub type BlitImageInfo2KHR<'a> = BlitImageInfo2<'a>;
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct CopyBufferToImageInfo2<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub src_buffer: Buffer,
    pub dst_image: Image,
    pub dst_image_layout: ImageLayout,
    pub region_count: u32,
    /// Len: `region_count`
    pub regions: *const BufferImageCopy2<'a>,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for CopyBufferToImageInfo2<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::CopyBufferToImageInfo2,
            next: ptr::null_mut(),
            src_buffer: Default::default(),
            dst_image: Default::default(),
            dst_image_layout: Default::default(),
            region_count: 0,
            regions: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

pub type CopyBufferToImageInfo2KHR<'a> = CopyBufferToImageInfo2<'a>;
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct CopyImageToBufferInfo2<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub src_image: Image,
    pub src_image_layout: ImageLayout,
    pub dst_buffer: Buffer,
    pub region_count: u32,
    /// Len: `region_count`
    pub regions: *const BufferImageCopy2<'a>,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for CopyImageToBufferInfo2<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::CopyImageToBufferInfo2,
            next: ptr::null_mut(),
            src_image: Default::default(),
            src_image_layout: Default::default(),
            dst_buffer: Default::default(),
            region_count: 0,
            regions: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

pub type CopyImageToBufferInfo2KHR<'a> = CopyImageToBufferInfo2<'a>;
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ResolveImageInfo2<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub src_image: Image,
    pub src_image_layout: ImageLayout,
    pub dst_image: Image,
    pub dst_image_layout: ImageLayout,
    pub region_count: u32,
    /// Len: `region_count`
    pub regions: *const ImageResolve2<'a>,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ResolveImageInfo2<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ResolveImageInfo2,
            next: ptr::null_mut(),
            src_image: Default::default(),
            src_image_layout: Default::default(),
            dst_image: Default::default(),
            dst_image_layout: Default::default(),
            region_count: 0,
            regions: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsResolveImageInfo2 {}
impl<'a> ResolveImageInfo2<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsResolveImageInfo2>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

pub type ResolveImageInfo2KHR<'a> = ResolveImageInfo2<'a>;
/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceShaderImageAtomicInt64FeaturesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub shader_image_int64_atomics: Bool32,
    pub sparse_image_int64_atomics: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceShaderImageAtomicInt64FeaturesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceShaderImageAtomicInt64FeaturesEXT,
            next: ptr::null_mut(),
            shader_image_int64_atomics: FALSE,
            sparse_image_int64_atomics: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderImageAtomicInt64FeaturesEXT<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderImageAtomicInt64FeaturesEXT<'_> {}

/// Extends: `SubpassDescription2`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct FragmentShadingRateAttachmentInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    /// Nullable
    pub fragment_shading_rate_attachment: *const AttachmentReference2<'a>,
    pub shading_rate_attachment_texel_size: Extent2D,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for FragmentShadingRateAttachmentInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::FragmentShadingRateAttachmentInfoKHR,
            next: ptr::null_mut(),
            fragment_shading_rate_attachment: ptr::null_mut(),
            shading_rate_attachment_texel_size: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsSubpassDescription2 for FragmentShadingRateAttachmentInfoKHR<'_> {}

/// Extends: `GraphicsPipelineCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PipelineFragmentShadingRateStateCreateInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub fragment_size: Extent2D,
    pub combiner_ops: [FragmentShadingRateCombinerOpKHR; 2],
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PipelineFragmentShadingRateStateCreateInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PipelineFragmentShadingRateStateCreateInfoKHR,
            next: ptr::null_mut(),
            fragment_size: Default::default(),
            combiner_ops: unsafe { mem::zeroed() },
            _marker: PhantomData,
        }
    }
}

impl ExtendsGraphicsPipelineCreateInfo for PipelineFragmentShadingRateStateCreateInfoKHR<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceFragmentShadingRateFeaturesKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub pipeline_fragment_shading_rate: Bool32,
    pub primitive_fragment_shading_rate: Bool32,
    pub attachment_fragment_shading_rate: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceFragmentShadingRateFeaturesKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceFragmentShadingRateFeaturesKHR,
            next: ptr::null_mut(),
            pipeline_fragment_shading_rate: FALSE,
            primitive_fragment_shading_rate: FALSE,
            attachment_fragment_shading_rate: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceFragmentShadingRateFeaturesKHR<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentShadingRateFeaturesKHR<'_> {}

/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceFragmentShadingRatePropertiesKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub min_fragment_shading_rate_attachment_texel_size: Extent2D,
    pub max_fragment_shading_rate_attachment_texel_size: Extent2D,
    pub max_fragment_shading_rate_attachment_texel_size_aspect_ratio: u32,
    pub primitive_fragment_shading_rate_with_multiple_viewports: Bool32,
    pub layered_shading_rate_attachments: Bool32,
    pub fragment_shading_rate_non_trivial_combiner_ops: Bool32,
    pub max_fragment_size: Extent2D,
    pub max_fragment_size_aspect_ratio: u32,
    pub max_fragment_shading_rate_coverage_samples: u32,
    pub max_fragment_shading_rate_rasterization_samples: SampleCountFlags,
    pub fragment_shading_rate_with_shader_depth_stencil_writes: Bool32,
    pub fragment_shading_rate_with_sample_mask: Bool32,
    pub fragment_shading_rate_with_shader_sample_mask: Bool32,
    pub fragment_shading_rate_with_conservative_rasterization: Bool32,
    pub fragment_shading_rate_with_fragment_shader_interlock: Bool32,
    pub fragment_shading_rate_with_custom_sample_locations: Bool32,
    pub fragment_shading_rate_strict_multiply_combiner: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceFragmentShadingRatePropertiesKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceFragmentShadingRatePropertiesKHR,
            next: ptr::null_mut(),
            min_fragment_shading_rate_attachment_texel_size: Default::default(),
            max_fragment_shading_rate_attachment_texel_size: Default::default(),
            max_fragment_shading_rate_attachment_texel_size_aspect_ratio: 0,
            primitive_fragment_shading_rate_with_multiple_viewports: FALSE,
            layered_shading_rate_attachments: FALSE,
            fragment_shading_rate_non_trivial_combiner_ops: FALSE,
            max_fragment_size: Default::default(),
            max_fragment_size_aspect_ratio: 0,
            max_fragment_shading_rate_coverage_samples: 0,
            max_fragment_shading_rate_rasterization_samples: Default::default(),
            fragment_shading_rate_with_shader_depth_stencil_writes: FALSE,
            fragment_shading_rate_with_sample_mask: FALSE,
            fragment_shading_rate_with_shader_sample_mask: FALSE,
            fragment_shading_rate_with_conservative_rasterization: FALSE,
            fragment_shading_rate_with_fragment_shader_interlock: FALSE,
            fragment_shading_rate_with_custom_sample_locations: FALSE,
            fragment_shading_rate_strict_multiply_combiner: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceFragmentShadingRatePropertiesKHR<'_> {}

/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceFragmentShadingRateKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub sample_counts: SampleCountFlags,
    pub fragment_size: Extent2D,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceFragmentShadingRateKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceFragmentShadingRateKHR,
            next: ptr::null_mut(),
            sample_counts: Default::default(),
            fragment_size: Default::default(),
            _marker: PhantomData,
        }
    }
}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceShaderTerminateInvocationFeatures<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub shader_terminate_invocation: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceShaderTerminateInvocationFeatures<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceShaderTerminateInvocationFeatures,
            next: ptr::null_mut(),
            shader_terminate_invocation: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderTerminateInvocationFeatures<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderTerminateInvocationFeatures<'_> {}

pub type PhysicalDeviceShaderTerminateInvocationFeaturesKHR<'a> =
    PhysicalDeviceShaderTerminateInvocationFeatures<'a>;
/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceFragmentShadingRateEnumsFeaturesNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub fragment_shading_rate_enums: Bool32,
    pub supersample_fragment_shading_rates: Bool32,
    pub no_invocation_fragment_shading_rates: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceFragmentShadingRateEnumsFeaturesNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceFragmentShadingRateEnumsFeaturesNV,
            next: ptr::null_mut(),
            fragment_shading_rate_enums: FALSE,
            supersample_fragment_shading_rates: FALSE,
            no_invocation_fragment_shading_rates: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceFragmentShadingRateEnumsFeaturesNV<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentShadingRateEnumsFeaturesNV<'_> {}

/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceFragmentShadingRateEnumsPropertiesNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub max_fragment_shading_rate_invocation_count: SampleCountFlags,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceFragmentShadingRateEnumsPropertiesNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceFragmentShadingRateEnumsPropertiesNV,
            next: ptr::null_mut(),
            max_fragment_shading_rate_invocation_count: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceFragmentShadingRateEnumsPropertiesNV<'_> {}

/// Extends: `GraphicsPipelineCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PipelineFragmentShadingRateEnumStateCreateInfoNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub shading_rate_type: FragmentShadingRateTypeNV,
    pub shading_rate: FragmentShadingRateNV,
    pub combiner_ops: [FragmentShadingRateCombinerOpKHR; 2],
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PipelineFragmentShadingRateEnumStateCreateInfoNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PipelineFragmentShadingRateEnumStateCreateInfoNV,
            next: ptr::null_mut(),
            shading_rate_type: Default::default(),
            shading_rate: Default::default(),
            combiner_ops: unsafe { mem::zeroed() },
            _marker: PhantomData,
        }
    }
}

impl ExtendsGraphicsPipelineCreateInfo for PipelineFragmentShadingRateEnumStateCreateInfoNV<'_> {}

/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct AccelerationStructureBuildSizesInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub acceleration_structure_size: DeviceSize,
    pub update_scratch_size: DeviceSize,
    pub build_scratch_size: DeviceSize,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for AccelerationStructureBuildSizesInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::AccelerationStructureBuildSizesInfoKHR,
            next: ptr::null_mut(),
            acceleration_structure_size: Default::default(),
            update_scratch_size: Default::default(),
            build_scratch_size: Default::default(),
            _marker: PhantomData,
        }
    }
}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceImage2DViewOf3DFeaturesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub image2_d_view_of3_d: Bool32,
    pub sampler2_d_view_of3_d: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceImage2DViewOf3DFeaturesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceImage2DViewOf3DFeaturesEXT,
            next: ptr::null_mut(),
            image2_d_view_of3_d: FALSE,
            sampler2_d_view_of3_d: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceImage2DViewOf3DFeaturesEXT<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceImage2DViewOf3DFeaturesEXT<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceImageSlicedViewOf3DFeaturesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub image_sliced_view_of3_d: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceImageSlicedViewOf3DFeaturesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceImageSlicedViewOf3DFeaturesEXT,
            next: ptr::null_mut(),
            image_sliced_view_of3_d: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceImageSlicedViewOf3DFeaturesEXT<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceImageSlicedViewOf3DFeaturesEXT<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub attachment_feedback_loop_dynamic_state: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT,
            next: ptr::null_mut(),
            attachment_feedback_loop_dynamic_state: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2
    for PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT<'_>
{
}
impl ExtendsDeviceCreateInfo for PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceLegacyVertexAttributesFeaturesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub legacy_vertex_attributes: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceLegacyVertexAttributesFeaturesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceLegacyVertexAttributesFeaturesEXT,
            next: ptr::null_mut(),
            legacy_vertex_attributes: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceLegacyVertexAttributesFeaturesEXT<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceLegacyVertexAttributesFeaturesEXT<'_> {}

/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceLegacyVertexAttributesPropertiesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub native_unaligned_performance: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceLegacyVertexAttributesPropertiesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceLegacyVertexAttributesPropertiesEXT,
            next: ptr::null_mut(),
            native_unaligned_performance: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceLegacyVertexAttributesPropertiesEXT<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceMutableDescriptorTypeFeaturesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub mutable_descriptor_type: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceMutableDescriptorTypeFeaturesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceMutableDescriptorTypeFeaturesEXT,
            next: ptr::null_mut(),
            mutable_descriptor_type: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMutableDescriptorTypeFeaturesEXT<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceMutableDescriptorTypeFeaturesEXT<'_> {}

pub type PhysicalDeviceMutableDescriptorTypeFeaturesVALVE<'a> =
    PhysicalDeviceMutableDescriptorTypeFeaturesEXT<'a>;
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct MutableDescriptorTypeListEXT<'a> {
    pub descriptor_type_count: u32,
    /// Len: `descriptor_type_count`
    pub descriptor_types: *const DescriptorType,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for MutableDescriptorTypeListEXT<'_> {
    fn default() -> Self {
        Self {
            descriptor_type_count: 0,
            descriptor_types: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

pub type MutableDescriptorTypeListVALVE<'a> = MutableDescriptorTypeListEXT<'a>;
/// Extends: `DescriptorSetLayoutCreateInfo`, `DescriptorPoolCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct MutableDescriptorTypeCreateInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub mutable_descriptor_type_list_count: u32,
    /// Len: `mutable_descriptor_type_list_count`
    pub mutable_descriptor_type_lists: *const MutableDescriptorTypeListEXT<'a>,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for MutableDescriptorTypeCreateInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::MutableDescriptorTypeCreateInfoEXT,
            next: ptr::null_mut(),
            mutable_descriptor_type_list_count: 0,
            mutable_descriptor_type_lists: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsDescriptorSetLayoutCreateInfo for MutableDescriptorTypeCreateInfoEXT<'_> {}
impl ExtendsDescriptorPoolCreateInfo for MutableDescriptorTypeCreateInfoEXT<'_> {}

pub type MutableDescriptorTypeCreateInfoVALVE<'a> = MutableDescriptorTypeCreateInfoEXT<'a>;
/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceDepthClipControlFeaturesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub depth_clip_control: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceDepthClipControlFeaturesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceDepthClipControlFeaturesEXT,
            next: ptr::null_mut(),
            depth_clip_control: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDepthClipControlFeaturesEXT<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceDepthClipControlFeaturesEXT<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub zero_initialize_device_memory: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT,
            next: ptr::null_mut(),
            zero_initialize_device_memory: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT<'_> {}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct BeginCustomResolveInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for BeginCustomResolveInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::BeginCustomResolveInfoEXT,
            next: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceCustomResolveFeaturesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub custom_resolve: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceCustomResolveFeaturesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceCustomResolveFeaturesEXT,
            next: ptr::null_mut(),
            custom_resolve: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceCustomResolveFeaturesEXT<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceCustomResolveFeaturesEXT<'_> {}

/// Extends: `GraphicsPipelineCreateInfo`, `CommandBufferInheritanceInfo`, `ShaderCreateInfoEXT`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct CustomResolveCreateInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub custom_resolve: Bool32,
    pub color_attachment_count: u32,
    /// Len: `color_attachment_count`
    pub color_attachment_formats: *const Format,
    pub depth_attachment_format: Format,
    pub stencil_attachment_format: Format,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for CustomResolveCreateInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::CustomResolveCreateInfoEXT,
            next: ptr::null_mut(),
            custom_resolve: FALSE,
            color_attachment_count: 0,
            color_attachment_formats: ptr::null_mut(),
            depth_attachment_format: Default::default(),
            stencil_attachment_format: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsGraphicsPipelineCreateInfo for CustomResolveCreateInfoEXT<'_> {}
impl ExtendsCommandBufferInheritanceInfo for CustomResolveCreateInfoEXT<'_> {}
impl ExtendsShaderCreateInfoEXT for CustomResolveCreateInfoEXT<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceDeviceGeneratedCommandsFeaturesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub device_generated_commands: Bool32,
    pub dynamic_generated_pipeline_layout: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceDeviceGeneratedCommandsFeaturesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceDeviceGeneratedCommandsFeaturesEXT,
            next: ptr::null_mut(),
            device_generated_commands: FALSE,
            dynamic_generated_pipeline_layout: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDeviceGeneratedCommandsFeaturesEXT<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceDeviceGeneratedCommandsFeaturesEXT<'_> {}

/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceDeviceGeneratedCommandsPropertiesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub max_indirect_pipeline_count: u32,
    pub max_indirect_shader_object_count: u32,
    pub max_indirect_sequence_count: u32,
    pub max_indirect_commands_token_count: u32,
    pub max_indirect_commands_token_offset: u32,
    pub max_indirect_commands_indirect_stride: u32,
    pub supported_indirect_commands_input_modes: IndirectCommandsInputModeFlagsEXT,
    pub supported_indirect_commands_shader_stages: ShaderStageFlags,
    pub supported_indirect_commands_shader_stages_pipeline_binding: ShaderStageFlags,
    pub supported_indirect_commands_shader_stages_shader_binding: ShaderStageFlags,
    pub device_generated_commands_transform_feedback: Bool32,
    pub device_generated_commands_multi_draw_indirect_count: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceDeviceGeneratedCommandsPropertiesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceDeviceGeneratedCommandsPropertiesEXT,
            next: ptr::null_mut(),
            max_indirect_pipeline_count: 0,
            max_indirect_shader_object_count: 0,
            max_indirect_sequence_count: 0,
            max_indirect_commands_token_count: 0,
            max_indirect_commands_token_offset: 0,
            max_indirect_commands_indirect_stride: 0,
            supported_indirect_commands_input_modes: Default::default(),
            supported_indirect_commands_shader_stages: Default::default(),
            supported_indirect_commands_shader_stages_pipeline_binding: Default::default(),
            supported_indirect_commands_shader_stages_shader_binding: Default::default(),
            device_generated_commands_transform_feedback: FALSE,
            device_generated_commands_multi_draw_indirect_count: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDeviceGeneratedCommandsPropertiesEXT<'_> {}

/// Extends: `GeneratedCommandsInfoEXT`, `GeneratedCommandsMemoryRequirementsInfoEXT`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct GeneratedCommandsPipelineInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub pipeline: Pipeline,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for GeneratedCommandsPipelineInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::GeneratedCommandsPipelineInfoEXT,
            next: ptr::null_mut(),
            pipeline: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsGeneratedCommandsInfoEXT for GeneratedCommandsPipelineInfoEXT<'_> {}
impl ExtendsGeneratedCommandsMemoryRequirementsInfoEXT for GeneratedCommandsPipelineInfoEXT<'_> {}

/// Extends: `GeneratedCommandsInfoEXT`, `GeneratedCommandsMemoryRequirementsInfoEXT`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct GeneratedCommandsShaderInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub shader_count: u32,
    /// Len: `shader_count`
    pub shaders: *const ShaderEXT,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for GeneratedCommandsShaderInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::GeneratedCommandsShaderInfoEXT,
            next: ptr::null_mut(),
            shader_count: 0,
            shaders: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsGeneratedCommandsInfoEXT for GeneratedCommandsShaderInfoEXT<'_> {}
impl ExtendsGeneratedCommandsMemoryRequirementsInfoEXT for GeneratedCommandsShaderInfoEXT<'_> {}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct GeneratedCommandsMemoryRequirementsInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub indirect_execution_set: IndirectExecutionSetEXT,
    pub indirect_commands_layout: IndirectCommandsLayoutEXT,
    pub max_sequence_count: u32,
    pub max_draw_count: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for GeneratedCommandsMemoryRequirementsInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::GeneratedCommandsMemoryRequirementsInfoEXT,
            next: ptr::null_mut(),
            indirect_execution_set: Default::default(),
            indirect_commands_layout: Default::default(),
            max_sequence_count: 0,
            max_draw_count: 0,
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsGeneratedCommandsMemoryRequirementsInfoEXT {}
impl<'a> GeneratedCommandsMemoryRequirementsInfoEXT<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsGeneratedCommandsMemoryRequirementsInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct IndirectExecutionSetPipelineInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub initial_pipeline: Pipeline,
    pub max_pipeline_count: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for IndirectExecutionSetPipelineInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::IndirectExecutionSetPipelineInfoEXT,
            next: ptr::null_mut(),
            initial_pipeline: Default::default(),
            max_pipeline_count: 0,
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct IndirectExecutionSetShaderLayoutInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub set_layout_count: u32,
    /// Nullable
    /// Len: `set_layout_count`
    pub set_layouts: *const DescriptorSetLayout,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for IndirectExecutionSetShaderLayoutInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::IndirectExecutionSetShaderLayoutInfoEXT,
            next: ptr::null_mut(),
            set_layout_count: 0,
            set_layouts: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct IndirectExecutionSetShaderInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub shader_count: u32,
    /// Len: `shader_count`
    pub initial_shaders: *const ShaderEXT,
    /// Nullable
    /// Len: `shader_count`
    pub set_layout_infos: *const IndirectExecutionSetShaderLayoutInfoEXT<'a>,
    pub max_shader_count: u32,
    pub push_constant_range_count: u32,
    /// Len: `push_constant_range_count`
    pub push_constant_ranges: *const PushConstantRange,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for IndirectExecutionSetShaderInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::IndirectExecutionSetShaderInfoEXT,
            next: ptr::null_mut(),
            shader_count: 0,
            initial_shaders: ptr::null_mut(),
            set_layout_infos: ptr::null_mut(),
            max_shader_count: 0,
            push_constant_range_count: 0,
            push_constant_ranges: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub union IndirectExecutionSetInfoEXT<'a> {
    pub pipeline_info: *const IndirectExecutionSetPipelineInfoEXT<'a>,
    pub shader_info: *const IndirectExecutionSetShaderInfoEXT<'a>,
}
impl Default for IndirectExecutionSetInfoEXT<'_> {
    fn default() -> Self {
        unsafe { mem::zeroed() }
    }
}

impl fmt::Debug for IndirectExecutionSetInfoEXT<'_> {
    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
        fmt.debug_struct("IndirectExecutionSetInfoEXT").finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct IndirectExecutionSetCreateInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub ty: IndirectExecutionSetInfoTypeEXT,
    pub info: IndirectExecutionSetInfoEXT<'a>,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for IndirectExecutionSetCreateInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::IndirectExecutionSetCreateInfoEXT,
            next: ptr::null_mut(),
            ty: Default::default(),
            info: Default::default(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct GeneratedCommandsInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub shader_stages: ShaderStageFlags,
    pub indirect_execution_set: IndirectExecutionSetEXT,
    pub indirect_commands_layout: IndirectCommandsLayoutEXT,
    pub indirect_address: DeviceAddress,
    pub indirect_address_size: DeviceSize,
    pub preprocess_address: DeviceAddress,
    pub preprocess_size: DeviceSize,
    pub max_sequence_count: u32,
    pub sequence_count_address: DeviceAddress,
    pub max_draw_count: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for GeneratedCommandsInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::GeneratedCommandsInfoEXT,
            next: ptr::null_mut(),
            shader_stages: Default::default(),
            indirect_execution_set: Default::default(),
            indirect_commands_layout: Default::default(),
            indirect_address: Default::default(),
            indirect_address_size: Default::default(),
            preprocess_address: Default::default(),
            preprocess_size: Default::default(),
            max_sequence_count: 0,
            sequence_count_address: Default::default(),
            max_draw_count: 0,
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsGeneratedCommandsInfoEXT {}
impl<'a> GeneratedCommandsInfoEXT<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsGeneratedCommandsInfoEXT>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct WriteIndirectExecutionSetPipelineEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub index: u32,
    pub pipeline: Pipeline,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for WriteIndirectExecutionSetPipelineEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::WriteIndirectExecutionSetPipelineEXT,
            next: ptr::null_mut(),
            index: 0,
            pipeline: Default::default(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct WriteIndirectExecutionSetShaderEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub index: u32,
    pub shader: ShaderEXT,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for WriteIndirectExecutionSetShaderEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::WriteIndirectExecutionSetShaderEXT,
            next: ptr::null_mut(),
            index: 0,
            shader: Default::default(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct IndirectCommandsLayoutCreateInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub flags: IndirectCommandsLayoutUsageFlagsEXT,
    pub shader_stages: ShaderStageFlags,
    pub indirect_stride: u32,
    pub pipeline_layout: PipelineLayout,
    pub token_count: u32,
    /// Len: `token_count`
    pub tokens: *const IndirectCommandsLayoutTokenEXT<'a>,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for IndirectCommandsLayoutCreateInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::IndirectCommandsLayoutCreateInfoEXT,
            next: ptr::null_mut(),
            flags: Default::default(),
            shader_stages: Default::default(),
            indirect_stride: 0,
            pipeline_layout: Default::default(),
            token_count: 0,
            tokens: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsIndirectCommandsLayoutCreateInfoEXT {}
impl<'a> IndirectCommandsLayoutCreateInfoEXT<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsIndirectCommandsLayoutCreateInfoEXT>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct IndirectCommandsLayoutTokenEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub ty: IndirectCommandsTokenTypeEXT,
    pub data: IndirectCommandsTokenDataEXT,
    pub offset: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for IndirectCommandsLayoutTokenEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::IndirectCommandsLayoutTokenEXT,
            next: ptr::null_mut(),
            ty: Default::default(),
            data: Default::default(),
            offset: 0,
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsIndirectCommandsLayoutTokenEXT {}
impl<'a> IndirectCommandsLayoutTokenEXT<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsIndirectCommandsLayoutTokenEXT>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DrawIndirectCountIndirectCommandEXT {
    pub buffer_address: DeviceAddress,
    pub stride: u32,
    pub command_count: u32,
}
impl Default for DrawIndirectCountIndirectCommandEXT {
    fn default() -> Self {
        Self {
            buffer_address: Default::default(),
            stride: 0,
            command_count: 0,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct IndirectCommandsVertexBufferTokenEXT {
    pub vertex_binding_unit: u32,
}
impl Default for IndirectCommandsVertexBufferTokenEXT {
    fn default() -> Self {
        Self {
            vertex_binding_unit: 0,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct BindVertexBufferIndirectCommandEXT {
    pub buffer_address: DeviceAddress,
    pub size: u32,
    pub stride: u32,
}
impl Default for BindVertexBufferIndirectCommandEXT {
    fn default() -> Self {
        Self {
            buffer_address: Default::default(),
            size: 0,
            stride: 0,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct IndirectCommandsIndexBufferTokenEXT {
    pub mode: IndirectCommandsInputModeFlagsEXT,
}
impl Default for IndirectCommandsIndexBufferTokenEXT {
    fn default() -> Self {
        Self {
            mode: Default::default(),
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct BindIndexBufferIndirectCommandEXT {
    pub buffer_address: DeviceAddress,
    pub size: u32,
    pub index_type: IndexType,
}
impl Default for BindIndexBufferIndirectCommandEXT {
    fn default() -> Self {
        Self {
            buffer_address: Default::default(),
            size: 0,
            index_type: Default::default(),
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct IndirectCommandsPushConstantTokenEXT {
    pub update_range: PushConstantRange,
}
impl Default for IndirectCommandsPushConstantTokenEXT {
    fn default() -> Self {
        Self {
            update_range: Default::default(),
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct IndirectCommandsExecutionSetTokenEXT {
    pub ty: IndirectExecutionSetInfoTypeEXT,
    pub shader_stages: ShaderStageFlags,
}
impl Default for IndirectCommandsExecutionSetTokenEXT {
    fn default() -> Self {
        Self {
            ty: Default::default(),
            shader_stages: Default::default(),
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub union IndirectCommandsTokenDataEXT {
    pub push_constant: *const IndirectCommandsPushConstantTokenEXT,
    pub vertex_buffer: *const IndirectCommandsVertexBufferTokenEXT,
    pub index_buffer: *const IndirectCommandsIndexBufferTokenEXT,
    pub execution_set: *const IndirectCommandsExecutionSetTokenEXT,
}
impl Default for IndirectCommandsTokenDataEXT {
    fn default() -> Self {
        unsafe { mem::zeroed() }
    }
}

impl fmt::Debug for IndirectCommandsTokenDataEXT {
    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
        fmt.debug_struct("IndirectCommandsTokenDataEXT").finish()
    }
}

/// Extends: `PipelineViewportStateCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PipelineViewportDepthClipControlCreateInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub negative_one_to_one: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PipelineViewportDepthClipControlCreateInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PipelineViewportDepthClipControlCreateInfoEXT,
            next: ptr::null_mut(),
            negative_one_to_one: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPipelineViewportStateCreateInfo for PipelineViewportDepthClipControlCreateInfoEXT<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceDepthClampControlFeaturesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub depth_clamp_control: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceDepthClampControlFeaturesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceDepthClampControlFeaturesEXT,
            next: ptr::null_mut(),
            depth_clamp_control: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDepthClampControlFeaturesEXT<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceDepthClampControlFeaturesEXT<'_> {}

/// Extends: `PipelineViewportStateCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PipelineViewportDepthClampControlCreateInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub depth_clamp_mode: DepthClampModeEXT,
    /// Nullable
    pub depth_clamp_range: *const DepthClampRangeEXT,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PipelineViewportDepthClampControlCreateInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PipelineViewportDepthClampControlCreateInfoEXT,
            next: ptr::null_mut(),
            depth_clamp_mode: Default::default(),
            depth_clamp_range: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsPipelineViewportStateCreateInfo for PipelineViewportDepthClampControlCreateInfoEXT<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceVertexInputDynamicStateFeaturesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub vertex_input_dynamic_state: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceVertexInputDynamicStateFeaturesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceVertexInputDynamicStateFeaturesEXT,
            next: ptr::null_mut(),
            vertex_input_dynamic_state: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVertexInputDynamicStateFeaturesEXT<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceVertexInputDynamicStateFeaturesEXT<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceExternalMemoryRDMAFeaturesNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub external_memory_rdma: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceExternalMemoryRDMAFeaturesNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceExternalMemoryRDMAFeaturesNV,
            next: ptr::null_mut(),
            external_memory_rdma: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceExternalMemoryRDMAFeaturesNV<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceExternalMemoryRDMAFeaturesNV<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub shader_relaxed_extended_instruction: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR,
            next: ptr::null_mut(),
            shader_relaxed_extended_instruction: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2
    for PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR<'_>
{
}
impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR<'_> {}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VertexInputBindingDescription2EXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub binding: u32,
    pub stride: u32,
    pub input_rate: VertexInputRate,
    pub divisor: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for VertexInputBindingDescription2EXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::VertexInputBindingDescription2EXT,
            next: ptr::null_mut(),
            binding: 0,
            stride: 0,
            input_rate: Default::default(),
            divisor: 0,
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VertexInputAttributeDescription2EXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    /// location of the shader vertex attrib
    pub location: u32,
    /// Vertex buffer binding id
    pub binding: u32,
    /// format of source data
    pub format: Format,
    /// Offset of first element in bytes from base of vertex
    pub offset: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for VertexInputAttributeDescription2EXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::VertexInputAttributeDescription2EXT,
            next: ptr::null_mut(),
            location: 0,
            binding: 0,
            format: Default::default(),
            offset: 0,
            _marker: PhantomData,
        }
    }
}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceColorWriteEnableFeaturesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub color_write_enable: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceColorWriteEnableFeaturesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceColorWriteEnableFeaturesEXT,
            next: ptr::null_mut(),
            color_write_enable: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceColorWriteEnableFeaturesEXT<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceColorWriteEnableFeaturesEXT<'_> {}

/// Extends: `PipelineColorBlendStateCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PipelineColorWriteCreateInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    /// # of pAttachments
    pub attachment_count: u32,
    /// Len: `attachment_count`
    pub color_write_enables: *const Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PipelineColorWriteCreateInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PipelineColorWriteCreateInfoEXT,
            next: ptr::null_mut(),
            attachment_count: 0,
            color_write_enables: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsPipelineColorBlendStateCreateInfo for PipelineColorWriteCreateInfoEXT<'_> {}

/// Extends: `SubpassDependency2`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct MemoryBarrier2<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub src_stage_mask: PipelineStageFlags2,
    pub src_access_mask: AccessFlags2,
    pub dst_stage_mask: PipelineStageFlags2,
    pub dst_access_mask: AccessFlags2,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for MemoryBarrier2<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::MemoryBarrier2,
            next: ptr::null_mut(),
            src_stage_mask: Default::default(),
            src_access_mask: Default::default(),
            dst_stage_mask: Default::default(),
            dst_access_mask: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsSubpassDependency2 for MemoryBarrier2<'_> {}

pub type MemoryBarrier2KHR<'a> = MemoryBarrier2<'a>;
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ImageMemoryBarrier2<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub src_stage_mask: PipelineStageFlags2,
    pub src_access_mask: AccessFlags2,
    pub dst_stage_mask: PipelineStageFlags2,
    pub dst_access_mask: AccessFlags2,
    pub old_layout: ImageLayout,
    pub new_layout: ImageLayout,
    pub src_queue_family_index: u32,
    pub dst_queue_family_index: u32,
    pub image: Image,
    pub subresource_range: ImageSubresourceRange,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ImageMemoryBarrier2<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ImageMemoryBarrier2,
            next: ptr::null_mut(),
            src_stage_mask: Default::default(),
            src_access_mask: Default::default(),
            dst_stage_mask: Default::default(),
            dst_access_mask: Default::default(),
            old_layout: Default::default(),
            new_layout: Default::default(),
            src_queue_family_index: 0,
            dst_queue_family_index: 0,
            image: Default::default(),
            subresource_range: Default::default(),
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsImageMemoryBarrier2 {}
impl<'a> ImageMemoryBarrier2<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsImageMemoryBarrier2>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

pub type ImageMemoryBarrier2KHR<'a> = ImageMemoryBarrier2<'a>;
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct BufferMemoryBarrier2<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub src_stage_mask: PipelineStageFlags2,
    pub src_access_mask: AccessFlags2,
    pub dst_stage_mask: PipelineStageFlags2,
    pub dst_access_mask: AccessFlags2,
    pub src_queue_family_index: u32,
    pub dst_queue_family_index: u32,
    pub buffer: Buffer,
    pub offset: DeviceSize,
    pub size: DeviceSize,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for BufferMemoryBarrier2<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::BufferMemoryBarrier2,
            next: ptr::null_mut(),
            src_stage_mask: Default::default(),
            src_access_mask: Default::default(),
            dst_stage_mask: Default::default(),
            dst_access_mask: Default::default(),
            src_queue_family_index: 0,
            dst_queue_family_index: 0,
            buffer: Default::default(),
            offset: Default::default(),
            size: Default::default(),
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsBufferMemoryBarrier2 {}
impl<'a> BufferMemoryBarrier2<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsBufferMemoryBarrier2>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

pub type BufferMemoryBarrier2KHR<'a> = BufferMemoryBarrier2<'a>;
/// Extends: `SubpassDependency2`, `BufferMemoryBarrier2`, `ImageMemoryBarrier2`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct MemoryBarrierAccessFlags3KHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub src_access_mask3: AccessFlags3KHR,
    pub dst_access_mask3: AccessFlags3KHR,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for MemoryBarrierAccessFlags3KHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::MemoryBarrierAccessFlags3KHR,
            next: ptr::null_mut(),
            src_access_mask3: Default::default(),
            dst_access_mask3: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsSubpassDependency2 for MemoryBarrierAccessFlags3KHR<'_> {}
impl ExtendsBufferMemoryBarrier2 for MemoryBarrierAccessFlags3KHR<'_> {}
impl ExtendsImageMemoryBarrier2 for MemoryBarrierAccessFlags3KHR<'_> {}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DependencyInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub dependency_flags: DependencyFlags,
    pub memory_barrier_count: u32,
    /// Len: `memory_barrier_count`
    pub memory_barriers: *const MemoryBarrier2<'a>,
    pub buffer_memory_barrier_count: u32,
    /// Len: `buffer_memory_barrier_count`
    pub buffer_memory_barriers: *const BufferMemoryBarrier2<'a>,
    pub image_memory_barrier_count: u32,
    /// Len: `image_memory_barrier_count`
    pub image_memory_barriers: *const ImageMemoryBarrier2<'a>,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for DependencyInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::DependencyInfo,
            next: ptr::null_mut(),
            dependency_flags: Default::default(),
            memory_barrier_count: 0,
            memory_barriers: ptr::null_mut(),
            buffer_memory_barrier_count: 0,
            buffer_memory_barriers: ptr::null_mut(),
            image_memory_barrier_count: 0,
            image_memory_barriers: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsDependencyInfo {}
impl<'a> DependencyInfo<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsDependencyInfo>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

pub type DependencyInfoKHR<'a> = DependencyInfo<'a>;
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct SemaphoreSubmitInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub semaphore: Semaphore,
    pub value: u64,
    pub stage_mask: PipelineStageFlags2,
    pub device_index: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for SemaphoreSubmitInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::SemaphoreSubmitInfo,
            next: ptr::null_mut(),
            semaphore: Default::default(),
            value: 0,
            stage_mask: Default::default(),
            device_index: 0,
            _marker: PhantomData,
        }
    }
}

pub type SemaphoreSubmitInfoKHR<'a> = SemaphoreSubmitInfo<'a>;
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct CommandBufferSubmitInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub command_buffer: vkCommandBuffer,
    pub device_mask: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for CommandBufferSubmitInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::CommandBufferSubmitInfo,
            next: ptr::null_mut(),
            command_buffer: Default::default(),
            device_mask: 0,
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsCommandBufferSubmitInfo {}
impl<'a> CommandBufferSubmitInfo<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsCommandBufferSubmitInfo>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

pub type CommandBufferSubmitInfoKHR<'a> = CommandBufferSubmitInfo<'a>;
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct SubmitInfo2<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub flags: SubmitFlags,
    pub wait_semaphore_info_count: u32,
    /// Len: `wait_semaphore_info_count`
    pub wait_semaphore_infos: *const SemaphoreSubmitInfo<'a>,
    pub command_buffer_info_count: u32,
    /// Len: `command_buffer_info_count`
    pub command_buffer_infos: *const CommandBufferSubmitInfo<'a>,
    pub signal_semaphore_info_count: u32,
    /// Len: `signal_semaphore_info_count`
    pub signal_semaphore_infos: *const SemaphoreSubmitInfo<'a>,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for SubmitInfo2<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::SubmitInfo2,
            next: ptr::null_mut(),
            flags: Default::default(),
            wait_semaphore_info_count: 0,
            wait_semaphore_infos: ptr::null_mut(),
            command_buffer_info_count: 0,
            command_buffer_infos: ptr::null_mut(),
            signal_semaphore_info_count: 0,
            signal_semaphore_infos: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsSubmitInfo2 {}
impl<'a> SubmitInfo2<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsSubmitInfo2>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

pub type SubmitInfo2KHR<'a> = SubmitInfo2<'a>;
/// Extends: `QueueFamilyProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct QueueFamilyCheckpointProperties2NV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub checkpoint_execution_stage_mask: PipelineStageFlags2,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for QueueFamilyCheckpointProperties2NV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::QueueFamilyCheckpointProperties2NV,
            next: ptr::null_mut(),
            checkpoint_execution_stage_mask: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsQueueFamilyProperties2 for QueueFamilyCheckpointProperties2NV<'_> {}

/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct CheckpointData2NV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub stage: PipelineStageFlags2,
    pub checkpoint_marker: *mut c_void,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for CheckpointData2NV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::CheckpointData2NV,
            next: ptr::null_mut(),
            stage: Default::default(),
            checkpoint_marker: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceSynchronization2Features<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub synchronization2: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceSynchronization2Features<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceSynchronization2Features,
            next: ptr::null_mut(),
            synchronization2: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceSynchronization2Features<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceSynchronization2Features<'_> {}

pub type PhysicalDeviceSynchronization2FeaturesKHR<'a> = PhysicalDeviceSynchronization2Features<'a>;
/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceUnifiedImageLayoutsFeaturesKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub unified_image_layouts: Bool32,
    pub unified_image_layouts_video: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceUnifiedImageLayoutsFeaturesKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceUnifiedImageLayoutsFeaturesKHR,
            next: ptr::null_mut(),
            unified_image_layouts: FALSE,
            unified_image_layouts_video: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceUnifiedImageLayoutsFeaturesKHR<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceUnifiedImageLayoutsFeaturesKHR<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceHostImageCopyFeatures<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub host_image_copy: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceHostImageCopyFeatures<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceHostImageCopyFeatures,
            next: ptr::null_mut(),
            host_image_copy: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceHostImageCopyFeatures<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceHostImageCopyFeatures<'_> {}

pub type PhysicalDeviceHostImageCopyFeaturesEXT<'a> = PhysicalDeviceHostImageCopyFeatures<'a>;
/// Extends: `PhysicalDeviceProperties2`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceHostImageCopyProperties<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub copy_src_layout_count: u32,
    /// Nullable
    /// Len: `copy_src_layout_count`
    pub copy_src_layouts: *mut ImageLayout,
    pub copy_dst_layout_count: u32,
    /// Nullable
    /// Len: `copy_dst_layout_count`
    pub copy_dst_layouts: *mut ImageLayout,
    pub optimal_tiling_layout_uuid: [u8; UUID_SIZE as usize],
    pub identical_memory_type_requirements: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceHostImageCopyProperties<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceHostImageCopyProperties,
            next: ptr::null_mut(),
            copy_src_layout_count: 0,
            copy_src_layouts: ptr::null_mut(),
            copy_dst_layout_count: 0,
            copy_dst_layouts: ptr::null_mut(),
            optimal_tiling_layout_uuid: unsafe { mem::zeroed() },
            identical_memory_type_requirements: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceHostImageCopyProperties<'_> {}

pub type PhysicalDeviceHostImageCopyPropertiesEXT<'a> = PhysicalDeviceHostImageCopyProperties<'a>;
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct MemoryToImageCopy<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub host_pointer: *const c_void,
    /// Specified in texels
    pub memory_row_length: u32,
    pub memory_image_height: u32,
    pub image_subresource: ImageSubresourceLayers,
    pub image_offset: Offset3D,
    pub image_extent: Extent3D,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for MemoryToImageCopy<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::MemoryToImageCopy,
            next: ptr::null_mut(),
            host_pointer: ptr::null_mut(),
            memory_row_length: 0,
            memory_image_height: 0,
            image_subresource: Default::default(),
            image_offset: Default::default(),
            image_extent: Default::default(),
            _marker: PhantomData,
        }
    }
}

pub type MemoryToImageCopyEXT<'a> = MemoryToImageCopy<'a>;
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ImageToMemoryCopy<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub host_pointer: *mut c_void,
    /// Specified in texels
    pub memory_row_length: u32,
    pub memory_image_height: u32,
    pub image_subresource: ImageSubresourceLayers,
    pub image_offset: Offset3D,
    pub image_extent: Extent3D,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ImageToMemoryCopy<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ImageToMemoryCopy,
            next: ptr::null_mut(),
            host_pointer: ptr::null_mut(),
            memory_row_length: 0,
            memory_image_height: 0,
            image_subresource: Default::default(),
            image_offset: Default::default(),
            image_extent: Default::default(),
            _marker: PhantomData,
        }
    }
}

pub type ImageToMemoryCopyEXT<'a> = ImageToMemoryCopy<'a>;
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct CopyMemoryToImageInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub flags: HostImageCopyFlags,
    pub dst_image: Image,
    pub dst_image_layout: ImageLayout,
    pub region_count: u32,
    /// Len: `region_count`
    pub regions: *const MemoryToImageCopy<'a>,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for CopyMemoryToImageInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::CopyMemoryToImageInfo,
            next: ptr::null_mut(),
            flags: Default::default(),
            dst_image: Default::default(),
            dst_image_layout: Default::default(),
            region_count: 0,
            regions: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

pub type CopyMemoryToImageInfoEXT<'a> = CopyMemoryToImageInfo<'a>;
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct CopyImageToMemoryInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub flags: HostImageCopyFlags,
    pub src_image: Image,
    pub src_image_layout: ImageLayout,
    pub region_count: u32,
    /// Len: `region_count`
    pub regions: *const ImageToMemoryCopy<'a>,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for CopyImageToMemoryInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::CopyImageToMemoryInfo,
            next: ptr::null_mut(),
            flags: Default::default(),
            src_image: Default::default(),
            src_image_layout: Default::default(),
            region_count: 0,
            regions: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

pub type CopyImageToMemoryInfoEXT<'a> = CopyImageToMemoryInfo<'a>;
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct CopyImageToImageInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub flags: HostImageCopyFlags,
    pub src_image: Image,
    pub src_image_layout: ImageLayout,
    pub dst_image: Image,
    pub dst_image_layout: ImageLayout,
    pub region_count: u32,
    /// Len: `region_count`
    pub regions: *const ImageCopy2<'a>,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for CopyImageToImageInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::CopyImageToImageInfo,
            next: ptr::null_mut(),
            flags: Default::default(),
            src_image: Default::default(),
            src_image_layout: Default::default(),
            dst_image: Default::default(),
            dst_image_layout: Default::default(),
            region_count: 0,
            regions: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

pub type CopyImageToImageInfoEXT<'a> = CopyImageToImageInfo<'a>;
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct HostImageLayoutTransitionInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub image: Image,
    pub old_layout: ImageLayout,
    pub new_layout: ImageLayout,
    pub subresource_range: ImageSubresourceRange,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for HostImageLayoutTransitionInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::HostImageLayoutTransitionInfo,
            next: ptr::null_mut(),
            image: Default::default(),
            old_layout: Default::default(),
            new_layout: Default::default(),
            subresource_range: Default::default(),
            _marker: PhantomData,
        }
    }
}

pub type HostImageLayoutTransitionInfoEXT<'a> = HostImageLayoutTransitionInfo<'a>;
/// Extends: `SubresourceLayout2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct SubresourceHostMemcpySize<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    /// Specified in bytes
    pub size: DeviceSize,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for SubresourceHostMemcpySize<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::SubresourceHostMemcpySize,
            next: ptr::null_mut(),
            size: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsSubresourceLayout2 for SubresourceHostMemcpySize<'_> {}

pub type SubresourceHostMemcpySizeEXT<'a> = SubresourceHostMemcpySize<'a>;
/// Extends: `ImageFormatProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct HostImageCopyDevicePerformanceQuery<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    /// Specifies if device access is optimal
    pub optimal_device_access: Bool32,
    /// Specifies if memory layout is identical
    pub identical_memory_layout: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for HostImageCopyDevicePerformanceQuery<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::HostImageCopyDevicePerformanceQuery,
            next: ptr::null_mut(),
            optimal_device_access: FALSE,
            identical_memory_layout: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsImageFormatProperties2 for HostImageCopyDevicePerformanceQuery<'_> {}

pub type HostImageCopyDevicePerformanceQueryEXT<'a> = HostImageCopyDevicePerformanceQuery<'a>;
/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceVulkanSC10Properties<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub device_no_dynamic_host_allocations: Bool32,
    pub device_destroy_frees_memory: Bool32,
    pub command_pool_multiple_command_buffers_recording: Bool32,
    pub command_pool_reset_command_buffer: Bool32,
    pub command_buffer_simultaneous_use: Bool32,
    pub secondary_command_buffer_null_or_imageless_framebuffer: Bool32,
    pub recycle_descriptor_set_memory: Bool32,
    pub recycle_pipeline_memory: Bool32,
    pub max_render_pass_subpasses: u32,
    pub max_render_pass_dependencies: u32,
    pub max_subpass_input_attachments: u32,
    pub max_subpass_preserve_attachments: u32,
    pub max_framebuffer_attachments: u32,
    pub max_descriptor_set_layout_bindings: u32,
    pub max_query_fault_count: u32,
    pub max_callback_fault_count: u32,
    pub max_command_pool_command_buffers: u32,
    pub max_command_buffer_size: DeviceSize,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceVulkanSC10Properties<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceVulkanSC10Properties,
            next: ptr::null_mut(),
            device_no_dynamic_host_allocations: FALSE,
            device_destroy_frees_memory: FALSE,
            command_pool_multiple_command_buffers_recording: FALSE,
            command_pool_reset_command_buffer: FALSE,
            command_buffer_simultaneous_use: FALSE,
            secondary_command_buffer_null_or_imageless_framebuffer: FALSE,
            recycle_descriptor_set_memory: FALSE,
            recycle_pipeline_memory: FALSE,
            max_render_pass_subpasses: 0,
            max_render_pass_dependencies: 0,
            max_subpass_input_attachments: 0,
            max_subpass_preserve_attachments: 0,
            max_framebuffer_attachments: 0,
            max_descriptor_set_layout_bindings: 0,
            max_query_fault_count: 0,
            max_callback_fault_count: 0,
            max_command_pool_command_buffers: 0,
            max_command_buffer_size: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceVulkanSC10Properties<'_> {}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PipelinePoolSize<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub pool_entry_size: DeviceSize,
    pub pool_entry_count: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PipelinePoolSize<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PipelinePoolSize,
            next: ptr::null_mut(),
            pool_entry_size: Default::default(),
            pool_entry_count: 0,
            _marker: PhantomData,
        }
    }
}

/// Extends: `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DeviceObjectReservationCreateInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub pipeline_cache_create_info_count: u32,
    /// Len: `pipeline_cache_create_info_count`
    pub pipeline_cache_create_infos: *const PipelineCacheCreateInfo<'a>,
    pub pipeline_pool_size_count: u32,
    /// Len: `pipeline_pool_size_count`
    pub pipeline_pool_sizes: *const PipelinePoolSize<'a>,
    pub semaphore_request_count: u32,
    pub command_buffer_request_count: u32,
    pub fence_request_count: u32,
    pub device_memory_request_count: u32,
    pub buffer_request_count: u32,
    pub image_request_count: u32,
    pub event_request_count: u32,
    pub query_pool_request_count: u32,
    pub buffer_view_request_count: u32,
    pub image_view_request_count: u32,
    pub layered_image_view_request_count: u32,
    pub pipeline_cache_request_count: u32,
    pub pipeline_layout_request_count: u32,
    pub render_pass_request_count: u32,
    pub graphics_pipeline_request_count: u32,
    pub compute_pipeline_request_count: u32,
    pub descriptor_set_layout_request_count: u32,
    pub sampler_request_count: u32,
    pub descriptor_pool_request_count: u32,
    pub descriptor_set_request_count: u32,
    pub framebuffer_request_count: u32,
    pub command_pool_request_count: u32,
    pub sampler_ycbcr_conversion_request_count: u32,
    pub surface_request_count: u32,
    pub swapchain_request_count: u32,
    pub display_mode_request_count: u32,
    pub subpass_description_request_count: u32,
    pub attachment_description_request_count: u32,
    pub descriptor_set_layout_binding_request_count: u32,
    pub descriptor_set_layout_binding_limit: u32,
    pub max_image_view_mip_levels: u32,
    pub max_image_view_array_layers: u32,
    pub max_layered_image_view_mip_levels: u32,
    pub max_occlusion_queries_per_pool: u32,
    pub max_pipeline_statistics_queries_per_pool: u32,
    pub max_timestamp_queries_per_pool: u32,
    pub max_immutable_samplers_per_descriptor_set_layout: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for DeviceObjectReservationCreateInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::DeviceObjectReservationCreateInfo,
            next: ptr::null_mut(),
            pipeline_cache_create_info_count: 0,
            pipeline_cache_create_infos: ptr::null_mut(),
            pipeline_pool_size_count: 0,
            pipeline_pool_sizes: ptr::null_mut(),
            semaphore_request_count: 0,
            command_buffer_request_count: 0,
            fence_request_count: 0,
            device_memory_request_count: 0,
            buffer_request_count: 0,
            image_request_count: 0,
            event_request_count: 0,
            query_pool_request_count: 0,
            buffer_view_request_count: 0,
            image_view_request_count: 0,
            layered_image_view_request_count: 0,
            pipeline_cache_request_count: 0,
            pipeline_layout_request_count: 0,
            render_pass_request_count: 0,
            graphics_pipeline_request_count: 0,
            compute_pipeline_request_count: 0,
            descriptor_set_layout_request_count: 0,
            sampler_request_count: 0,
            descriptor_pool_request_count: 0,
            descriptor_set_request_count: 0,
            framebuffer_request_count: 0,
            command_pool_request_count: 0,
            sampler_ycbcr_conversion_request_count: 0,
            surface_request_count: 0,
            swapchain_request_count: 0,
            display_mode_request_count: 0,
            subpass_description_request_count: 0,
            attachment_description_request_count: 0,
            descriptor_set_layout_binding_request_count: 0,
            descriptor_set_layout_binding_limit: 0,
            max_image_view_mip_levels: 0,
            max_image_view_array_layers: 0,
            max_layered_image_view_mip_levels: 0,
            max_occlusion_queries_per_pool: 0,
            max_pipeline_statistics_queries_per_pool: 0,
            max_timestamp_queries_per_pool: 0,
            max_immutable_samplers_per_descriptor_set_layout: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsDeviceCreateInfo for DeviceObjectReservationCreateInfo<'_> {}

/// Extends: `CommandPoolCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct CommandPoolMemoryReservationCreateInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub command_pool_reserved_size: DeviceSize,
    pub command_pool_max_command_buffers: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for CommandPoolMemoryReservationCreateInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::CommandPoolMemoryReservationCreateInfo,
            next: ptr::null_mut(),
            command_pool_reserved_size: Default::default(),
            command_pool_max_command_buffers: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsCommandPoolCreateInfo for CommandPoolMemoryReservationCreateInfo<'_> {}

/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct CommandPoolMemoryConsumption<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub command_pool_allocated: DeviceSize,
    pub command_pool_reserved_size: DeviceSize,
    pub command_buffer_allocated: DeviceSize,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for CommandPoolMemoryConsumption<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::CommandPoolMemoryConsumption,
            next: ptr::null_mut(),
            command_pool_allocated: Default::default(),
            command_pool_reserved_size: Default::default(),
            command_buffer_allocated: Default::default(),
            _marker: PhantomData,
        }
    }
}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceVulkanSC10Features<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub shader_atomic_instructions: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceVulkanSC10Features<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceVulkanSC10Features,
            next: ptr::null_mut(),
            shader_atomic_instructions: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVulkanSC10Features<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceVulkanSC10Features<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub primitives_generated_query: Bool32,
    pub primitives_generated_query_with_rasterizer_discard: Bool32,
    pub primitives_generated_query_with_non_zero_streams: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT,
            next: ptr::null_mut(),
            primitives_generated_query: FALSE,
            primitives_generated_query_with_rasterizer_discard: FALSE,
            primitives_generated_query_with_non_zero_streams: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceLegacyDitheringFeaturesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub legacy_dithering: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceLegacyDitheringFeaturesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceLegacyDitheringFeaturesEXT,
            next: ptr::null_mut(),
            legacy_dithering: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceLegacyDitheringFeaturesEXT<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceLegacyDitheringFeaturesEXT<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub multisampled_render_to_single_sampled: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT,
            next: ptr::null_mut(),
            multisampled_render_to_single_sampled: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2
    for PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT<'_>
{
}
impl ExtendsDeviceCreateInfo for PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT<'_> {}

/// Extends: `SurfaceCapabilities2KHR`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct SurfaceCapabilitiesPresentId2KHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub present_id2_supported: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for SurfaceCapabilitiesPresentId2KHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::SurfaceCapabilitiesPresentId2KHR,
            next: ptr::null_mut(),
            present_id2_supported: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsSurfaceCapabilities2KHR for SurfaceCapabilitiesPresentId2KHR<'_> {}

/// Extends: `SurfaceCapabilities2KHR`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct SurfaceCapabilitiesPresentWait2KHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub present_wait2_supported: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for SurfaceCapabilitiesPresentWait2KHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::SurfaceCapabilitiesPresentWait2KHR,
            next: ptr::null_mut(),
            present_wait2_supported: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsSurfaceCapabilities2KHR for SurfaceCapabilitiesPresentWait2KHR<'_> {}

/// Extends: `FormatProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct SubpassResolvePerformanceQueryEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub optimal: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for SubpassResolvePerformanceQueryEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::SubpassResolvePerformanceQueryEXT,
            next: ptr::null_mut(),
            optimal: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsFormatProperties2 for SubpassResolvePerformanceQueryEXT<'_> {}

/// Extends: `SubpassDescription2`, `RenderingInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct MultisampledRenderToSingleSampledInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub multisampled_render_to_single_sampled_enable: Bool32,
    pub rasterization_samples: SampleCountFlags,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for MultisampledRenderToSingleSampledInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::MultisampledRenderToSingleSampledInfoEXT,
            next: ptr::null_mut(),
            multisampled_render_to_single_sampled_enable: FALSE,
            rasterization_samples: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsSubpassDescription2 for MultisampledRenderToSingleSampledInfoEXT<'_> {}
impl ExtendsRenderingInfo for MultisampledRenderToSingleSampledInfoEXT<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDevicePipelineProtectedAccessFeatures<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub pipeline_protected_access: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDevicePipelineProtectedAccessFeatures<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDevicePipelineProtectedAccessFeatures,
            next: ptr::null_mut(),
            pipeline_protected_access: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePipelineProtectedAccessFeatures<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDevicePipelineProtectedAccessFeatures<'_> {}

pub type PhysicalDevicePipelineProtectedAccessFeaturesEXT<'a> =
    PhysicalDevicePipelineProtectedAccessFeatures<'a>;
/// Extends: `QueueFamilyProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct QueueFamilyVideoPropertiesKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub video_codec_operations: VideoCodecOperationFlagsKHR,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for QueueFamilyVideoPropertiesKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::QueueFamilyVideoPropertiesKHR,
            next: ptr::null_mut(),
            video_codec_operations: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsQueueFamilyProperties2 for QueueFamilyVideoPropertiesKHR<'_> {}

/// Extends: `QueueFamilyProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct QueueFamilyQueryResultStatusPropertiesKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub query_result_status_support: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for QueueFamilyQueryResultStatusPropertiesKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::QueueFamilyQueryResultStatusPropertiesKHR,
            next: ptr::null_mut(),
            query_result_status_support: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsQueueFamilyProperties2 for QueueFamilyQueryResultStatusPropertiesKHR<'_> {}

/// Extends: `PhysicalDeviceImageFormatInfo2`, `PhysicalDeviceVideoFormatInfoKHR`, `ImageCreateInfo`, `BufferCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VideoProfileListInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub profile_count: u32,
    /// Len: `profile_count`
    pub profiles: *const VideoProfileInfoKHR<'a>,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for VideoProfileListInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::VideoProfileListInfoKHR,
            next: ptr::null_mut(),
            profile_count: 0,
            profiles: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceImageFormatInfo2 for VideoProfileListInfoKHR<'_> {}
impl ExtendsPhysicalDeviceVideoFormatInfoKHR for VideoProfileListInfoKHR<'_> {}
impl ExtendsImageCreateInfo for VideoProfileListInfoKHR<'_> {}
impl ExtendsBufferCreateInfo for VideoProfileListInfoKHR<'_> {}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceVideoFormatInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub image_usage: ImageUsageFlags,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceVideoFormatInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceVideoFormatInfoKHR,
            next: ptr::null_mut(),
            image_usage: Default::default(),
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsPhysicalDeviceVideoFormatInfoKHR {}
impl<'a> PhysicalDeviceVideoFormatInfoKHR<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsPhysicalDeviceVideoFormatInfoKHR>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VideoFormatPropertiesKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub format: Format,
    pub component_mapping: ComponentMapping,
    pub image_create_flags: ImageCreateFlags,
    pub image_type: ImageType,
    pub image_tiling: ImageTiling,
    pub image_usage_flags: ImageUsageFlags,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for VideoFormatPropertiesKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::VideoFormatPropertiesKHR,
            next: ptr::null_mut(),
            format: Default::default(),
            component_mapping: Default::default(),
            image_create_flags: Default::default(),
            image_type: Default::default(),
            image_tiling: Default::default(),
            image_usage_flags: Default::default(),
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsVideoFormatPropertiesKHR {}
impl<'a> VideoFormatPropertiesKHR<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsVideoFormatPropertiesKHR>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

/// Extends: `VideoCapabilitiesKHR`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VideoEncodeQuantizationMapCapabilitiesKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub max_quantization_map_extent: Extent2D,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for VideoEncodeQuantizationMapCapabilitiesKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::VideoEncodeQuantizationMapCapabilitiesKHR,
            next: ptr::null_mut(),
            max_quantization_map_extent: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsVideoCapabilitiesKHR for VideoEncodeQuantizationMapCapabilitiesKHR<'_> {}

/// Extends: `VideoCapabilitiesKHR`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VideoEncodeH264QuantizationMapCapabilitiesKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub min_qp_delta: i32,
    pub max_qp_delta: i32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for VideoEncodeH264QuantizationMapCapabilitiesKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::VideoEncodeH264QuantizationMapCapabilitiesKHR,
            next: ptr::null_mut(),
            min_qp_delta: 0,
            max_qp_delta: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsVideoCapabilitiesKHR for VideoEncodeH264QuantizationMapCapabilitiesKHR<'_> {}

/// Extends: `VideoCapabilitiesKHR`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VideoEncodeH265QuantizationMapCapabilitiesKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub min_qp_delta: i32,
    pub max_qp_delta: i32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for VideoEncodeH265QuantizationMapCapabilitiesKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::VideoEncodeH265QuantizationMapCapabilitiesKHR,
            next: ptr::null_mut(),
            min_qp_delta: 0,
            max_qp_delta: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsVideoCapabilitiesKHR for VideoEncodeH265QuantizationMapCapabilitiesKHR<'_> {}

/// Extends: `VideoCapabilitiesKHR`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VideoEncodeAV1QuantizationMapCapabilitiesKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub min_q_index_delta: i32,
    pub max_q_index_delta: i32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for VideoEncodeAV1QuantizationMapCapabilitiesKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::VideoEncodeAV1QuantizationMapCapabilitiesKHR,
            next: ptr::null_mut(),
            min_q_index_delta: 0,
            max_q_index_delta: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsVideoCapabilitiesKHR for VideoEncodeAV1QuantizationMapCapabilitiesKHR<'_> {}

/// Extends: `VideoFormatPropertiesKHR`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VideoFormatQuantizationMapPropertiesKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub quantization_map_texel_size: Extent2D,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for VideoFormatQuantizationMapPropertiesKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::VideoFormatQuantizationMapPropertiesKHR,
            next: ptr::null_mut(),
            quantization_map_texel_size: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsVideoFormatPropertiesKHR for VideoFormatQuantizationMapPropertiesKHR<'_> {}

/// Extends: `VideoFormatPropertiesKHR`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VideoFormatH265QuantizationMapPropertiesKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub compatible_ctb_sizes: VideoEncodeH265CtbSizeFlagsKHR,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for VideoFormatH265QuantizationMapPropertiesKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::VideoFormatH265QuantizationMapPropertiesKHR,
            next: ptr::null_mut(),
            compatible_ctb_sizes: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsVideoFormatPropertiesKHR for VideoFormatH265QuantizationMapPropertiesKHR<'_> {}

/// Extends: `VideoFormatPropertiesKHR`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VideoFormatAV1QuantizationMapPropertiesKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub compatible_superblock_sizes: VideoEncodeAV1SuperblockSizeFlagsKHR,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for VideoFormatAV1QuantizationMapPropertiesKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::VideoFormatAV1QuantizationMapPropertiesKHR,
            next: ptr::null_mut(),
            compatible_superblock_sizes: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsVideoFormatPropertiesKHR for VideoFormatAV1QuantizationMapPropertiesKHR<'_> {}

/// Extends: `QueryPoolCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VideoProfileInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub video_codec_operation: VideoCodecOperationFlagsKHR,
    pub chroma_subsampling: VideoChromaSubsamplingFlagsKHR,
    pub luma_bit_depth: VideoComponentBitDepthFlagsKHR,
    pub chroma_bit_depth: VideoComponentBitDepthFlagsKHR,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for VideoProfileInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::VideoProfileInfoKHR,
            next: ptr::null_mut(),
            video_codec_operation: Default::default(),
            chroma_subsampling: Default::default(),
            luma_bit_depth: Default::default(),
            chroma_bit_depth: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsQueryPoolCreateInfo for VideoProfileInfoKHR<'_> {}
pub trait ExtendsVideoProfileInfoKHR {}
impl<'a> VideoProfileInfoKHR<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsVideoProfileInfoKHR>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VideoCapabilitiesKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub flags: VideoCapabilityFlagsKHR,
    pub min_bitstream_buffer_offset_alignment: DeviceSize,
    pub min_bitstream_buffer_size_alignment: DeviceSize,
    pub picture_access_granularity: Extent2D,
    pub min_coded_extent: Extent2D,
    pub max_coded_extent: Extent2D,
    pub max_dpb_slots: u32,
    pub max_active_reference_pictures: u32,
    pub header_version: ExtensionProperties,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for VideoCapabilitiesKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::VideoCapabilitiesKHR,
            next: ptr::null_mut(),
            flags: Default::default(),
            min_bitstream_buffer_offset_alignment: Default::default(),
            min_bitstream_buffer_size_alignment: Default::default(),
            picture_access_granularity: Default::default(),
            min_coded_extent: Default::default(),
            max_coded_extent: Default::default(),
            max_dpb_slots: 0,
            max_active_reference_pictures: 0,
            header_version: Default::default(),
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsVideoCapabilitiesKHR {}
impl<'a> VideoCapabilitiesKHR<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsVideoCapabilitiesKHR>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VideoSessionMemoryRequirementsKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub memory_bind_index: u32,
    pub memory_requirements: MemoryRequirements,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for VideoSessionMemoryRequirementsKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::VideoSessionMemoryRequirementsKHR,
            next: ptr::null_mut(),
            memory_bind_index: 0,
            memory_requirements: Default::default(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct BindVideoSessionMemoryInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub memory_bind_index: u32,
    pub memory: DeviceMemory,
    pub memory_offset: DeviceSize,
    pub memory_size: DeviceSize,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for BindVideoSessionMemoryInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::BindVideoSessionMemoryInfoKHR,
            next: ptr::null_mut(),
            memory_bind_index: 0,
            memory: Default::default(),
            memory_offset: Default::default(),
            memory_size: Default::default(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VideoPictureResourceInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    /// The offset to be used for the picture resource, currently only used in field mode
    pub coded_offset: Offset2D,
    /// The extent to be used for the picture resource
    pub coded_extent: Extent2D,
    /// The first array layer to be accessed for the Decode or Encode Operations
    pub base_array_layer: u32,
    /// The ImageView binding of the resource
    pub image_view_binding: ImageView,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for VideoPictureResourceInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::VideoPictureResourceInfoKHR,
            next: ptr::null_mut(),
            coded_offset: Default::default(),
            coded_extent: Default::default(),
            base_array_layer: 0,
            image_view_binding: Default::default(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VideoReferenceSlotInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    /// The reference slot index
    pub slot_index: i32,
    /// The reference picture resource
    /// Nullable
    pub picture_resource: *const VideoPictureResourceInfoKHR<'a>,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for VideoReferenceSlotInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::VideoReferenceSlotInfoKHR,
            next: ptr::null_mut(),
            slot_index: 0,
            picture_resource: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsVideoReferenceSlotInfoKHR {}
impl<'a> VideoReferenceSlotInfoKHR<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsVideoReferenceSlotInfoKHR>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

/// Extends: `VideoCapabilitiesKHR`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VideoDecodeCapabilitiesKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub flags: VideoDecodeCapabilityFlagsKHR,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for VideoDecodeCapabilitiesKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::VideoDecodeCapabilitiesKHR,
            next: ptr::null_mut(),
            flags: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsVideoCapabilitiesKHR for VideoDecodeCapabilitiesKHR<'_> {}

/// Extends: `VideoProfileInfoKHR`, `QueryPoolCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VideoDecodeUsageInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub video_usage_hints: VideoDecodeUsageFlagsKHR,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for VideoDecodeUsageInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::VideoDecodeUsageInfoKHR,
            next: ptr::null_mut(),
            video_usage_hints: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsVideoProfileInfoKHR for VideoDecodeUsageInfoKHR<'_> {}
impl ExtendsQueryPoolCreateInfo for VideoDecodeUsageInfoKHR<'_> {}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VideoDecodeInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub flags: VideoDecodeFlagsKHR,
    pub src_buffer: Buffer,
    pub src_buffer_offset: DeviceSize,
    pub src_buffer_range: DeviceSize,
    pub dst_picture_resource: VideoPictureResourceInfoKHR<'a>,
    /// Nullable
    pub setup_reference_slot: *const VideoReferenceSlotInfoKHR<'a>,
    pub reference_slot_count: u32,
    /// Len: `reference_slot_count`
    pub reference_slots: *const VideoReferenceSlotInfoKHR<'a>,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for VideoDecodeInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::VideoDecodeInfoKHR,
            next: ptr::null_mut(),
            flags: Default::default(),
            src_buffer: Default::default(),
            src_buffer_offset: Default::default(),
            src_buffer_range: Default::default(),
            dst_picture_resource: Default::default(),
            setup_reference_slot: ptr::null_mut(),
            reference_slot_count: 0,
            reference_slots: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsVideoDecodeInfoKHR {}
impl<'a> VideoDecodeInfoKHR<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsVideoDecodeInfoKHR>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceVideoMaintenance1FeaturesKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub video_maintenance1: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceVideoMaintenance1FeaturesKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceVideoMaintenance1FeaturesKHR,
            next: ptr::null_mut(),
            video_maintenance1: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVideoMaintenance1FeaturesKHR<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceVideoMaintenance1FeaturesKHR<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceVideoMaintenance2FeaturesKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub video_maintenance2: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceVideoMaintenance2FeaturesKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceVideoMaintenance2FeaturesKHR,
            next: ptr::null_mut(),
            video_maintenance2: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVideoMaintenance2FeaturesKHR<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceVideoMaintenance2FeaturesKHR<'_> {}

/// Extends: `VideoDecodeInfoKHR`, `VideoEncodeInfoKHR`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VideoInlineQueryInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub query_pool: QueryPool,
    pub first_query: u32,
    pub query_count: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for VideoInlineQueryInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::VideoInlineQueryInfoKHR,
            next: ptr::null_mut(),
            query_pool: Default::default(),
            first_query: 0,
            query_count: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsVideoDecodeInfoKHR for VideoInlineQueryInfoKHR<'_> {}
impl ExtendsVideoEncodeInfoKHR for VideoInlineQueryInfoKHR<'_> {}

/// Extends: `VideoProfileInfoKHR`, `QueryPoolCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VideoDecodeH264ProfileInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub profile_idc: H264ProfileIdc,
    pub picture_layout: VideoDecodeH264PictureLayoutFlagsKHR,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for VideoDecodeH264ProfileInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::VideoDecodeH264ProfileInfoKHR,
            next: ptr::null_mut(),
            profile_idc: Default::default(),
            picture_layout: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsVideoProfileInfoKHR for VideoDecodeH264ProfileInfoKHR<'_> {}
impl ExtendsQueryPoolCreateInfo for VideoDecodeH264ProfileInfoKHR<'_> {}

/// Extends: `VideoCapabilitiesKHR`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VideoDecodeH264CapabilitiesKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub max_level_idc: H264LevelIdc,
    pub field_offset_granularity: Offset2D,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for VideoDecodeH264CapabilitiesKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::VideoDecodeH264CapabilitiesKHR,
            next: ptr::null_mut(),
            max_level_idc: Default::default(),
            field_offset_granularity: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsVideoCapabilitiesKHR for VideoDecodeH264CapabilitiesKHR<'_> {}

/// Extends: `VideoSessionParametersUpdateInfoKHR`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VideoDecodeH264SessionParametersAddInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub sps_count: u32,
    /// Len: `sps_count`
    pub sp_ss: *const H264SequenceParameterSet<'a>,
    pub pps_count: u32,
    /// List of Picture Parameters associated with the spsStd, above
    /// Len: `pps_count`
    pub pp_ss: *const H264PictureParameterSet<'a>,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for VideoDecodeH264SessionParametersAddInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::VideoDecodeH264SessionParametersAddInfoKHR,
            next: ptr::null_mut(),
            sps_count: 0,
            sp_ss: ptr::null_mut(),
            pps_count: 0,
            pp_ss: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsVideoSessionParametersUpdateInfoKHR for VideoDecodeH264SessionParametersAddInfoKHR<'_> {}

/// Extends: `VideoSessionParametersCreateInfoKHR`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VideoDecodeH264SessionParametersCreateInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub max_sps_count: u32,
    pub max_pps_count: u32,
    /// Nullable
    pub parameters_add_info: *const VideoDecodeH264SessionParametersAddInfoKHR<'a>,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for VideoDecodeH264SessionParametersCreateInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::VideoDecodeH264SessionParametersCreateInfoKHR,
            next: ptr::null_mut(),
            max_sps_count: 0,
            max_pps_count: 0,
            parameters_add_info: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsVideoSessionParametersCreateInfoKHR
    for VideoDecodeH264SessionParametersCreateInfoKHR<'_>
{
}

/// Extends: `VideoDecodeInfoKHR`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VideoDecodeH264InlineSessionParametersInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    /// Nullable
    pub sps: *const H264SequenceParameterSet<'a>,
    /// Nullable
    pub pps: *const H264PictureParameterSet<'a>,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for VideoDecodeH264InlineSessionParametersInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::VideoDecodeH264InlineSessionParametersInfoKHR,
            next: ptr::null_mut(),
            sps: ptr::null_mut(),
            pps: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsVideoDecodeInfoKHR for VideoDecodeH264InlineSessionParametersInfoKHR<'_> {}

/// Extends: `VideoDecodeInfoKHR`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VideoDecodeH264PictureInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub picture_info: *const DecodeH264PictureInfo,
    pub slice_count: u32,
    /// Len: `slice_count`
    pub slice_offsets: *const u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for VideoDecodeH264PictureInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::VideoDecodeH264PictureInfoKHR,
            next: ptr::null_mut(),
            picture_info: ptr::null_mut(),
            slice_count: 0,
            slice_offsets: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsVideoDecodeInfoKHR for VideoDecodeH264PictureInfoKHR<'_> {}

/// Extends: `VideoReferenceSlotInfoKHR`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VideoDecodeH264DpbSlotInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub reference_info: *const DecodeH264ReferenceInfo,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for VideoDecodeH264DpbSlotInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::VideoDecodeH264DpbSlotInfoKHR,
            next: ptr::null_mut(),
            reference_info: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsVideoReferenceSlotInfoKHR for VideoDecodeH264DpbSlotInfoKHR<'_> {}

/// Extends: `VideoProfileInfoKHR`, `QueryPoolCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VideoDecodeH265ProfileInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub profile_idc: H265ProfileIdc,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for VideoDecodeH265ProfileInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::VideoDecodeH265ProfileInfoKHR,
            next: ptr::null_mut(),
            profile_idc: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsVideoProfileInfoKHR for VideoDecodeH265ProfileInfoKHR<'_> {}
impl ExtendsQueryPoolCreateInfo for VideoDecodeH265ProfileInfoKHR<'_> {}

/// Extends: `VideoCapabilitiesKHR`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VideoDecodeH265CapabilitiesKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub max_level_idc: H265LevelIdc,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for VideoDecodeH265CapabilitiesKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::VideoDecodeH265CapabilitiesKHR,
            next: ptr::null_mut(),
            max_level_idc: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsVideoCapabilitiesKHR for VideoDecodeH265CapabilitiesKHR<'_> {}

/// Extends: `VideoSessionParametersUpdateInfoKHR`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VideoDecodeH265SessionParametersAddInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub vps_count: u32,
    /// Len: `vps_count`
    pub vp_ss: *const H265VideoParameterSet<'a>,
    pub sps_count: u32,
    /// Len: `sps_count`
    pub sp_ss: *const H265SequenceParameterSet<'a>,
    pub pps_count: u32,
    /// List of Picture Parameters associated with the spsStd, above
    /// Len: `pps_count`
    pub pp_ss: *const H265PictureParameterSet<'a>,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for VideoDecodeH265SessionParametersAddInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::VideoDecodeH265SessionParametersAddInfoKHR,
            next: ptr::null_mut(),
            vps_count: 0,
            vp_ss: ptr::null_mut(),
            sps_count: 0,
            sp_ss: ptr::null_mut(),
            pps_count: 0,
            pp_ss: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsVideoSessionParametersUpdateInfoKHR for VideoDecodeH265SessionParametersAddInfoKHR<'_> {}

/// Extends: `VideoSessionParametersCreateInfoKHR`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VideoDecodeH265SessionParametersCreateInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub max_vps_count: u32,
    pub max_sps_count: u32,
    pub max_pps_count: u32,
    /// Nullable
    pub parameters_add_info: *const VideoDecodeH265SessionParametersAddInfoKHR<'a>,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for VideoDecodeH265SessionParametersCreateInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::VideoDecodeH265SessionParametersCreateInfoKHR,
            next: ptr::null_mut(),
            max_vps_count: 0,
            max_sps_count: 0,
            max_pps_count: 0,
            parameters_add_info: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsVideoSessionParametersCreateInfoKHR
    for VideoDecodeH265SessionParametersCreateInfoKHR<'_>
{
}

/// Extends: `VideoDecodeInfoKHR`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VideoDecodeH265InlineSessionParametersInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    /// Nullable
    pub vps: *const H265VideoParameterSet<'a>,
    /// Nullable
    pub sps: *const H265SequenceParameterSet<'a>,
    /// Nullable
    pub pps: *const H265PictureParameterSet<'a>,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for VideoDecodeH265InlineSessionParametersInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::VideoDecodeH265InlineSessionParametersInfoKHR,
            next: ptr::null_mut(),
            vps: ptr::null_mut(),
            sps: ptr::null_mut(),
            pps: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsVideoDecodeInfoKHR for VideoDecodeH265InlineSessionParametersInfoKHR<'_> {}

/// Extends: `VideoDecodeInfoKHR`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VideoDecodeH265PictureInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub picture_info: *const DecodeH265PictureInfo,
    pub slice_segment_count: u32,
    /// Len: `slice_segment_count`
    pub slice_segment_offsets: *const u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for VideoDecodeH265PictureInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::VideoDecodeH265PictureInfoKHR,
            next: ptr::null_mut(),
            picture_info: ptr::null_mut(),
            slice_segment_count: 0,
            slice_segment_offsets: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsVideoDecodeInfoKHR for VideoDecodeH265PictureInfoKHR<'_> {}

/// Extends: `VideoReferenceSlotInfoKHR`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VideoDecodeH265DpbSlotInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub reference_info: *const DecodeH265ReferenceInfo,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for VideoDecodeH265DpbSlotInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::VideoDecodeH265DpbSlotInfoKHR,
            next: ptr::null_mut(),
            reference_info: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsVideoReferenceSlotInfoKHR for VideoDecodeH265DpbSlotInfoKHR<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceVideoDecodeVP9FeaturesKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub video_decode_vp9: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceVideoDecodeVP9FeaturesKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceVideoDecodeVP9FeaturesKHR,
            next: ptr::null_mut(),
            video_decode_vp9: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVideoDecodeVP9FeaturesKHR<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceVideoDecodeVP9FeaturesKHR<'_> {}

/// Extends: `VideoProfileInfoKHR`, `QueryPoolCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VideoDecodeVP9ProfileInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub profile: VP9Profile,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for VideoDecodeVP9ProfileInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::VideoDecodeVP9ProfileInfoKHR,
            next: ptr::null_mut(),
            profile: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsVideoProfileInfoKHR for VideoDecodeVP9ProfileInfoKHR<'_> {}
impl ExtendsQueryPoolCreateInfo for VideoDecodeVP9ProfileInfoKHR<'_> {}

/// Extends: `VideoCapabilitiesKHR`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VideoDecodeVP9CapabilitiesKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub max_level: VP9Level,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for VideoDecodeVP9CapabilitiesKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::VideoDecodeVP9CapabilitiesKHR,
            next: ptr::null_mut(),
            max_level: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsVideoCapabilitiesKHR for VideoDecodeVP9CapabilitiesKHR<'_> {}

/// Extends: `VideoDecodeInfoKHR`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VideoDecodeVP9PictureInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub picture_info: *const DecodeVP9PictureInfo<'a>,
    pub reference_name_slot_indices: [i32; MAX_VIDEO_VP9_REFERENCES_PER_FRAME_KHR as usize],
    pub uncompressed_header_offset: u32,
    pub compressed_header_offset: u32,
    pub tiles_offset: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for VideoDecodeVP9PictureInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::VideoDecodeVP9PictureInfoKHR,
            next: ptr::null_mut(),
            picture_info: ptr::null_mut(),
            reference_name_slot_indices: unsafe { mem::zeroed() },
            uncompressed_header_offset: 0,
            compressed_header_offset: 0,
            tiles_offset: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsVideoDecodeInfoKHR for VideoDecodeVP9PictureInfoKHR<'_> {}

/// Extends: `VideoProfileInfoKHR`, `QueryPoolCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VideoDecodeAV1ProfileInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub profile: AV1Profile,
    pub film_grain_support: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for VideoDecodeAV1ProfileInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::VideoDecodeAV1ProfileInfoKHR,
            next: ptr::null_mut(),
            profile: Default::default(),
            film_grain_support: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsVideoProfileInfoKHR for VideoDecodeAV1ProfileInfoKHR<'_> {}
impl ExtendsQueryPoolCreateInfo for VideoDecodeAV1ProfileInfoKHR<'_> {}

/// Extends: `VideoCapabilitiesKHR`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VideoDecodeAV1CapabilitiesKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub max_level: AV1Level,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for VideoDecodeAV1CapabilitiesKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::VideoDecodeAV1CapabilitiesKHR,
            next: ptr::null_mut(),
            max_level: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsVideoCapabilitiesKHR for VideoDecodeAV1CapabilitiesKHR<'_> {}

/// Extends: `VideoSessionParametersCreateInfoKHR`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VideoDecodeAV1SessionParametersCreateInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub sequence_header: *const AV1SequenceHeader<'a>,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for VideoDecodeAV1SessionParametersCreateInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::VideoDecodeAV1SessionParametersCreateInfoKHR,
            next: ptr::null_mut(),
            sequence_header: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsVideoSessionParametersCreateInfoKHR
    for VideoDecodeAV1SessionParametersCreateInfoKHR<'_>
{
}

/// Extends: `VideoDecodeInfoKHR`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VideoDecodeAV1InlineSessionParametersInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    /// Nullable
    pub sequence_header: *const AV1SequenceHeader<'a>,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for VideoDecodeAV1InlineSessionParametersInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::VideoDecodeAV1InlineSessionParametersInfoKHR,
            next: ptr::null_mut(),
            sequence_header: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsVideoDecodeInfoKHR for VideoDecodeAV1InlineSessionParametersInfoKHR<'_> {}

/// Extends: `VideoDecodeInfoKHR`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VideoDecodeAV1PictureInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub picture_info: *const DecodeAV1PictureInfo<'a>,
    pub reference_name_slot_indices: [i32; MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR as usize],
    pub frame_header_offset: u32,
    pub tile_count: u32,
    /// Len: `tile_count`
    pub tile_offsets: *const u32,
    /// Len: `tile_count`
    pub tile_sizes: *const u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for VideoDecodeAV1PictureInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::VideoDecodeAV1PictureInfoKHR,
            next: ptr::null_mut(),
            picture_info: ptr::null_mut(),
            reference_name_slot_indices: unsafe { mem::zeroed() },
            frame_header_offset: 0,
            tile_count: 0,
            tile_offsets: ptr::null_mut(),
            tile_sizes: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsVideoDecodeInfoKHR for VideoDecodeAV1PictureInfoKHR<'_> {}

/// Extends: `VideoReferenceSlotInfoKHR`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VideoDecodeAV1DpbSlotInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub reference_info: *const DecodeAV1ReferenceInfo,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for VideoDecodeAV1DpbSlotInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::VideoDecodeAV1DpbSlotInfoKHR,
            next: ptr::null_mut(),
            reference_info: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsVideoReferenceSlotInfoKHR for VideoDecodeAV1DpbSlotInfoKHR<'_> {}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VideoSessionCreateInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub queue_family_index: u32,
    pub flags: VideoSessionCreateFlagsKHR,
    pub video_profile: *const VideoProfileInfoKHR<'a>,
    pub picture_format: Format,
    pub max_coded_extent: Extent2D,
    pub reference_picture_format: Format,
    pub max_dpb_slots: u32,
    pub max_active_reference_pictures: u32,
    pub header_version: *const ExtensionProperties,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for VideoSessionCreateInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::VideoSessionCreateInfoKHR,
            next: ptr::null_mut(),
            queue_family_index: 0,
            flags: Default::default(),
            video_profile: ptr::null_mut(),
            picture_format: Default::default(),
            max_coded_extent: Default::default(),
            reference_picture_format: Default::default(),
            max_dpb_slots: 0,
            max_active_reference_pictures: 0,
            header_version: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsVideoSessionCreateInfoKHR {}
impl<'a> VideoSessionCreateInfoKHR<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsVideoSessionCreateInfoKHR>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VideoSessionParametersCreateInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub flags: VideoSessionParametersCreateFlagsKHR,
    pub video_session_parameters_template: VideoSessionParametersKHR,
    pub video_session: VideoSessionKHR,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for VideoSessionParametersCreateInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::VideoSessionParametersCreateInfoKHR,
            next: ptr::null_mut(),
            flags: Default::default(),
            video_session_parameters_template: Default::default(),
            video_session: Default::default(),
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsVideoSessionParametersCreateInfoKHR {}
impl<'a> VideoSessionParametersCreateInfoKHR<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsVideoSessionParametersCreateInfoKHR>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VideoSessionParametersUpdateInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub update_sequence_count: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for VideoSessionParametersUpdateInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::VideoSessionParametersUpdateInfoKHR,
            next: ptr::null_mut(),
            update_sequence_count: 0,
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsVideoSessionParametersUpdateInfoKHR {}
impl<'a> VideoSessionParametersUpdateInfoKHR<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsVideoSessionParametersUpdateInfoKHR>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VideoEncodeSessionParametersGetInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub video_session_parameters: VideoSessionParametersKHR,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for VideoEncodeSessionParametersGetInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::VideoEncodeSessionParametersGetInfoKHR,
            next: ptr::null_mut(),
            video_session_parameters: Default::default(),
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsVideoEncodeSessionParametersGetInfoKHR {}
impl<'a> VideoEncodeSessionParametersGetInfoKHR<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsVideoEncodeSessionParametersGetInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VideoEncodeSessionParametersFeedbackInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub has_overrides: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for VideoEncodeSessionParametersFeedbackInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::VideoEncodeSessionParametersFeedbackInfoKHR,
            next: ptr::null_mut(),
            has_overrides: FALSE,
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsVideoEncodeSessionParametersFeedbackInfoKHR {}
impl<'a> VideoEncodeSessionParametersFeedbackInfoKHR<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsVideoEncodeSessionParametersFeedbackInfoKHR>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VideoBeginCodingInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub flags: VideoBeginCodingFlagsKHR,
    pub video_session: VideoSessionKHR,
    pub video_session_parameters: VideoSessionParametersKHR,
    pub reference_slot_count: u32,
    /// Len: `reference_slot_count`
    pub reference_slots: *const VideoReferenceSlotInfoKHR<'a>,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for VideoBeginCodingInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::VideoBeginCodingInfoKHR,
            next: ptr::null_mut(),
            flags: Default::default(),
            video_session: Default::default(),
            video_session_parameters: Default::default(),
            reference_slot_count: 0,
            reference_slots: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsVideoBeginCodingInfoKHR {}
impl<'a> VideoBeginCodingInfoKHR<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsVideoBeginCodingInfoKHR>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VideoEndCodingInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub flags: VideoEndCodingFlagsKHR,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for VideoEndCodingInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::VideoEndCodingInfoKHR,
            next: ptr::null_mut(),
            flags: Default::default(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VideoCodingControlInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub flags: VideoCodingControlFlagsKHR,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for VideoCodingControlInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::VideoCodingControlInfoKHR,
            next: ptr::null_mut(),
            flags: Default::default(),
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsVideoCodingControlInfoKHR {}
impl<'a> VideoCodingControlInfoKHR<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsVideoCodingControlInfoKHR>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

/// Extends: `VideoProfileInfoKHR`, `QueryPoolCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VideoEncodeUsageInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub video_usage_hints: VideoEncodeUsageFlagsKHR,
    pub video_content_hints: VideoEncodeContentFlagsKHR,
    pub tuning_mode: VideoEncodeTuningModeKHR,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for VideoEncodeUsageInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::VideoEncodeUsageInfoKHR,
            next: ptr::null_mut(),
            video_usage_hints: Default::default(),
            video_content_hints: Default::default(),
            tuning_mode: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsVideoProfileInfoKHR for VideoEncodeUsageInfoKHR<'_> {}
impl ExtendsQueryPoolCreateInfo for VideoEncodeUsageInfoKHR<'_> {}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VideoEncodeInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub flags: VideoEncodeFlagsKHR,
    pub dst_buffer: Buffer,
    pub dst_buffer_offset: DeviceSize,
    pub dst_buffer_range: DeviceSize,
    pub src_picture_resource: VideoPictureResourceInfoKHR<'a>,
    /// Nullable
    pub setup_reference_slot: *const VideoReferenceSlotInfoKHR<'a>,
    pub reference_slot_count: u32,
    /// Len: `reference_slot_count`
    pub reference_slots: *const VideoReferenceSlotInfoKHR<'a>,
    pub preceding_externally_encoded_bytes: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for VideoEncodeInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::VideoEncodeInfoKHR,
            next: ptr::null_mut(),
            flags: Default::default(),
            dst_buffer: Default::default(),
            dst_buffer_offset: Default::default(),
            dst_buffer_range: Default::default(),
            src_picture_resource: Default::default(),
            setup_reference_slot: ptr::null_mut(),
            reference_slot_count: 0,
            reference_slots: ptr::null_mut(),
            preceding_externally_encoded_bytes: 0,
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsVideoEncodeInfoKHR {}
impl<'a> VideoEncodeInfoKHR<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsVideoEncodeInfoKHR>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

/// Extends: `VideoEncodeInfoKHR`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VideoEncodeQuantizationMapInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub quantization_map: ImageView,
    pub quantization_map_extent: Extent2D,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for VideoEncodeQuantizationMapInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::VideoEncodeQuantizationMapInfoKHR,
            next: ptr::null_mut(),
            quantization_map: Default::default(),
            quantization_map_extent: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsVideoEncodeInfoKHR for VideoEncodeQuantizationMapInfoKHR<'_> {}

/// Extends: `VideoSessionParametersCreateInfoKHR`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VideoEncodeQuantizationMapSessionParametersCreateInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub quantization_map_texel_size: Extent2D,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for VideoEncodeQuantizationMapSessionParametersCreateInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::VideoEncodeQuantizationMapSessionParametersCreateInfoKHR,
            next: ptr::null_mut(),
            quantization_map_texel_size: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsVideoSessionParametersCreateInfoKHR
    for VideoEncodeQuantizationMapSessionParametersCreateInfoKHR<'_>
{
}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub video_encode_quantization_map: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR,
            next: ptr::null_mut(),
            video_encode_quantization_map: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR<'_> {}

/// Extends: `QueryPoolCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct QueryPoolVideoEncodeFeedbackCreateInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub encode_feedback_flags: VideoEncodeFeedbackFlagsKHR,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for QueryPoolVideoEncodeFeedbackCreateInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::QueryPoolVideoEncodeFeedbackCreateInfoKHR,
            next: ptr::null_mut(),
            encode_feedback_flags: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsQueryPoolCreateInfo for QueryPoolVideoEncodeFeedbackCreateInfoKHR<'_> {}

/// Extends: `VideoCodingControlInfoKHR`, `VideoSessionParametersCreateInfoKHR`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VideoEncodeQualityLevelInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub quality_level: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for VideoEncodeQualityLevelInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::VideoEncodeQualityLevelInfoKHR,
            next: ptr::null_mut(),
            quality_level: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsVideoCodingControlInfoKHR for VideoEncodeQualityLevelInfoKHR<'_> {}
impl ExtendsVideoSessionParametersCreateInfoKHR for VideoEncodeQualityLevelInfoKHR<'_> {}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceVideoEncodeQualityLevelInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub video_profile: *const VideoProfileInfoKHR<'a>,
    pub quality_level: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceVideoEncodeQualityLevelInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceVideoEncodeQualityLevelInfoKHR,
            next: ptr::null_mut(),
            video_profile: ptr::null_mut(),
            quality_level: 0,
            _marker: PhantomData,
        }
    }
}

/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VideoEncodeQualityLevelPropertiesKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub preferred_rate_control_mode: VideoEncodeRateControlModeFlagsKHR,
    pub preferred_rate_control_layer_count: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for VideoEncodeQualityLevelPropertiesKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::VideoEncodeQualityLevelPropertiesKHR,
            next: ptr::null_mut(),
            preferred_rate_control_mode: Default::default(),
            preferred_rate_control_layer_count: 0,
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsVideoEncodeQualityLevelPropertiesKHR {}
impl<'a> VideoEncodeQualityLevelPropertiesKHR<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsVideoEncodeQualityLevelPropertiesKHR>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

/// Extends: `VideoCodingControlInfoKHR`, `VideoBeginCodingInfoKHR`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VideoEncodeRateControlInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub flags: VideoEncodeRateControlFlagsKHR,
    pub rate_control_mode: VideoEncodeRateControlModeFlagsKHR,
    pub layer_count: u32,
    /// Len: `layer_count`
    pub layers: *const VideoEncodeRateControlLayerInfoKHR<'a>,
    pub virtual_buffer_size_in_ms: u32,
    pub initial_virtual_buffer_size_in_ms: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for VideoEncodeRateControlInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::VideoEncodeRateControlInfoKHR,
            next: ptr::null_mut(),
            flags: Default::default(),
            rate_control_mode: Default::default(),
            layer_count: 0,
            layers: ptr::null_mut(),
            virtual_buffer_size_in_ms: 0,
            initial_virtual_buffer_size_in_ms: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsVideoCodingControlInfoKHR for VideoEncodeRateControlInfoKHR<'_> {}
impl ExtendsVideoBeginCodingInfoKHR for VideoEncodeRateControlInfoKHR<'_> {}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VideoEncodeRateControlLayerInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub average_bitrate: u64,
    pub max_bitrate: u64,
    pub frame_rate_numerator: u32,
    pub frame_rate_denominator: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for VideoEncodeRateControlLayerInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::VideoEncodeRateControlLayerInfoKHR,
            next: ptr::null_mut(),
            average_bitrate: 0,
            max_bitrate: 0,
            frame_rate_numerator: 0,
            frame_rate_denominator: 0,
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsVideoEncodeRateControlLayerInfoKHR {}
impl<'a> VideoEncodeRateControlLayerInfoKHR<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsVideoEncodeRateControlLayerInfoKHR>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

/// Extends: `VideoCapabilitiesKHR`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VideoEncodeCapabilitiesKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub flags: VideoEncodeCapabilityFlagsKHR,
    pub rate_control_modes: VideoEncodeRateControlModeFlagsKHR,
    pub max_rate_control_layers: u32,
    pub max_bitrate: u64,
    pub max_quality_levels: u32,
    pub encode_input_picture_granularity: Extent2D,
    pub supported_encode_feedback_flags: VideoEncodeFeedbackFlagsKHR,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for VideoEncodeCapabilitiesKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::VideoEncodeCapabilitiesKHR,
            next: ptr::null_mut(),
            flags: Default::default(),
            rate_control_modes: Default::default(),
            max_rate_control_layers: 0,
            max_bitrate: 0,
            max_quality_levels: 0,
            encode_input_picture_granularity: Default::default(),
            supported_encode_feedback_flags: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsVideoCapabilitiesKHR for VideoEncodeCapabilitiesKHR<'_> {}

/// Extends: `VideoCapabilitiesKHR`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VideoEncodeH264CapabilitiesKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub flags: VideoEncodeH264CapabilityFlagsKHR,
    pub max_level_idc: H264LevelIdc,
    pub max_slice_count: u32,
    pub max_p_picture_l0_reference_count: u32,
    pub max_b_picture_l0_reference_count: u32,
    pub max_l1_reference_count: u32,
    pub max_temporal_layer_count: u32,
    pub expect_dyadic_temporal_layer_pattern: Bool32,
    pub min_qp: i32,
    pub max_qp: i32,
    pub prefers_gop_remaining_frames: Bool32,
    pub requires_gop_remaining_frames: Bool32,
    pub syntax_flags: VideoEncodeH264StdFlagsKHR,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for VideoEncodeH264CapabilitiesKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::VideoEncodeH264CapabilitiesKHR,
            next: ptr::null_mut(),
            flags: Default::default(),
            max_level_idc: Default::default(),
            max_slice_count: 0,
            max_p_picture_l0_reference_count: 0,
            max_b_picture_l0_reference_count: 0,
            max_l1_reference_count: 0,
            max_temporal_layer_count: 0,
            expect_dyadic_temporal_layer_pattern: FALSE,
            min_qp: 0,
            max_qp: 0,
            prefers_gop_remaining_frames: FALSE,
            requires_gop_remaining_frames: FALSE,
            syntax_flags: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsVideoCapabilitiesKHR for VideoEncodeH264CapabilitiesKHR<'_> {}

/// Extends: `VideoEncodeQualityLevelPropertiesKHR`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VideoEncodeH264QualityLevelPropertiesKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub preferred_rate_control_flags: VideoEncodeH264RateControlFlagsKHR,
    pub preferred_gop_frame_count: u32,
    pub preferred_idr_period: u32,
    pub preferred_consecutive_b_frame_count: u32,
    pub preferred_temporal_layer_count: u32,
    pub preferred_constant_qp: VideoEncodeH264QpKHR,
    pub preferred_max_l0_reference_count: u32,
    pub preferred_max_l1_reference_count: u32,
    pub preferred_entropy_coding_mode_flag: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for VideoEncodeH264QualityLevelPropertiesKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::VideoEncodeH264QualityLevelPropertiesKHR,
            next: ptr::null_mut(),
            preferred_rate_control_flags: Default::default(),
            preferred_gop_frame_count: 0,
            preferred_idr_period: 0,
            preferred_consecutive_b_frame_count: 0,
            preferred_temporal_layer_count: 0,
            preferred_constant_qp: Default::default(),
            preferred_max_l0_reference_count: 0,
            preferred_max_l1_reference_count: 0,
            preferred_entropy_coding_mode_flag: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsVideoEncodeQualityLevelPropertiesKHR for VideoEncodeH264QualityLevelPropertiesKHR<'_> {}

/// Extends: `VideoSessionCreateInfoKHR`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VideoEncodeH264SessionCreateInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub use_max_level_idc: Bool32,
    pub max_level_idc: H264LevelIdc,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for VideoEncodeH264SessionCreateInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::VideoEncodeH264SessionCreateInfoKHR,
            next: ptr::null_mut(),
            use_max_level_idc: FALSE,
            max_level_idc: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsVideoSessionCreateInfoKHR for VideoEncodeH264SessionCreateInfoKHR<'_> {}

/// Extends: `VideoSessionParametersUpdateInfoKHR`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VideoEncodeH264SessionParametersAddInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub sps_count: u32,
    /// Nullable
    /// Len: `sps_count`
    pub sp_ss: *const H264SequenceParameterSet<'a>,
    pub pps_count: u32,
    /// List of Picture Parameters associated with the spsStd, above
    /// Nullable
    /// Len: `pps_count`
    pub pp_ss: *const H264PictureParameterSet<'a>,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for VideoEncodeH264SessionParametersAddInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::VideoEncodeH264SessionParametersAddInfoKHR,
            next: ptr::null_mut(),
            sps_count: 0,
            sp_ss: ptr::null_mut(),
            pps_count: 0,
            pp_ss: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsVideoSessionParametersUpdateInfoKHR for VideoEncodeH264SessionParametersAddInfoKHR<'_> {}

/// Extends: `VideoSessionParametersCreateInfoKHR`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VideoEncodeH264SessionParametersCreateInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub max_sps_count: u32,
    pub max_pps_count: u32,
    /// Nullable
    pub parameters_add_info: *const VideoEncodeH264SessionParametersAddInfoKHR<'a>,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for VideoEncodeH264SessionParametersCreateInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::VideoEncodeH264SessionParametersCreateInfoKHR,
            next: ptr::null_mut(),
            max_sps_count: 0,
            max_pps_count: 0,
            parameters_add_info: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsVideoSessionParametersCreateInfoKHR
    for VideoEncodeH264SessionParametersCreateInfoKHR<'_>
{
}

/// Extends: `VideoEncodeSessionParametersGetInfoKHR`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VideoEncodeH264SessionParametersGetInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub write_sps: Bool32,
    pub write_pps: Bool32,
    pub sps_id: u32,
    pub pps_id: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for VideoEncodeH264SessionParametersGetInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::VideoEncodeH264SessionParametersGetInfoKHR,
            next: ptr::null_mut(),
            write_sps: FALSE,
            write_pps: FALSE,
            sps_id: 0,
            pps_id: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsVideoEncodeSessionParametersGetInfoKHR
    for VideoEncodeH264SessionParametersGetInfoKHR<'_>
{
}

/// Extends: `VideoEncodeSessionParametersFeedbackInfoKHR`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VideoEncodeH264SessionParametersFeedbackInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub has_sps_overrides: Bool32,
    pub has_pps_overrides: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for VideoEncodeH264SessionParametersFeedbackInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::VideoEncodeH264SessionParametersFeedbackInfoKHR,
            next: ptr::null_mut(),
            has_sps_overrides: FALSE,
            has_pps_overrides: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsVideoEncodeSessionParametersFeedbackInfoKHR
    for VideoEncodeH264SessionParametersFeedbackInfoKHR<'_>
{
}

/// Extends: `VideoReferenceSlotInfoKHR`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VideoEncodeH264DpbSlotInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub reference_info: *const EncodeH264ReferenceInfo,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for VideoEncodeH264DpbSlotInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::VideoEncodeH264DpbSlotInfoKHR,
            next: ptr::null_mut(),
            reference_info: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsVideoReferenceSlotInfoKHR for VideoEncodeH264DpbSlotInfoKHR<'_> {}

/// Extends: `VideoEncodeInfoKHR`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VideoEncodeH264PictureInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub nalu_slice_entry_count: u32,
    /// Len: `nalu_slice_entry_count`
    pub nalu_slice_entries: *const VideoEncodeH264NaluSliceInfoKHR<'a>,
    pub picture_info: *const EncodeH264PictureInfo<'a>,
    pub generate_prefix_nalu: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for VideoEncodeH264PictureInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::VideoEncodeH264PictureInfoKHR,
            next: ptr::null_mut(),
            nalu_slice_entry_count: 0,
            nalu_slice_entries: ptr::null_mut(),
            picture_info: ptr::null_mut(),
            generate_prefix_nalu: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsVideoEncodeInfoKHR for VideoEncodeH264PictureInfoKHR<'_> {}

/// Extends: `VideoProfileInfoKHR`, `QueryPoolCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VideoEncodeH264ProfileInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub profile_idc: H264ProfileIdc,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for VideoEncodeH264ProfileInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::VideoEncodeH264ProfileInfoKHR,
            next: ptr::null_mut(),
            profile_idc: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsVideoProfileInfoKHR for VideoEncodeH264ProfileInfoKHR<'_> {}
impl ExtendsQueryPoolCreateInfo for VideoEncodeH264ProfileInfoKHR<'_> {}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VideoEncodeH264NaluSliceInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub constant_qp: i32,
    pub slice_header: *const EncodeH264SliceHeader<'a>,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for VideoEncodeH264NaluSliceInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::VideoEncodeH264NaluSliceInfoKHR,
            next: ptr::null_mut(),
            constant_qp: 0,
            slice_header: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

/// Extends: `VideoCodingControlInfoKHR`, `VideoBeginCodingInfoKHR`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VideoEncodeH264RateControlInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub flags: VideoEncodeH264RateControlFlagsKHR,
    pub gop_frame_count: u32,
    pub idr_period: u32,
    pub consecutive_b_frame_count: u32,
    pub temporal_layer_count: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for VideoEncodeH264RateControlInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::VideoEncodeH264RateControlInfoKHR,
            next: ptr::null_mut(),
            flags: Default::default(),
            gop_frame_count: 0,
            idr_period: 0,
            consecutive_b_frame_count: 0,
            temporal_layer_count: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsVideoCodingControlInfoKHR for VideoEncodeH264RateControlInfoKHR<'_> {}
impl ExtendsVideoBeginCodingInfoKHR for VideoEncodeH264RateControlInfoKHR<'_> {}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VideoEncodeH264QpKHR {
    pub qp_i: i32,
    pub qp_p: i32,
    pub qp_b: i32,
}
impl Default for VideoEncodeH264QpKHR {
    fn default() -> Self {
        Self {
            qp_i: 0,
            qp_p: 0,
            qp_b: 0,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VideoEncodeH264FrameSizeKHR {
    pub frame_i_size: u32,
    pub frame_p_size: u32,
    pub frame_b_size: u32,
}
impl Default for VideoEncodeH264FrameSizeKHR {
    fn default() -> Self {
        Self {
            frame_i_size: 0,
            frame_p_size: 0,
            frame_b_size: 0,
        }
    }
}

/// Extends: `VideoBeginCodingInfoKHR`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VideoEncodeH264GopRemainingFrameInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub use_gop_remaining_frames: Bool32,
    pub gop_remaining_i: u32,
    pub gop_remaining_p: u32,
    pub gop_remaining_b: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for VideoEncodeH264GopRemainingFrameInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::VideoEncodeH264GopRemainingFrameInfoKHR,
            next: ptr::null_mut(),
            use_gop_remaining_frames: FALSE,
            gop_remaining_i: 0,
            gop_remaining_p: 0,
            gop_remaining_b: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsVideoBeginCodingInfoKHR for VideoEncodeH264GopRemainingFrameInfoKHR<'_> {}

/// Extends: `VideoEncodeRateControlLayerInfoKHR`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VideoEncodeH264RateControlLayerInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub use_min_qp: Bool32,
    pub min_qp: VideoEncodeH264QpKHR,
    pub use_max_qp: Bool32,
    pub max_qp: VideoEncodeH264QpKHR,
    pub use_max_frame_size: Bool32,
    pub max_frame_size: VideoEncodeH264FrameSizeKHR,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for VideoEncodeH264RateControlLayerInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::VideoEncodeH264RateControlLayerInfoKHR,
            next: ptr::null_mut(),
            use_min_qp: FALSE,
            min_qp: Default::default(),
            use_max_qp: FALSE,
            max_qp: Default::default(),
            use_max_frame_size: FALSE,
            max_frame_size: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsVideoEncodeRateControlLayerInfoKHR for VideoEncodeH264RateControlLayerInfoKHR<'_> {}

/// Extends: `VideoCapabilitiesKHR`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VideoEncodeH265CapabilitiesKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub flags: VideoEncodeH265CapabilityFlagsKHR,
    pub max_level_idc: H265LevelIdc,
    pub max_slice_segment_count: u32,
    pub max_tiles: Extent2D,
    pub ctb_sizes: VideoEncodeH265CtbSizeFlagsKHR,
    pub transform_block_sizes: VideoEncodeH265TransformBlockSizeFlagsKHR,
    pub max_p_picture_l0_reference_count: u32,
    pub max_b_picture_l0_reference_count: u32,
    pub max_l1_reference_count: u32,
    pub max_sub_layer_count: u32,
    pub expect_dyadic_temporal_sub_layer_pattern: Bool32,
    pub min_qp: i32,
    pub max_qp: i32,
    pub prefers_gop_remaining_frames: Bool32,
    pub requires_gop_remaining_frames: Bool32,
    pub syntax_flags: VideoEncodeH265StdFlagsKHR,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for VideoEncodeH265CapabilitiesKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::VideoEncodeH265CapabilitiesKHR,
            next: ptr::null_mut(),
            flags: Default::default(),
            max_level_idc: Default::default(),
            max_slice_segment_count: 0,
            max_tiles: Default::default(),
            ctb_sizes: Default::default(),
            transform_block_sizes: Default::default(),
            max_p_picture_l0_reference_count: 0,
            max_b_picture_l0_reference_count: 0,
            max_l1_reference_count: 0,
            max_sub_layer_count: 0,
            expect_dyadic_temporal_sub_layer_pattern: FALSE,
            min_qp: 0,
            max_qp: 0,
            prefers_gop_remaining_frames: FALSE,
            requires_gop_remaining_frames: FALSE,
            syntax_flags: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsVideoCapabilitiesKHR for VideoEncodeH265CapabilitiesKHR<'_> {}

/// Extends: `VideoEncodeQualityLevelPropertiesKHR`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VideoEncodeH265QualityLevelPropertiesKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub preferred_rate_control_flags: VideoEncodeH265RateControlFlagsKHR,
    pub preferred_gop_frame_count: u32,
    pub preferred_idr_period: u32,
    pub preferred_consecutive_b_frame_count: u32,
    pub preferred_sub_layer_count: u32,
    pub preferred_constant_qp: VideoEncodeH265QpKHR,
    pub preferred_max_l0_reference_count: u32,
    pub preferred_max_l1_reference_count: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for VideoEncodeH265QualityLevelPropertiesKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::VideoEncodeH265QualityLevelPropertiesKHR,
            next: ptr::null_mut(),
            preferred_rate_control_flags: Default::default(),
            preferred_gop_frame_count: 0,
            preferred_idr_period: 0,
            preferred_consecutive_b_frame_count: 0,
            preferred_sub_layer_count: 0,
            preferred_constant_qp: Default::default(),
            preferred_max_l0_reference_count: 0,
            preferred_max_l1_reference_count: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsVideoEncodeQualityLevelPropertiesKHR for VideoEncodeH265QualityLevelPropertiesKHR<'_> {}

/// Extends: `VideoSessionCreateInfoKHR`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VideoEncodeH265SessionCreateInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub use_max_level_idc: Bool32,
    pub max_level_idc: H265LevelIdc,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for VideoEncodeH265SessionCreateInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::VideoEncodeH265SessionCreateInfoKHR,
            next: ptr::null_mut(),
            use_max_level_idc: FALSE,
            max_level_idc: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsVideoSessionCreateInfoKHR for VideoEncodeH265SessionCreateInfoKHR<'_> {}

/// Extends: `VideoSessionParametersUpdateInfoKHR`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VideoEncodeH265SessionParametersAddInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub vps_count: u32,
    /// Nullable
    /// Len: `vps_count`
    pub vp_ss: *const H265VideoParameterSet<'a>,
    pub sps_count: u32,
    /// Nullable
    /// Len: `sps_count`
    pub sp_ss: *const H265SequenceParameterSet<'a>,
    pub pps_count: u32,
    /// List of Picture Parameters associated with the spsStd, above
    /// Nullable
    /// Len: `pps_count`
    pub pp_ss: *const H265PictureParameterSet<'a>,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for VideoEncodeH265SessionParametersAddInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::VideoEncodeH265SessionParametersAddInfoKHR,
            next: ptr::null_mut(),
            vps_count: 0,
            vp_ss: ptr::null_mut(),
            sps_count: 0,
            sp_ss: ptr::null_mut(),
            pps_count: 0,
            pp_ss: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsVideoSessionParametersUpdateInfoKHR for VideoEncodeH265SessionParametersAddInfoKHR<'_> {}

/// Extends: `VideoSessionParametersCreateInfoKHR`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VideoEncodeH265SessionParametersCreateInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub max_vps_count: u32,
    pub max_sps_count: u32,
    pub max_pps_count: u32,
    /// Nullable
    pub parameters_add_info: *const VideoEncodeH265SessionParametersAddInfoKHR<'a>,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for VideoEncodeH265SessionParametersCreateInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::VideoEncodeH265SessionParametersCreateInfoKHR,
            next: ptr::null_mut(),
            max_vps_count: 0,
            max_sps_count: 0,
            max_pps_count: 0,
            parameters_add_info: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsVideoSessionParametersCreateInfoKHR
    for VideoEncodeH265SessionParametersCreateInfoKHR<'_>
{
}

/// Extends: `VideoEncodeSessionParametersGetInfoKHR`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VideoEncodeH265SessionParametersGetInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub write_vps: Bool32,
    pub write_sps: Bool32,
    pub write_pps: Bool32,
    pub vps_id: u32,
    pub sps_id: u32,
    pub pps_id: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for VideoEncodeH265SessionParametersGetInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::VideoEncodeH265SessionParametersGetInfoKHR,
            next: ptr::null_mut(),
            write_vps: FALSE,
            write_sps: FALSE,
            write_pps: FALSE,
            vps_id: 0,
            sps_id: 0,
            pps_id: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsVideoEncodeSessionParametersGetInfoKHR
    for VideoEncodeH265SessionParametersGetInfoKHR<'_>
{
}

/// Extends: `VideoEncodeSessionParametersFeedbackInfoKHR`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VideoEncodeH265SessionParametersFeedbackInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub has_vps_overrides: Bool32,
    pub has_sps_overrides: Bool32,
    pub has_pps_overrides: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for VideoEncodeH265SessionParametersFeedbackInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::VideoEncodeH265SessionParametersFeedbackInfoKHR,
            next: ptr::null_mut(),
            has_vps_overrides: FALSE,
            has_sps_overrides: FALSE,
            has_pps_overrides: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsVideoEncodeSessionParametersFeedbackInfoKHR
    for VideoEncodeH265SessionParametersFeedbackInfoKHR<'_>
{
}

/// Extends: `VideoEncodeInfoKHR`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VideoEncodeH265PictureInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub nalu_slice_segment_entry_count: u32,
    /// Len: `nalu_slice_segment_entry_count`
    pub nalu_slice_segment_entries: *const VideoEncodeH265NaluSliceSegmentInfoKHR<'a>,
    pub picture_info: *const EncodeH265PictureInfo<'a>,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for VideoEncodeH265PictureInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::VideoEncodeH265PictureInfoKHR,
            next: ptr::null_mut(),
            nalu_slice_segment_entry_count: 0,
            nalu_slice_segment_entries: ptr::null_mut(),
            picture_info: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsVideoEncodeInfoKHR for VideoEncodeH265PictureInfoKHR<'_> {}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VideoEncodeH265NaluSliceSegmentInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub constant_qp: i32,
    pub slice_segment_header: *const EncodeH265SliceSegmentHeader<'a>,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for VideoEncodeH265NaluSliceSegmentInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::VideoEncodeH265NaluSliceSegmentInfoKHR,
            next: ptr::null_mut(),
            constant_qp: 0,
            slice_segment_header: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

/// Extends: `VideoCodingControlInfoKHR`, `VideoBeginCodingInfoKHR`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VideoEncodeH265RateControlInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub flags: VideoEncodeH265RateControlFlagsKHR,
    pub gop_frame_count: u32,
    pub idr_period: u32,
    pub consecutive_b_frame_count: u32,
    pub sub_layer_count: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for VideoEncodeH265RateControlInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::VideoEncodeH265RateControlInfoKHR,
            next: ptr::null_mut(),
            flags: Default::default(),
            gop_frame_count: 0,
            idr_period: 0,
            consecutive_b_frame_count: 0,
            sub_layer_count: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsVideoCodingControlInfoKHR for VideoEncodeH265RateControlInfoKHR<'_> {}
impl ExtendsVideoBeginCodingInfoKHR for VideoEncodeH265RateControlInfoKHR<'_> {}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VideoEncodeH265QpKHR {
    pub qp_i: i32,
    pub qp_p: i32,
    pub qp_b: i32,
}
impl Default for VideoEncodeH265QpKHR {
    fn default() -> Self {
        Self {
            qp_i: 0,
            qp_p: 0,
            qp_b: 0,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VideoEncodeH265FrameSizeKHR {
    pub frame_i_size: u32,
    pub frame_p_size: u32,
    pub frame_b_size: u32,
}
impl Default for VideoEncodeH265FrameSizeKHR {
    fn default() -> Self {
        Self {
            frame_i_size: 0,
            frame_p_size: 0,
            frame_b_size: 0,
        }
    }
}

/// Extends: `VideoBeginCodingInfoKHR`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VideoEncodeH265GopRemainingFrameInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub use_gop_remaining_frames: Bool32,
    pub gop_remaining_i: u32,
    pub gop_remaining_p: u32,
    pub gop_remaining_b: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for VideoEncodeH265GopRemainingFrameInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::VideoEncodeH265GopRemainingFrameInfoKHR,
            next: ptr::null_mut(),
            use_gop_remaining_frames: FALSE,
            gop_remaining_i: 0,
            gop_remaining_p: 0,
            gop_remaining_b: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsVideoBeginCodingInfoKHR for VideoEncodeH265GopRemainingFrameInfoKHR<'_> {}

/// Extends: `VideoEncodeRateControlLayerInfoKHR`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VideoEncodeH265RateControlLayerInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub use_min_qp: Bool32,
    pub min_qp: VideoEncodeH265QpKHR,
    pub use_max_qp: Bool32,
    pub max_qp: VideoEncodeH265QpKHR,
    pub use_max_frame_size: Bool32,
    pub max_frame_size: VideoEncodeH265FrameSizeKHR,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for VideoEncodeH265RateControlLayerInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::VideoEncodeH265RateControlLayerInfoKHR,
            next: ptr::null_mut(),
            use_min_qp: FALSE,
            min_qp: Default::default(),
            use_max_qp: FALSE,
            max_qp: Default::default(),
            use_max_frame_size: FALSE,
            max_frame_size: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsVideoEncodeRateControlLayerInfoKHR for VideoEncodeH265RateControlLayerInfoKHR<'_> {}

/// Extends: `VideoProfileInfoKHR`, `QueryPoolCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VideoEncodeH265ProfileInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub profile_idc: H265ProfileIdc,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for VideoEncodeH265ProfileInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::VideoEncodeH265ProfileInfoKHR,
            next: ptr::null_mut(),
            profile_idc: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsVideoProfileInfoKHR for VideoEncodeH265ProfileInfoKHR<'_> {}
impl ExtendsQueryPoolCreateInfo for VideoEncodeH265ProfileInfoKHR<'_> {}

/// Extends: `VideoReferenceSlotInfoKHR`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VideoEncodeH265DpbSlotInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub reference_info: *const EncodeH265ReferenceInfo,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for VideoEncodeH265DpbSlotInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::VideoEncodeH265DpbSlotInfoKHR,
            next: ptr::null_mut(),
            reference_info: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsVideoReferenceSlotInfoKHR for VideoEncodeH265DpbSlotInfoKHR<'_> {}

/// Extends: `VideoCapabilitiesKHR`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VideoEncodeAV1CapabilitiesKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub flags: VideoEncodeAV1CapabilityFlagsKHR,
    pub max_level: AV1Level,
    pub coded_picture_alignment: Extent2D,
    pub max_tiles: Extent2D,
    pub min_tile_size: Extent2D,
    pub max_tile_size: Extent2D,
    pub superblock_sizes: VideoEncodeAV1SuperblockSizeFlagsKHR,
    pub max_single_reference_count: u32,
    pub single_reference_name_mask: u32,
    pub max_unidirectional_compound_reference_count: u32,
    pub max_unidirectional_compound_group1_reference_count: u32,
    pub unidirectional_compound_reference_name_mask: u32,
    pub max_bidirectional_compound_reference_count: u32,
    pub max_bidirectional_compound_group1_reference_count: u32,
    pub max_bidirectional_compound_group2_reference_count: u32,
    pub bidirectional_compound_reference_name_mask: u32,
    pub max_temporal_layer_count: u32,
    pub max_spatial_layer_count: u32,
    pub max_operating_points: u32,
    pub min_q_index: u32,
    pub max_q_index: u32,
    pub prefers_gop_remaining_frames: Bool32,
    pub requires_gop_remaining_frames: Bool32,
    pub syntax_flags: VideoEncodeAV1StdFlagsKHR,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for VideoEncodeAV1CapabilitiesKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::VideoEncodeAV1CapabilitiesKHR,
            next: ptr::null_mut(),
            flags: Default::default(),
            max_level: Default::default(),
            coded_picture_alignment: Default::default(),
            max_tiles: Default::default(),
            min_tile_size: Default::default(),
            max_tile_size: Default::default(),
            superblock_sizes: Default::default(),
            max_single_reference_count: 0,
            single_reference_name_mask: 0,
            max_unidirectional_compound_reference_count: 0,
            max_unidirectional_compound_group1_reference_count: 0,
            unidirectional_compound_reference_name_mask: 0,
            max_bidirectional_compound_reference_count: 0,
            max_bidirectional_compound_group1_reference_count: 0,
            max_bidirectional_compound_group2_reference_count: 0,
            bidirectional_compound_reference_name_mask: 0,
            max_temporal_layer_count: 0,
            max_spatial_layer_count: 0,
            max_operating_points: 0,
            min_q_index: 0,
            max_q_index: 0,
            prefers_gop_remaining_frames: FALSE,
            requires_gop_remaining_frames: FALSE,
            syntax_flags: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsVideoCapabilitiesKHR for VideoEncodeAV1CapabilitiesKHR<'_> {}

/// Extends: `VideoEncodeQualityLevelPropertiesKHR`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VideoEncodeAV1QualityLevelPropertiesKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub preferred_rate_control_flags: VideoEncodeAV1RateControlFlagsKHR,
    pub preferred_gop_frame_count: u32,
    pub preferred_key_frame_period: u32,
    pub preferred_consecutive_bipredictive_frame_count: u32,
    pub preferred_temporal_layer_count: u32,
    pub preferred_constant_q_index: VideoEncodeAV1QIndexKHR,
    pub preferred_max_single_reference_count: u32,
    pub preferred_single_reference_name_mask: u32,
    pub preferred_max_unidirectional_compound_reference_count: u32,
    pub preferred_max_unidirectional_compound_group1_reference_count: u32,
    pub preferred_unidirectional_compound_reference_name_mask: u32,
    pub preferred_max_bidirectional_compound_reference_count: u32,
    pub preferred_max_bidirectional_compound_group1_reference_count: u32,
    pub preferred_max_bidirectional_compound_group2_reference_count: u32,
    pub preferred_bidirectional_compound_reference_name_mask: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for VideoEncodeAV1QualityLevelPropertiesKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::VideoEncodeAV1QualityLevelPropertiesKHR,
            next: ptr::null_mut(),
            preferred_rate_control_flags: Default::default(),
            preferred_gop_frame_count: 0,
            preferred_key_frame_period: 0,
            preferred_consecutive_bipredictive_frame_count: 0,
            preferred_temporal_layer_count: 0,
            preferred_constant_q_index: Default::default(),
            preferred_max_single_reference_count: 0,
            preferred_single_reference_name_mask: 0,
            preferred_max_unidirectional_compound_reference_count: 0,
            preferred_max_unidirectional_compound_group1_reference_count: 0,
            preferred_unidirectional_compound_reference_name_mask: 0,
            preferred_max_bidirectional_compound_reference_count: 0,
            preferred_max_bidirectional_compound_group1_reference_count: 0,
            preferred_max_bidirectional_compound_group2_reference_count: 0,
            preferred_bidirectional_compound_reference_name_mask: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsVideoEncodeQualityLevelPropertiesKHR for VideoEncodeAV1QualityLevelPropertiesKHR<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceVideoEncodeAV1FeaturesKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub video_encode_av1: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceVideoEncodeAV1FeaturesKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceVideoEncodeAV1FeaturesKHR,
            next: ptr::null_mut(),
            video_encode_av1: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVideoEncodeAV1FeaturesKHR<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceVideoEncodeAV1FeaturesKHR<'_> {}

/// Extends: `VideoSessionCreateInfoKHR`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VideoEncodeAV1SessionCreateInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub use_max_level: Bool32,
    pub max_level: AV1Level,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for VideoEncodeAV1SessionCreateInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::VideoEncodeAV1SessionCreateInfoKHR,
            next: ptr::null_mut(),
            use_max_level: FALSE,
            max_level: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsVideoSessionCreateInfoKHR for VideoEncodeAV1SessionCreateInfoKHR<'_> {}

/// Extends: `VideoSessionParametersCreateInfoKHR`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VideoEncodeAV1SessionParametersCreateInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub sequence_header: *const AV1SequenceHeader<'a>,
    /// Nullable
    pub decoder_model_info: *const EncodeAV1DecoderModelInfo,
    pub operating_point_count: u32,
    /// Nullable
    /// Len: `operating_point_count`
    pub operating_points: *const EncodeAV1OperatingPointInfo,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for VideoEncodeAV1SessionParametersCreateInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::VideoEncodeAV1SessionParametersCreateInfoKHR,
            next: ptr::null_mut(),
            sequence_header: ptr::null_mut(),
            decoder_model_info: ptr::null_mut(),
            operating_point_count: 0,
            operating_points: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsVideoSessionParametersCreateInfoKHR
    for VideoEncodeAV1SessionParametersCreateInfoKHR<'_>
{
}

/// Extends: `VideoReferenceSlotInfoKHR`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VideoEncodeAV1DpbSlotInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub reference_info: *const EncodeAV1ReferenceInfo<'a>,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for VideoEncodeAV1DpbSlotInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::VideoEncodeAV1DpbSlotInfoKHR,
            next: ptr::null_mut(),
            reference_info: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsVideoReferenceSlotInfoKHR for VideoEncodeAV1DpbSlotInfoKHR<'_> {}

/// Extends: `VideoEncodeInfoKHR`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VideoEncodeAV1PictureInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub prediction_mode: VideoEncodeAV1PredictionModeKHR,
    pub rate_control_group: VideoEncodeAV1RateControlGroupKHR,
    pub constant_q_index: u32,
    pub picture_info: *const EncodeAV1PictureInfo<'a>,
    pub reference_name_slot_indices: [i32; MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR as usize],
    pub primary_reference_cdf_only: Bool32,
    pub generate_obu_extension_header: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for VideoEncodeAV1PictureInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::VideoEncodeAV1PictureInfoKHR,
            next: ptr::null_mut(),
            prediction_mode: Default::default(),
            rate_control_group: Default::default(),
            constant_q_index: 0,
            picture_info: ptr::null_mut(),
            reference_name_slot_indices: unsafe { mem::zeroed() },
            primary_reference_cdf_only: FALSE,
            generate_obu_extension_header: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsVideoEncodeInfoKHR for VideoEncodeAV1PictureInfoKHR<'_> {}

/// Extends: `VideoProfileInfoKHR`, `QueryPoolCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VideoEncodeAV1ProfileInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub profile: AV1Profile,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for VideoEncodeAV1ProfileInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::VideoEncodeAV1ProfileInfoKHR,
            next: ptr::null_mut(),
            profile: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsVideoProfileInfoKHR for VideoEncodeAV1ProfileInfoKHR<'_> {}
impl ExtendsQueryPoolCreateInfo for VideoEncodeAV1ProfileInfoKHR<'_> {}

/// Extends: `VideoCodingControlInfoKHR`, `VideoBeginCodingInfoKHR`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VideoEncodeAV1RateControlInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub flags: VideoEncodeAV1RateControlFlagsKHR,
    pub gop_frame_count: u32,
    pub key_frame_period: u32,
    pub consecutive_bipredictive_frame_count: u32,
    pub temporal_layer_count: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for VideoEncodeAV1RateControlInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::VideoEncodeAV1RateControlInfoKHR,
            next: ptr::null_mut(),
            flags: Default::default(),
            gop_frame_count: 0,
            key_frame_period: 0,
            consecutive_bipredictive_frame_count: 0,
            temporal_layer_count: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsVideoCodingControlInfoKHR for VideoEncodeAV1RateControlInfoKHR<'_> {}
impl ExtendsVideoBeginCodingInfoKHR for VideoEncodeAV1RateControlInfoKHR<'_> {}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VideoEncodeAV1QIndexKHR {
    pub intra_q_index: u32,
    pub predictive_q_index: u32,
    pub bipredictive_q_index: u32,
}
impl Default for VideoEncodeAV1QIndexKHR {
    fn default() -> Self {
        Self {
            intra_q_index: 0,
            predictive_q_index: 0,
            bipredictive_q_index: 0,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VideoEncodeAV1FrameSizeKHR {
    pub intra_frame_size: u32,
    pub predictive_frame_size: u32,
    pub bipredictive_frame_size: u32,
}
impl Default for VideoEncodeAV1FrameSizeKHR {
    fn default() -> Self {
        Self {
            intra_frame_size: 0,
            predictive_frame_size: 0,
            bipredictive_frame_size: 0,
        }
    }
}

/// Extends: `VideoBeginCodingInfoKHR`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VideoEncodeAV1GopRemainingFrameInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub use_gop_remaining_frames: Bool32,
    pub gop_remaining_intra: u32,
    pub gop_remaining_predictive: u32,
    pub gop_remaining_bipredictive: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for VideoEncodeAV1GopRemainingFrameInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::VideoEncodeAV1GopRemainingFrameInfoKHR,
            next: ptr::null_mut(),
            use_gop_remaining_frames: FALSE,
            gop_remaining_intra: 0,
            gop_remaining_predictive: 0,
            gop_remaining_bipredictive: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsVideoBeginCodingInfoKHR for VideoEncodeAV1GopRemainingFrameInfoKHR<'_> {}

/// Extends: `VideoEncodeRateControlLayerInfoKHR`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VideoEncodeAV1RateControlLayerInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub use_min_q_index: Bool32,
    pub min_q_index: VideoEncodeAV1QIndexKHR,
    pub use_max_q_index: Bool32,
    pub max_q_index: VideoEncodeAV1QIndexKHR,
    pub use_max_frame_size: Bool32,
    pub max_frame_size: VideoEncodeAV1FrameSizeKHR,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for VideoEncodeAV1RateControlLayerInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::VideoEncodeAV1RateControlLayerInfoKHR,
            next: ptr::null_mut(),
            use_min_q_index: FALSE,
            min_q_index: Default::default(),
            use_max_q_index: FALSE,
            max_q_index: Default::default(),
            use_max_frame_size: FALSE,
            max_frame_size: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsVideoEncodeRateControlLayerInfoKHR for VideoEncodeAV1RateControlLayerInfoKHR<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceInheritedViewportScissorFeaturesNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub inherited_viewport_scissor2_d: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceInheritedViewportScissorFeaturesNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceInheritedViewportScissorFeaturesNV,
            next: ptr::null_mut(),
            inherited_viewport_scissor2_d: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceInheritedViewportScissorFeaturesNV<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceInheritedViewportScissorFeaturesNV<'_> {}

/// Extends: `CommandBufferInheritanceInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct CommandBufferInheritanceViewportScissorInfoNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub viewport_scissor2_d: Bool32,
    pub viewport_depth_count: u32,
    pub viewport_depths: *const Viewport,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for CommandBufferInheritanceViewportScissorInfoNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::CommandBufferInheritanceViewportScissorInfoNV,
            next: ptr::null_mut(),
            viewport_scissor2_d: FALSE,
            viewport_depth_count: 0,
            viewport_depths: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsCommandBufferInheritanceInfo for CommandBufferInheritanceViewportScissorInfoNV<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub ycbcr2plane444_formats: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT,
            next: ptr::null_mut(),
            ycbcr2plane444_formats: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceProvokingVertexFeaturesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub provoking_vertex_last: Bool32,
    pub transform_feedback_preserves_provoking_vertex: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceProvokingVertexFeaturesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceProvokingVertexFeaturesEXT,
            next: ptr::null_mut(),
            provoking_vertex_last: FALSE,
            transform_feedback_preserves_provoking_vertex: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceProvokingVertexFeaturesEXT<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceProvokingVertexFeaturesEXT<'_> {}

/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceProvokingVertexPropertiesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub provoking_vertex_mode_per_pipeline: Bool32,
    pub transform_feedback_preserves_triangle_fan_provoking_vertex: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceProvokingVertexPropertiesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceProvokingVertexPropertiesEXT,
            next: ptr::null_mut(),
            provoking_vertex_mode_per_pipeline: FALSE,
            transform_feedback_preserves_triangle_fan_provoking_vertex: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceProvokingVertexPropertiesEXT<'_> {}

/// Extends: `PipelineRasterizationStateCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PipelineRasterizationProvokingVertexStateCreateInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub provoking_vertex_mode: ProvokingVertexModeEXT,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PipelineRasterizationProvokingVertexStateCreateInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PipelineRasterizationProvokingVertexStateCreateInfoEXT,
            next: ptr::null_mut(),
            provoking_vertex_mode: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsPipelineRasterizationStateCreateInfo
    for PipelineRasterizationProvokingVertexStateCreateInfoEXT<'_>
{
}

/// Extends: `VideoCapabilitiesKHR`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VideoEncodeIntraRefreshCapabilitiesKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub intra_refresh_modes: VideoEncodeIntraRefreshModeFlagsKHR,
    pub max_intra_refresh_cycle_duration: u32,
    pub max_intra_refresh_active_reference_pictures: u32,
    pub partition_independent_intra_refresh_regions: Bool32,
    pub non_rectangular_intra_refresh_regions: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for VideoEncodeIntraRefreshCapabilitiesKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::VideoEncodeIntraRefreshCapabilitiesKHR,
            next: ptr::null_mut(),
            intra_refresh_modes: Default::default(),
            max_intra_refresh_cycle_duration: 0,
            max_intra_refresh_active_reference_pictures: 0,
            partition_independent_intra_refresh_regions: FALSE,
            non_rectangular_intra_refresh_regions: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsVideoCapabilitiesKHR for VideoEncodeIntraRefreshCapabilitiesKHR<'_> {}

/// Extends: `VideoSessionCreateInfoKHR`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VideoEncodeSessionIntraRefreshCreateInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub intra_refresh_mode: VideoEncodeIntraRefreshModeFlagsKHR,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for VideoEncodeSessionIntraRefreshCreateInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::VideoEncodeSessionIntraRefreshCreateInfoKHR,
            next: ptr::null_mut(),
            intra_refresh_mode: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsVideoSessionCreateInfoKHR for VideoEncodeSessionIntraRefreshCreateInfoKHR<'_> {}

/// Extends: `VideoEncodeInfoKHR`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VideoEncodeIntraRefreshInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub intra_refresh_cycle_duration: u32,
    pub intra_refresh_index: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for VideoEncodeIntraRefreshInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::VideoEncodeIntraRefreshInfoKHR,
            next: ptr::null_mut(),
            intra_refresh_cycle_duration: 0,
            intra_refresh_index: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsVideoEncodeInfoKHR for VideoEncodeIntraRefreshInfoKHR<'_> {}

/// Extends: `VideoReferenceSlotInfoKHR`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VideoReferenceIntraRefreshInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub dirty_intra_refresh_regions: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for VideoReferenceIntraRefreshInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::VideoReferenceIntraRefreshInfoKHR,
            next: ptr::null_mut(),
            dirty_intra_refresh_regions: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsVideoReferenceSlotInfoKHR for VideoReferenceIntraRefreshInfoKHR<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub video_encode_intra_refresh: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR,
            next: ptr::null_mut(),
            video_encode_intra_refresh: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR<'_> {}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct CuModuleCreateInfoNVX<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub data_size: usize,
    /// Len: `data_size`
    pub data: *const c_void,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for CuModuleCreateInfoNVX<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::CuModuleCreateInfoNVX,
            next: ptr::null_mut(),
            data_size: 0,
            data: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsCuModuleCreateInfoNVX {}
impl<'a> CuModuleCreateInfoNVX<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsCuModuleCreateInfoNVX>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

/// Extends: `CuModuleCreateInfoNVX`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct CuModuleTexturingModeCreateInfoNVX<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub use64bit_texturing: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for CuModuleTexturingModeCreateInfoNVX<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::CuModuleTexturingModeCreateInfoNVX,
            next: ptr::null_mut(),
            use64bit_texturing: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsCuModuleCreateInfoNVX for CuModuleTexturingModeCreateInfoNVX<'_> {}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct CuFunctionCreateInfoNVX<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub module: CuModuleNVX,
    /// Len: null-terminated
    pub name: *const c_char,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for CuFunctionCreateInfoNVX<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::CuFunctionCreateInfoNVX,
            next: ptr::null_mut(),
            module: Default::default(),
            name: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct CuLaunchInfoNVX<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub function: CuFunctionNVX,
    pub grid_dim_x: u32,
    pub grid_dim_y: u32,
    pub grid_dim_z: u32,
    pub block_dim_x: u32,
    pub block_dim_y: u32,
    pub block_dim_z: u32,
    pub shared_mem_bytes: u32,
    pub param_count: usize,
    /// Len: `param_count`
    pub params: *const *const c_void,
    pub extra_count: usize,
    /// Len: `extra_count`
    pub extras: *const *const c_void,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for CuLaunchInfoNVX<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::CuLaunchInfoNVX,
            next: ptr::null_mut(),
            function: Default::default(),
            grid_dim_x: 0,
            grid_dim_y: 0,
            grid_dim_z: 0,
            block_dim_x: 0,
            block_dim_y: 0,
            block_dim_z: 0,
            shared_mem_bytes: 0,
            param_count: 0,
            params: ptr::null_mut(),
            extra_count: 0,
            extras: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceDescriptorBufferFeaturesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub descriptor_buffer: Bool32,
    pub descriptor_buffer_capture_replay: Bool32,
    pub descriptor_buffer_image_layout_ignored: Bool32,
    pub descriptor_buffer_push_descriptors: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceDescriptorBufferFeaturesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceDescriptorBufferFeaturesEXT,
            next: ptr::null_mut(),
            descriptor_buffer: FALSE,
            descriptor_buffer_capture_replay: FALSE,
            descriptor_buffer_image_layout_ignored: FALSE,
            descriptor_buffer_push_descriptors: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDescriptorBufferFeaturesEXT<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceDescriptorBufferFeaturesEXT<'_> {}

/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceDescriptorBufferPropertiesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub combined_image_sampler_descriptor_single_array: Bool32,
    pub bufferless_push_descriptors: Bool32,
    pub allow_sampler_image_view_post_submit_creation: Bool32,
    pub descriptor_buffer_offset_alignment: DeviceSize,
    pub max_descriptor_buffer_bindings: u32,
    pub max_resource_descriptor_buffer_bindings: u32,
    pub max_sampler_descriptor_buffer_bindings: u32,
    pub max_embedded_immutable_sampler_bindings: u32,
    pub max_embedded_immutable_samplers: u32,
    pub buffer_capture_replay_descriptor_data_size: usize,
    pub image_capture_replay_descriptor_data_size: usize,
    pub image_view_capture_replay_descriptor_data_size: usize,
    pub sampler_capture_replay_descriptor_data_size: usize,
    pub acceleration_structure_capture_replay_descriptor_data_size: usize,
    pub sampler_descriptor_size: usize,
    pub combined_image_sampler_descriptor_size: usize,
    pub sampled_image_descriptor_size: usize,
    pub storage_image_descriptor_size: usize,
    pub uniform_texel_buffer_descriptor_size: usize,
    pub robust_uniform_texel_buffer_descriptor_size: usize,
    pub storage_texel_buffer_descriptor_size: usize,
    pub robust_storage_texel_buffer_descriptor_size: usize,
    pub uniform_buffer_descriptor_size: usize,
    pub robust_uniform_buffer_descriptor_size: usize,
    pub storage_buffer_descriptor_size: usize,
    pub robust_storage_buffer_descriptor_size: usize,
    pub input_attachment_descriptor_size: usize,
    pub acceleration_structure_descriptor_size: usize,
    pub max_sampler_descriptor_buffer_range: DeviceSize,
    pub max_resource_descriptor_buffer_range: DeviceSize,
    pub sampler_descriptor_buffer_address_space_size: DeviceSize,
    pub resource_descriptor_buffer_address_space_size: DeviceSize,
    pub descriptor_buffer_address_space_size: DeviceSize,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceDescriptorBufferPropertiesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceDescriptorBufferPropertiesEXT,
            next: ptr::null_mut(),
            combined_image_sampler_descriptor_single_array: FALSE,
            bufferless_push_descriptors: FALSE,
            allow_sampler_image_view_post_submit_creation: FALSE,
            descriptor_buffer_offset_alignment: Default::default(),
            max_descriptor_buffer_bindings: 0,
            max_resource_descriptor_buffer_bindings: 0,
            max_sampler_descriptor_buffer_bindings: 0,
            max_embedded_immutable_sampler_bindings: 0,
            max_embedded_immutable_samplers: 0,
            buffer_capture_replay_descriptor_data_size: 0,
            image_capture_replay_descriptor_data_size: 0,
            image_view_capture_replay_descriptor_data_size: 0,
            sampler_capture_replay_descriptor_data_size: 0,
            acceleration_structure_capture_replay_descriptor_data_size: 0,
            sampler_descriptor_size: 0,
            combined_image_sampler_descriptor_size: 0,
            sampled_image_descriptor_size: 0,
            storage_image_descriptor_size: 0,
            uniform_texel_buffer_descriptor_size: 0,
            robust_uniform_texel_buffer_descriptor_size: 0,
            storage_texel_buffer_descriptor_size: 0,
            robust_storage_texel_buffer_descriptor_size: 0,
            uniform_buffer_descriptor_size: 0,
            robust_uniform_buffer_descriptor_size: 0,
            storage_buffer_descriptor_size: 0,
            robust_storage_buffer_descriptor_size: 0,
            input_attachment_descriptor_size: 0,
            acceleration_structure_descriptor_size: 0,
            max_sampler_descriptor_buffer_range: Default::default(),
            max_resource_descriptor_buffer_range: Default::default(),
            sampler_descriptor_buffer_address_space_size: Default::default(),
            resource_descriptor_buffer_address_space_size: Default::default(),
            descriptor_buffer_address_space_size: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDescriptorBufferPropertiesEXT<'_> {}

/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub combined_image_sampler_density_map_descriptor_size: usize,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT,
            next: ptr::null_mut(),
            combined_image_sampler_density_map_descriptor_size: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2
    for PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT<'_>
{
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DescriptorAddressInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub address: DeviceAddress,
    pub range: DeviceSize,
    pub format: Format,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for DescriptorAddressInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::DescriptorAddressInfoEXT,
            next: ptr::null_mut(),
            address: Default::default(),
            range: Default::default(),
            format: Default::default(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DescriptorBufferBindingInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub address: DeviceAddress,
    pub usage: BufferUsageFlags,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for DescriptorBufferBindingInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::DescriptorBufferBindingInfoEXT,
            next: ptr::null_mut(),
            address: Default::default(),
            usage: Default::default(),
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsDescriptorBufferBindingInfoEXT {}
impl<'a> DescriptorBufferBindingInfoEXT<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsDescriptorBufferBindingInfoEXT>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

/// Extends: `DescriptorBufferBindingInfoEXT`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DescriptorBufferBindingPushDescriptorBufferHandleEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub buffer: Buffer,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for DescriptorBufferBindingPushDescriptorBufferHandleEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::DescriptorBufferBindingPushDescriptorBufferHandleEXT,
            next: ptr::null_mut(),
            buffer: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsDescriptorBufferBindingInfoEXT
    for DescriptorBufferBindingPushDescriptorBufferHandleEXT<'_>
{
}

#[repr(C)]
#[derive(Copy, Clone)]
pub union DescriptorDataEXT<'a> {
    pub sampler: *const Sampler,
    pub combined_image_sampler: *const DescriptorImageInfo,
    pub input_attachment_image: *const DescriptorImageInfo,
    /// Nullable
    pub sampled_image: *const DescriptorImageInfo,
    /// Nullable
    pub storage_image: *const DescriptorImageInfo,
    /// Nullable
    pub uniform_texel_buffer: *const DescriptorAddressInfoEXT<'a>,
    /// Nullable
    pub storage_texel_buffer: *const DescriptorAddressInfoEXT<'a>,
    /// Nullable
    pub uniform_buffer: *const DescriptorAddressInfoEXT<'a>,
    /// Nullable
    pub storage_buffer: *const DescriptorAddressInfoEXT<'a>,
    pub acceleration_structure: DeviceAddress,
}
impl Default for DescriptorDataEXT<'_> {
    fn default() -> Self {
        unsafe { mem::zeroed() }
    }
}

impl fmt::Debug for DescriptorDataEXT<'_> {
    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
        fmt.debug_struct("DescriptorDataEXT").finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DescriptorGetInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub ty: DescriptorType,
    pub data: DescriptorDataEXT<'a>,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for DescriptorGetInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::DescriptorGetInfoEXT,
            next: ptr::null_mut(),
            ty: Default::default(),
            data: Default::default(),
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsDescriptorGetInfoEXT {}
impl<'a> DescriptorGetInfoEXT<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsDescriptorGetInfoEXT>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct BufferCaptureDescriptorDataInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub buffer: Buffer,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for BufferCaptureDescriptorDataInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::BufferCaptureDescriptorDataInfoEXT,
            next: ptr::null_mut(),
            buffer: Default::default(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ImageCaptureDescriptorDataInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub image: Image,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ImageCaptureDescriptorDataInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ImageCaptureDescriptorDataInfoEXT,
            next: ptr::null_mut(),
            image: Default::default(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ImageViewCaptureDescriptorDataInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub image_view: ImageView,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ImageViewCaptureDescriptorDataInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ImageViewCaptureDescriptorDataInfoEXT,
            next: ptr::null_mut(),
            image_view: Default::default(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct SamplerCaptureDescriptorDataInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub sampler: Sampler,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for SamplerCaptureDescriptorDataInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::SamplerCaptureDescriptorDataInfoEXT,
            next: ptr::null_mut(),
            sampler: Default::default(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct AccelerationStructureCaptureDescriptorDataInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub acceleration_structure: AccelerationStructureKHR,
    pub acceleration_structure_nv: AccelerationStructureNV,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for AccelerationStructureCaptureDescriptorDataInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::AccelerationStructureCaptureDescriptorDataInfoEXT,
            next: ptr::null_mut(),
            acceleration_structure: Default::default(),
            acceleration_structure_nv: Default::default(),
            _marker: PhantomData,
        }
    }
}

/// Extends: `BufferCreateInfo`, `ImageCreateInfo`, `ImageViewCreateInfo`, `SamplerCreateInfo`, `AccelerationStructureCreateInfoKHR`, `AccelerationStructureCreateInfoNV`, `TensorCreateInfoARM`, `TensorViewCreateInfoARM`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct OpaqueCaptureDescriptorDataCreateInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub opaque_capture_descriptor_data: *const c_void,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for OpaqueCaptureDescriptorDataCreateInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::OpaqueCaptureDescriptorDataCreateInfoEXT,
            next: ptr::null_mut(),
            opaque_capture_descriptor_data: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsBufferCreateInfo for OpaqueCaptureDescriptorDataCreateInfoEXT<'_> {}
impl ExtendsImageCreateInfo for OpaqueCaptureDescriptorDataCreateInfoEXT<'_> {}
impl ExtendsImageViewCreateInfo for OpaqueCaptureDescriptorDataCreateInfoEXT<'_> {}
impl ExtendsSamplerCreateInfo for OpaqueCaptureDescriptorDataCreateInfoEXT<'_> {}
impl ExtendsAccelerationStructureCreateInfoKHR for OpaqueCaptureDescriptorDataCreateInfoEXT<'_> {}
impl ExtendsAccelerationStructureCreateInfoNV for OpaqueCaptureDescriptorDataCreateInfoEXT<'_> {}
impl ExtendsTensorCreateInfoARM for OpaqueCaptureDescriptorDataCreateInfoEXT<'_> {}
impl ExtendsTensorViewCreateInfoARM for OpaqueCaptureDescriptorDataCreateInfoEXT<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceShaderIntegerDotProductFeatures<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub shader_integer_dot_product: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceShaderIntegerDotProductFeatures<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceShaderIntegerDotProductFeatures,
            next: ptr::null_mut(),
            shader_integer_dot_product: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderIntegerDotProductFeatures<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderIntegerDotProductFeatures<'_> {}

pub type PhysicalDeviceShaderIntegerDotProductFeaturesKHR<'a> =
    PhysicalDeviceShaderIntegerDotProductFeatures<'a>;
/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceShaderIntegerDotProductProperties<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub integer_dot_product8_bit_unsigned_accelerated: Bool32,
    pub integer_dot_product8_bit_signed_accelerated: Bool32,
    pub integer_dot_product8_bit_mixed_signedness_accelerated: Bool32,
    pub integer_dot_product4x8_bit_packed_unsigned_accelerated: Bool32,
    pub integer_dot_product4x8_bit_packed_signed_accelerated: Bool32,
    pub integer_dot_product4x8_bit_packed_mixed_signedness_accelerated: Bool32,
    pub integer_dot_product16_bit_unsigned_accelerated: Bool32,
    pub integer_dot_product16_bit_signed_accelerated: Bool32,
    pub integer_dot_product16_bit_mixed_signedness_accelerated: Bool32,
    pub integer_dot_product32_bit_unsigned_accelerated: Bool32,
    pub integer_dot_product32_bit_signed_accelerated: Bool32,
    pub integer_dot_product32_bit_mixed_signedness_accelerated: Bool32,
    pub integer_dot_product64_bit_unsigned_accelerated: Bool32,
    pub integer_dot_product64_bit_signed_accelerated: Bool32,
    pub integer_dot_product64_bit_mixed_signedness_accelerated: Bool32,
    pub integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated: Bool32,
    pub integer_dot_product_accumulating_saturating8_bit_signed_accelerated: Bool32,
    pub integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated: Bool32,
    pub integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated: Bool32,
    pub integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated: Bool32,
    pub integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated:
        Bool32,
    pub integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated: Bool32,
    pub integer_dot_product_accumulating_saturating16_bit_signed_accelerated: Bool32,
    pub integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated: Bool32,
    pub integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated: Bool32,
    pub integer_dot_product_accumulating_saturating32_bit_signed_accelerated: Bool32,
    pub integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated: Bool32,
    pub integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated: Bool32,
    pub integer_dot_product_accumulating_saturating64_bit_signed_accelerated: Bool32,
    pub integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceShaderIntegerDotProductProperties<'_> {
    fn default() -> Self {
        Self {
s_type: StructureType::PhysicalDeviceShaderIntegerDotProductProperties,
next: ptr::null_mut(),
integer_dot_product8_bit_unsigned_accelerated: FALSE,
integer_dot_product8_bit_signed_accelerated: FALSE,
integer_dot_product8_bit_mixed_signedness_accelerated: FALSE,
integer_dot_product4x8_bit_packed_unsigned_accelerated: FALSE,
integer_dot_product4x8_bit_packed_signed_accelerated: FALSE,
integer_dot_product4x8_bit_packed_mixed_signedness_accelerated: FALSE,
integer_dot_product16_bit_unsigned_accelerated: FALSE,
integer_dot_product16_bit_signed_accelerated: FALSE,
integer_dot_product16_bit_mixed_signedness_accelerated: FALSE,
integer_dot_product32_bit_unsigned_accelerated: FALSE,
integer_dot_product32_bit_signed_accelerated: FALSE,
integer_dot_product32_bit_mixed_signedness_accelerated: FALSE,
integer_dot_product64_bit_unsigned_accelerated: FALSE,
integer_dot_product64_bit_signed_accelerated: FALSE,
integer_dot_product64_bit_mixed_signedness_accelerated: FALSE,
integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated: FALSE,
integer_dot_product_accumulating_saturating8_bit_signed_accelerated: FALSE,
integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated: FALSE,
integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated: FALSE,
integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated: FALSE,
integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated: FALSE,
integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated: FALSE,
integer_dot_product_accumulating_saturating16_bit_signed_accelerated: FALSE,
integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated: FALSE,
integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated: FALSE,
integer_dot_product_accumulating_saturating32_bit_signed_accelerated: FALSE,
integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated: FALSE,
integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated: FALSE,
integer_dot_product_accumulating_saturating64_bit_signed_accelerated: FALSE,
integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated: FALSE,
_marker: PhantomData,
}
    }
}

impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceShaderIntegerDotProductProperties<'_> {}

pub type PhysicalDeviceShaderIntegerDotProductPropertiesKHR<'a> =
    PhysicalDeviceShaderIntegerDotProductProperties<'a>;
/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceDrmPropertiesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub has_primary: Bool32,
    pub has_render: Bool32,
    pub primary_major: i64,
    pub primary_minor: i64,
    pub render_major: i64,
    pub render_minor: i64,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceDrmPropertiesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceDrmPropertiesEXT,
            next: ptr::null_mut(),
            has_primary: FALSE,
            has_render: FALSE,
            primary_major: 0,
            primary_minor: 0,
            render_major: 0,
            render_minor: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDrmPropertiesEXT<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceFragmentShaderBarycentricFeaturesKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub fragment_shader_barycentric: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceFragmentShaderBarycentricFeaturesKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceFragmentShaderBarycentricFeaturesKHR,
            next: ptr::null_mut(),
            fragment_shader_barycentric: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceFragmentShaderBarycentricFeaturesKHR<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentShaderBarycentricFeaturesKHR<'_> {}

/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceFragmentShaderBarycentricPropertiesKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub tri_strip_vertex_order_independent_of_provoking_vertex: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceFragmentShaderBarycentricPropertiesKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceFragmentShaderBarycentricPropertiesKHR,
            next: ptr::null_mut(),
            tri_strip_vertex_order_independent_of_provoking_vertex: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceFragmentShaderBarycentricPropertiesKHR<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceShaderFmaFeaturesKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub shader_fma_float16: Bool32,
    pub shader_fma_float32: Bool32,
    pub shader_fma_float64: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceShaderFmaFeaturesKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceShaderFmaFeaturesKHR,
            next: ptr::null_mut(),
            shader_fma_float16: FALSE,
            shader_fma_float32: FALSE,
            shader_fma_float64: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderFmaFeaturesKHR<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderFmaFeaturesKHR<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceRayTracingMotionBlurFeaturesNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub ray_tracing_motion_blur: Bool32,
    pub ray_tracing_motion_blur_pipeline_trace_rays_indirect: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceRayTracingMotionBlurFeaturesNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceRayTracingMotionBlurFeaturesNV,
            next: ptr::null_mut(),
            ray_tracing_motion_blur: FALSE,
            ray_tracing_motion_blur_pipeline_trace_rays_indirect: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceRayTracingMotionBlurFeaturesNV<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceRayTracingMotionBlurFeaturesNV<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceRayTracingValidationFeaturesNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub ray_tracing_validation: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceRayTracingValidationFeaturesNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceRayTracingValidationFeaturesNV,
            next: ptr::null_mut(),
            ray_tracing_validation: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceRayTracingValidationFeaturesNV<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceRayTracingValidationFeaturesNV<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub spheres: Bool32,
    pub linear_swept_spheres: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV,
            next: ptr::null_mut(),
            spheres: FALSE,
            linear_swept_spheres: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV<'_> {}

/// Extends: `AccelerationStructureGeometryTrianglesDataKHR`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct AccelerationStructureGeometryMotionTrianglesDataNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub vertex_data: DeviceOrHostAddressConstKHR,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for AccelerationStructureGeometryMotionTrianglesDataNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::AccelerationStructureGeometryMotionTrianglesDataNV,
            next: ptr::null_mut(),
            vertex_data: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsAccelerationStructureGeometryTrianglesDataKHR
    for AccelerationStructureGeometryMotionTrianglesDataNV<'_>
{
}

/// Extends: `AccelerationStructureCreateInfoKHR`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct AccelerationStructureMotionInfoNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub max_instances: u32,
    pub flags: AccelerationStructureMotionInfoFlagsNV,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for AccelerationStructureMotionInfoNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::AccelerationStructureMotionInfoNV,
            next: ptr::null_mut(),
            max_instances: 0,
            flags: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsAccelerationStructureCreateInfoKHR for AccelerationStructureMotionInfoNV<'_> {}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct SRTDataNV {
    pub sx: f32,
    pub a: f32,
    pub b: f32,
    pub pvx: f32,
    pub sy: f32,
    pub c: f32,
    pub pvy: f32,
    pub sz: f32,
    pub pvz: f32,
    pub qx: f32,
    pub qy: f32,
    pub qz: f32,
    pub qw: f32,
    pub tx: f32,
    pub ty: f32,
    pub tz: f32,
}
impl Default for SRTDataNV {
    fn default() -> Self {
        Self {
            sx: 0.0,
            a: 0.0,
            b: 0.0,
            pvx: 0.0,
            sy: 0.0,
            c: 0.0,
            pvy: 0.0,
            sz: 0.0,
            pvz: 0.0,
            qx: 0.0,
            qy: 0.0,
            qz: 0.0,
            qw: 0.0,
            tx: 0.0,
            ty: 0.0,
            tz: 0.0,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct AccelerationStructureSRTMotionInstanceNV {
    pub transform_t0: SRTDataNV,
    pub transform_t1: SRTDataNV,
    pub instance_custom_index: u32,
    pub mask: u32,
    pub instance_shader_binding_table_record_offset: u32,
    pub flags: GeometryInstanceFlagsKHR,
    pub acceleration_structure_reference: u64,
}
impl Default for AccelerationStructureSRTMotionInstanceNV {
    fn default() -> Self {
        Self {
            transform_t0: Default::default(),
            transform_t1: Default::default(),
            instance_custom_index: 0,
            mask: 0,
            instance_shader_binding_table_record_offset: 0,
            flags: Default::default(),
            acceleration_structure_reference: 0,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct AccelerationStructureMatrixMotionInstanceNV {
    pub transform_t0: TransformMatrixKHR,
    pub transform_t1: TransformMatrixKHR,
    pub instance_custom_index: u32,
    pub mask: u32,
    pub instance_shader_binding_table_record_offset: u32,
    pub flags: GeometryInstanceFlagsKHR,
    pub acceleration_structure_reference: u64,
}
impl Default for AccelerationStructureMatrixMotionInstanceNV {
    fn default() -> Self {
        Self {
            transform_t0: Default::default(),
            transform_t1: Default::default(),
            instance_custom_index: 0,
            mask: 0,
            instance_shader_binding_table_record_offset: 0,
            flags: Default::default(),
            acceleration_structure_reference: 0,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub union AccelerationStructureMotionInstanceDataNV {
    pub static_instance: AccelerationStructureInstanceKHR,
    pub matrix_motion_instance: AccelerationStructureMatrixMotionInstanceNV,
    pub srt_motion_instance: AccelerationStructureSRTMotionInstanceNV,
}
impl Default for AccelerationStructureMotionInstanceDataNV {
    fn default() -> Self {
        unsafe { mem::zeroed() }
    }
}

impl fmt::Debug for AccelerationStructureMotionInstanceDataNV {
    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
        fmt.debug_struct("AccelerationStructureMotionInstanceDataNV")
            .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct AccelerationStructureMotionInstanceNV {
    pub ty: AccelerationStructureMotionInstanceTypeNV,
    pub flags: AccelerationStructureMotionInstanceFlagsNV,
    pub data: AccelerationStructureMotionInstanceDataNV,
}
impl Default for AccelerationStructureMotionInstanceNV {
    fn default() -> Self {
        Self {
            ty: Default::default(),
            flags: Default::default(),
            data: Default::default(),
        }
    }
}

pub type RemoteAddressNV = c_void;
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct MemoryGetRemoteAddressInfoNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub memory: DeviceMemory,
    pub handle_type: ExternalMemoryHandleTypeFlags,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for MemoryGetRemoteAddressInfoNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::MemoryGetRemoteAddressInfoNV,
            next: ptr::null_mut(),
            memory: Default::default(),
            handle_type: Default::default(),
            _marker: PhantomData,
        }
    }
}

/// Extends: `MemoryAllocateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ImportMemoryBufferCollectionFUCHSIA<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub collection: BufferCollectionFUCHSIA,
    pub index: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ImportMemoryBufferCollectionFUCHSIA<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ImportMemoryBufferCollectionFUCHSIA,
            next: ptr::null_mut(),
            collection: Default::default(),
            index: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsMemoryAllocateInfo for ImportMemoryBufferCollectionFUCHSIA<'_> {}

/// Extends: `ImageCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct BufferCollectionImageCreateInfoFUCHSIA<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub collection: BufferCollectionFUCHSIA,
    pub index: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for BufferCollectionImageCreateInfoFUCHSIA<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::BufferCollectionImageCreateInfoFUCHSIA,
            next: ptr::null_mut(),
            collection: Default::default(),
            index: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsImageCreateInfo for BufferCollectionImageCreateInfoFUCHSIA<'_> {}

/// Extends: `BufferCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct BufferCollectionBufferCreateInfoFUCHSIA<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub collection: BufferCollectionFUCHSIA,
    pub index: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for BufferCollectionBufferCreateInfoFUCHSIA<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::BufferCollectionBufferCreateInfoFUCHSIA,
            next: ptr::null_mut(),
            collection: Default::default(),
            index: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsBufferCreateInfo for BufferCollectionBufferCreateInfoFUCHSIA<'_> {}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct BufferCollectionCreateInfoFUCHSIA<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub collection_token: zx_handle_t,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for BufferCollectionCreateInfoFUCHSIA<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::BufferCollectionCreateInfoFUCHSIA,
            next: ptr::null_mut(),
            collection_token: Default::default(),
            _marker: PhantomData,
        }
    }
}

/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct BufferCollectionPropertiesFUCHSIA<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub memory_type_bits: u32,
    pub buffer_count: u32,
    pub create_info_index: u32,
    pub sysmem_pixel_format: u64,
    pub format_features: FormatFeatureFlags,
    pub sysmem_color_space_index: SysmemColorSpaceFUCHSIA<'a>,
    pub sampler_ycbcr_conversion_components: ComponentMapping,
    pub suggested_ycbcr_model: SamplerYcbcrModelConversion,
    pub suggested_ycbcr_range: SamplerYcbcrRange,
    pub suggested_x_chroma_offset: ChromaLocation,
    pub suggested_y_chroma_offset: ChromaLocation,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for BufferCollectionPropertiesFUCHSIA<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::BufferCollectionPropertiesFUCHSIA,
            next: ptr::null_mut(),
            memory_type_bits: 0,
            buffer_count: 0,
            create_info_index: 0,
            sysmem_pixel_format: 0,
            format_features: Default::default(),
            sysmem_color_space_index: Default::default(),
            sampler_ycbcr_conversion_components: Default::default(),
            suggested_ycbcr_model: Default::default(),
            suggested_ycbcr_range: Default::default(),
            suggested_x_chroma_offset: Default::default(),
            suggested_y_chroma_offset: Default::default(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct BufferConstraintsInfoFUCHSIA<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub create_info: BufferCreateInfo<'a>,
    pub required_format_features: FormatFeatureFlags,
    pub buffer_collection_constraints: BufferCollectionConstraintsInfoFUCHSIA<'a>,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for BufferConstraintsInfoFUCHSIA<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::BufferConstraintsInfoFUCHSIA,
            next: ptr::null_mut(),
            create_info: Default::default(),
            required_format_features: Default::default(),
            buffer_collection_constraints: Default::default(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct SysmemColorSpaceFUCHSIA<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub color_space: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for SysmemColorSpaceFUCHSIA<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::SysmemColorSpaceFUCHSIA,
            next: ptr::null_mut(),
            color_space: 0,
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ImageFormatConstraintsInfoFUCHSIA<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub image_create_info: ImageCreateInfo<'a>,
    pub required_format_features: FormatFeatureFlags,
    pub flags: ImageFormatConstraintsFlagsFUCHSIA,
    pub sysmem_pixel_format: u64,
    pub color_space_count: u32,
    /// Len: `color_space_count`
    pub color_spaces: *const SysmemColorSpaceFUCHSIA<'a>,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ImageFormatConstraintsInfoFUCHSIA<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ImageFormatConstraintsInfoFUCHSIA,
            next: ptr::null_mut(),
            image_create_info: Default::default(),
            required_format_features: Default::default(),
            flags: Default::default(),
            sysmem_pixel_format: 0,
            color_space_count: 0,
            color_spaces: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ImageConstraintsInfoFUCHSIA<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub format_constraints_count: u32,
    /// Len: `format_constraints_count`
    pub format_constraints: *const ImageFormatConstraintsInfoFUCHSIA<'a>,
    pub buffer_collection_constraints: BufferCollectionConstraintsInfoFUCHSIA<'a>,
    pub flags: ImageConstraintsInfoFlagsFUCHSIA,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ImageConstraintsInfoFUCHSIA<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ImageConstraintsInfoFUCHSIA,
            next: ptr::null_mut(),
            format_constraints_count: 0,
            format_constraints: ptr::null_mut(),
            buffer_collection_constraints: Default::default(),
            flags: Default::default(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct BufferCollectionConstraintsInfoFUCHSIA<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub min_buffer_count: u32,
    pub max_buffer_count: u32,
    pub min_buffer_count_for_camping: u32,
    pub min_buffer_count_for_dedicated_slack: u32,
    pub min_buffer_count_for_shared_slack: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for BufferCollectionConstraintsInfoFUCHSIA<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::BufferCollectionConstraintsInfoFUCHSIA,
            next: ptr::null_mut(),
            min_buffer_count: 0,
            max_buffer_count: 0,
            min_buffer_count_for_camping: 0,
            min_buffer_count_for_dedicated_slack: 0,
            min_buffer_count_for_shared_slack: 0,
            _marker: PhantomData,
        }
    }
}

#[repr(transparent)]
#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
pub struct CudaModuleNV(pub u64);
impl CudaModuleNV {
    #[inline]
    pub const fn null() -> Self {
        Self(0)
    }
    #[inline]
    pub const fn is_null(self) -> bool {
        self.0 == 0
    }
}
impl fmt::Debug for CudaModuleNV {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "CudaModuleNV(0x{:x})", self.0)
    }
}
impl fmt::Pointer for CudaModuleNV {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        fmt::Debug::fmt(&self, f)
    }
}

#[repr(transparent)]
#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
pub struct CudaFunctionNV(pub u64);
impl CudaFunctionNV {
    #[inline]
    pub const fn null() -> Self {
        Self(0)
    }
    #[inline]
    pub const fn is_null(self) -> bool {
        self.0 == 0
    }
}
impl fmt::Debug for CudaFunctionNV {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "CudaFunctionNV(0x{:x})", self.0)
    }
}
impl fmt::Pointer for CudaFunctionNV {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        fmt::Debug::fmt(&self, f)
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct CudaModuleCreateInfoNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub data_size: usize,
    /// Len: `data_size`
    pub data: *const c_void,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for CudaModuleCreateInfoNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::CudaModuleCreateInfoNV,
            next: ptr::null_mut(),
            data_size: 0,
            data: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct CudaFunctionCreateInfoNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub module: CudaModuleNV,
    /// Len: null-terminated
    pub name: *const c_char,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for CudaFunctionCreateInfoNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::CudaFunctionCreateInfoNV,
            next: ptr::null_mut(),
            module: Default::default(),
            name: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct CudaLaunchInfoNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub function: CudaFunctionNV,
    pub grid_dim_x: u32,
    pub grid_dim_y: u32,
    pub grid_dim_z: u32,
    pub block_dim_x: u32,
    pub block_dim_y: u32,
    pub block_dim_z: u32,
    pub shared_mem_bytes: u32,
    pub param_count: usize,
    /// Len: `param_count`
    pub params: *const *const c_void,
    pub extra_count: usize,
    /// Len: `extra_count`
    pub extras: *const *const c_void,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for CudaLaunchInfoNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::CudaLaunchInfoNV,
            next: ptr::null_mut(),
            function: Default::default(),
            grid_dim_x: 0,
            grid_dim_y: 0,
            grid_dim_z: 0,
            block_dim_x: 0,
            block_dim_y: 0,
            block_dim_z: 0,
            shared_mem_bytes: 0,
            param_count: 0,
            params: ptr::null_mut(),
            extra_count: 0,
            extras: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceRGBA10X6FormatsFeaturesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub format_rgba10x6_without_y_cb_cr_sampler: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceRGBA10X6FormatsFeaturesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceRGBA10X6FormatsFeaturesEXT,
            next: ptr::null_mut(),
            format_rgba10x6_without_y_cb_cr_sampler: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceRGBA10X6FormatsFeaturesEXT<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceRGBA10X6FormatsFeaturesEXT<'_> {}

/// Extends: `FormatProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct FormatProperties3<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub linear_tiling_features: FormatFeatureFlags2,
    pub optimal_tiling_features: FormatFeatureFlags2,
    pub buffer_features: FormatFeatureFlags2,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for FormatProperties3<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::FormatProperties3,
            next: ptr::null_mut(),
            linear_tiling_features: Default::default(),
            optimal_tiling_features: Default::default(),
            buffer_features: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsFormatProperties2 for FormatProperties3<'_> {}

pub type FormatProperties3KHR<'a> = FormatProperties3<'a>;
/// Extends: `FormatProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DrmFormatModifierPropertiesList2EXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub drm_format_modifier_count: u32,
    /// Nullable
    /// Len: `drm_format_modifier_count`
    pub drm_format_modifier_properties: *mut DrmFormatModifierProperties2EXT,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for DrmFormatModifierPropertiesList2EXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::DrmFormatModifierPropertiesList2EXT,
            next: ptr::null_mut(),
            drm_format_modifier_count: 0,
            drm_format_modifier_properties: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsFormatProperties2 for DrmFormatModifierPropertiesList2EXT<'_> {}

/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DrmFormatModifierProperties2EXT {
    pub drm_format_modifier: u64,
    pub drm_format_modifier_plane_count: u32,
    pub drm_format_modifier_tiling_features: FormatFeatureFlags2,
}
impl Default for DrmFormatModifierProperties2EXT {
    fn default() -> Self {
        Self {
            drm_format_modifier: 0,
            drm_format_modifier_plane_count: 0,
            drm_format_modifier_tiling_features: Default::default(),
        }
    }
}

/// Extends: `AndroidHardwareBufferPropertiesANDROID`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct AndroidHardwareBufferFormatProperties2ANDROID<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub format: Format,
    pub external_format: u64,
    pub format_features: FormatFeatureFlags2,
    pub sampler_ycbcr_conversion_components: ComponentMapping,
    pub suggested_ycbcr_model: SamplerYcbcrModelConversion,
    pub suggested_ycbcr_range: SamplerYcbcrRange,
    pub suggested_x_chroma_offset: ChromaLocation,
    pub suggested_y_chroma_offset: ChromaLocation,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for AndroidHardwareBufferFormatProperties2ANDROID<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::AndroidHardwareBufferFormatProperties2ANDROID,
            next: ptr::null_mut(),
            format: Default::default(),
            external_format: 0,
            format_features: Default::default(),
            sampler_ycbcr_conversion_components: Default::default(),
            suggested_ycbcr_model: Default::default(),
            suggested_ycbcr_range: Default::default(),
            suggested_x_chroma_offset: Default::default(),
            suggested_y_chroma_offset: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsAndroidHardwareBufferPropertiesANDROID
    for AndroidHardwareBufferFormatProperties2ANDROID<'_>
{
}

/// Extends: `GraphicsPipelineCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PipelineRenderingCreateInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub view_mask: u32,
    pub color_attachment_count: u32,
    /// Len: `color_attachment_count`
    pub color_attachment_formats: *const Format,
    pub depth_attachment_format: Format,
    pub stencil_attachment_format: Format,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PipelineRenderingCreateInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PipelineRenderingCreateInfo,
            next: ptr::null_mut(),
            view_mask: 0,
            color_attachment_count: 0,
            color_attachment_formats: ptr::null_mut(),
            depth_attachment_format: Default::default(),
            stencil_attachment_format: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsGraphicsPipelineCreateInfo for PipelineRenderingCreateInfo<'_> {}

pub type PipelineRenderingCreateInfoKHR<'a> = PipelineRenderingCreateInfo<'a>;
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct RenderingInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub flags: RenderingFlags,
    pub render_area: Rect2D,
    pub layer_count: u32,
    pub view_mask: u32,
    pub color_attachment_count: u32,
    /// Len: `color_attachment_count`
    pub color_attachments: *const RenderingAttachmentInfo<'a>,
    /// Nullable
    pub depth_attachment: *const RenderingAttachmentInfo<'a>,
    /// Nullable
    pub stencil_attachment: *const RenderingAttachmentInfo<'a>,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for RenderingInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::RenderingInfo,
            next: ptr::null_mut(),
            flags: Default::default(),
            render_area: Default::default(),
            layer_count: 0,
            view_mask: 0,
            color_attachment_count: 0,
            color_attachments: ptr::null_mut(),
            depth_attachment: ptr::null_mut(),
            stencil_attachment: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsRenderingInfo {}
impl<'a> RenderingInfo<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsRenderingInfo>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

pub type RenderingInfoKHR<'a> = RenderingInfo<'a>;
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct RenderingEndInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for RenderingEndInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::RenderingEndInfoKHR,
            next: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsRenderingEndInfoKHR {}
impl<'a> RenderingEndInfoKHR<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsRenderingEndInfoKHR>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

pub type RenderingEndInfoEXT<'a> = RenderingEndInfoKHR<'a>;
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct RenderingAttachmentInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub image_view: ImageView,
    pub image_layout: ImageLayout,
    pub resolve_mode: ResolveModeFlags,
    pub resolve_image_view: ImageView,
    pub resolve_image_layout: ImageLayout,
    pub load_op: AttachmentLoadOp,
    pub store_op: AttachmentStoreOp,
    pub clear_value: ClearValue,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for RenderingAttachmentInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::RenderingAttachmentInfo,
            next: ptr::null_mut(),
            image_view: Default::default(),
            image_layout: Default::default(),
            resolve_mode: Default::default(),
            resolve_image_view: Default::default(),
            resolve_image_layout: Default::default(),
            load_op: Default::default(),
            store_op: Default::default(),
            clear_value: Default::default(),
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsRenderingAttachmentInfo {}
impl<'a> RenderingAttachmentInfo<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsRenderingAttachmentInfo>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

pub type RenderingAttachmentInfoKHR<'a> = RenderingAttachmentInfo<'a>;
/// Extends: `RenderingInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct RenderingFragmentShadingRateAttachmentInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub image_view: ImageView,
    pub image_layout: ImageLayout,
    pub shading_rate_attachment_texel_size: Extent2D,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for RenderingFragmentShadingRateAttachmentInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::RenderingFragmentShadingRateAttachmentInfoKHR,
            next: ptr::null_mut(),
            image_view: Default::default(),
            image_layout: Default::default(),
            shading_rate_attachment_texel_size: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsRenderingInfo for RenderingFragmentShadingRateAttachmentInfoKHR<'_> {}

/// Extends: `RenderingInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct RenderingFragmentDensityMapAttachmentInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub image_view: ImageView,
    pub image_layout: ImageLayout,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for RenderingFragmentDensityMapAttachmentInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::RenderingFragmentDensityMapAttachmentInfoEXT,
            next: ptr::null_mut(),
            image_view: Default::default(),
            image_layout: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsRenderingInfo for RenderingFragmentDensityMapAttachmentInfoEXT<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceDynamicRenderingFeatures<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub dynamic_rendering: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceDynamicRenderingFeatures<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceDynamicRenderingFeatures,
            next: ptr::null_mut(),
            dynamic_rendering: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDynamicRenderingFeatures<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceDynamicRenderingFeatures<'_> {}

pub type PhysicalDeviceDynamicRenderingFeaturesKHR<'a> = PhysicalDeviceDynamicRenderingFeatures<'a>;
/// Extends: `CommandBufferInheritanceInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct CommandBufferInheritanceRenderingInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub flags: RenderingFlags,
    pub view_mask: u32,
    pub color_attachment_count: u32,
    /// Len: `color_attachment_count`
    pub color_attachment_formats: *const Format,
    pub depth_attachment_format: Format,
    pub stencil_attachment_format: Format,
    pub rasterization_samples: SampleCountFlags,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for CommandBufferInheritanceRenderingInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::CommandBufferInheritanceRenderingInfo,
            next: ptr::null_mut(),
            flags: Default::default(),
            view_mask: 0,
            color_attachment_count: 0,
            color_attachment_formats: ptr::null_mut(),
            depth_attachment_format: Default::default(),
            stencil_attachment_format: Default::default(),
            rasterization_samples: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsCommandBufferInheritanceInfo for CommandBufferInheritanceRenderingInfo<'_> {}

pub type CommandBufferInheritanceRenderingInfoKHR<'a> = CommandBufferInheritanceRenderingInfo<'a>;
/// Extends: `CommandBufferInheritanceInfo`, `GraphicsPipelineCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct AttachmentSampleCountInfoAMD<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub color_attachment_count: u32,
    /// Len: `color_attachment_count`
    pub color_attachment_samples: *const SampleCountFlags,
    pub depth_stencil_attachment_samples: SampleCountFlags,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for AttachmentSampleCountInfoAMD<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::AttachmentSampleCountInfoAMD,
            next: ptr::null_mut(),
            color_attachment_count: 0,
            color_attachment_samples: ptr::null_mut(),
            depth_stencil_attachment_samples: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsCommandBufferInheritanceInfo for AttachmentSampleCountInfoAMD<'_> {}
impl ExtendsGraphicsPipelineCreateInfo for AttachmentSampleCountInfoAMD<'_> {}

pub type AttachmentSampleCountInfoNV<'a> = AttachmentSampleCountInfoAMD<'a>;
/// Extends: `CommandBufferInheritanceInfo`, `GraphicsPipelineCreateInfo`, `RenderingInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct MultiviewPerViewAttributesInfoNVX<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub per_view_attributes: Bool32,
    pub per_view_attributes_position_x_only: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for MultiviewPerViewAttributesInfoNVX<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::MultiviewPerViewAttributesInfoNVX,
            next: ptr::null_mut(),
            per_view_attributes: FALSE,
            per_view_attributes_position_x_only: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsCommandBufferInheritanceInfo for MultiviewPerViewAttributesInfoNVX<'_> {}
impl ExtendsGraphicsPipelineCreateInfo for MultiviewPerViewAttributesInfoNVX<'_> {}
impl ExtendsRenderingInfo for MultiviewPerViewAttributesInfoNVX<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceImageViewMinLodFeaturesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub min_lod: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceImageViewMinLodFeaturesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceImageViewMinLodFeaturesEXT,
            next: ptr::null_mut(),
            min_lod: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceImageViewMinLodFeaturesEXT<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceImageViewMinLodFeaturesEXT<'_> {}

/// Extends: `ImageViewCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ImageViewMinLodCreateInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub min_lod: f32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ImageViewMinLodCreateInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ImageViewMinLodCreateInfoEXT,
            next: ptr::null_mut(),
            min_lod: 0.0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsImageViewCreateInfo for ImageViewMinLodCreateInfoEXT<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub rasterization_order_color_attachment_access: Bool32,
    pub rasterization_order_depth_attachment_access: Bool32,
    pub rasterization_order_stencil_attachment_access: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT,
            next: ptr::null_mut(),
            rasterization_order_color_attachment_access: FALSE,
            rasterization_order_depth_attachment_access: FALSE,
            rasterization_order_stencil_attachment_access: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2
    for PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT<'_>
{
}
impl ExtendsDeviceCreateInfo for PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT<'_> {}

pub type PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM<'a> =
    PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT<'a>;
/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceLinearColorAttachmentFeaturesNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub linear_color_attachment: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceLinearColorAttachmentFeaturesNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceLinearColorAttachmentFeaturesNV,
            next: ptr::null_mut(),
            linear_color_attachment: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceLinearColorAttachmentFeaturesNV<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceLinearColorAttachmentFeaturesNV<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub graphics_pipeline_library: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT,
            next: ptr::null_mut(),
            graphics_pipeline_library: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDevicePipelineBinaryFeaturesKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub pipeline_binaries: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDevicePipelineBinaryFeaturesKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDevicePipelineBinaryFeaturesKHR,
            next: ptr::null_mut(),
            pipeline_binaries: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePipelineBinaryFeaturesKHR<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDevicePipelineBinaryFeaturesKHR<'_> {}

/// Extends: `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DevicePipelineBinaryInternalCacheControlKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub disable_internal_cache: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for DevicePipelineBinaryInternalCacheControlKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::DevicePipelineBinaryInternalCacheControlKHR,
            next: ptr::null_mut(),
            disable_internal_cache: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsDeviceCreateInfo for DevicePipelineBinaryInternalCacheControlKHR<'_> {}

/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDevicePipelineBinaryPropertiesKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub pipeline_binary_internal_cache: Bool32,
    pub pipeline_binary_internal_cache_control: Bool32,
    pub pipeline_binary_prefers_internal_cache: Bool32,
    pub pipeline_binary_precompiled_internal_cache: Bool32,
    pub pipeline_binary_compressed_data: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDevicePipelineBinaryPropertiesKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDevicePipelineBinaryPropertiesKHR,
            next: ptr::null_mut(),
            pipeline_binary_internal_cache: FALSE,
            pipeline_binary_internal_cache_control: FALSE,
            pipeline_binary_prefers_internal_cache: FALSE,
            pipeline_binary_precompiled_internal_cache: FALSE,
            pipeline_binary_compressed_data: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2 for PhysicalDevicePipelineBinaryPropertiesKHR<'_> {}

/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub graphics_pipeline_library_fast_linking: Bool32,
    pub graphics_pipeline_library_independent_interpolation_decoration: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT,
            next: ptr::null_mut(),
            graphics_pipeline_library_fast_linking: FALSE,
            graphics_pipeline_library_independent_interpolation_decoration: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT<'_> {}

/// Extends: `GraphicsPipelineCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct GraphicsPipelineLibraryCreateInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub flags: GraphicsPipelineLibraryFlagsEXT,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for GraphicsPipelineLibraryCreateInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::GraphicsPipelineLibraryCreateInfoEXT,
            next: ptr::null_mut(),
            flags: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsGraphicsPipelineCreateInfo for GraphicsPipelineLibraryCreateInfoEXT<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub descriptor_set_host_mapping: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE,
            next: ptr::null_mut(),
            descriptor_set_host_mapping: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE<'_> {}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DescriptorSetBindingReferenceVALVE<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub descriptor_set_layout: DescriptorSetLayout,
    pub binding: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for DescriptorSetBindingReferenceVALVE<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::DescriptorSetBindingReferenceVALVE,
            next: ptr::null_mut(),
            descriptor_set_layout: Default::default(),
            binding: 0,
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DescriptorSetLayoutHostMappingInfoVALVE<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub descriptor_offset: usize,
    pub descriptor_size: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for DescriptorSetLayoutHostMappingInfoVALVE<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::DescriptorSetLayoutHostMappingInfoVALVE,
            next: ptr::null_mut(),
            descriptor_offset: 0,
            descriptor_size: 0,
            _marker: PhantomData,
        }
    }
}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceNestedCommandBufferFeaturesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub nested_command_buffer: Bool32,
    pub nested_command_buffer_rendering: Bool32,
    pub nested_command_buffer_simultaneous_use: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceNestedCommandBufferFeaturesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceNestedCommandBufferFeaturesEXT,
            next: ptr::null_mut(),
            nested_command_buffer: FALSE,
            nested_command_buffer_rendering: FALSE,
            nested_command_buffer_simultaneous_use: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceNestedCommandBufferFeaturesEXT<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceNestedCommandBufferFeaturesEXT<'_> {}

/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceNestedCommandBufferPropertiesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub max_command_buffer_nesting_level: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceNestedCommandBufferPropertiesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceNestedCommandBufferPropertiesEXT,
            next: ptr::null_mut(),
            max_command_buffer_nesting_level: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceNestedCommandBufferPropertiesEXT<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceShaderModuleIdentifierFeaturesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub shader_module_identifier: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceShaderModuleIdentifierFeaturesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceShaderModuleIdentifierFeaturesEXT,
            next: ptr::null_mut(),
            shader_module_identifier: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderModuleIdentifierFeaturesEXT<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderModuleIdentifierFeaturesEXT<'_> {}

/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceShaderModuleIdentifierPropertiesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub shader_module_identifier_algorithm_uuid: [u8; UUID_SIZE as usize],
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceShaderModuleIdentifierPropertiesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceShaderModuleIdentifierPropertiesEXT,
            next: ptr::null_mut(),
            shader_module_identifier_algorithm_uuid: unsafe { mem::zeroed() },
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceShaderModuleIdentifierPropertiesEXT<'_> {}

/// Extends: `PipelineShaderStageCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PipelineShaderStageModuleIdentifierCreateInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub identifier_size: u32,
    /// Len: `identifier_size`
    pub identifier: *const u8,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PipelineShaderStageModuleIdentifierCreateInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PipelineShaderStageModuleIdentifierCreateInfoEXT,
            next: ptr::null_mut(),
            identifier_size: 0,
            identifier: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsPipelineShaderStageCreateInfo for PipelineShaderStageModuleIdentifierCreateInfoEXT<'_> {}

/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ShaderModuleIdentifierEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub identifier_size: u32,
    /// Len: `identifier_size`
    pub identifier: [u8; MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT as usize],
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ShaderModuleIdentifierEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ShaderModuleIdentifierEXT,
            next: ptr::null_mut(),
            identifier_size: 0,
            identifier: unsafe { mem::zeroed() },
            _marker: PhantomData,
        }
    }
}

/// Extends: `ImageCreateInfo`, `SwapchainCreateInfoKHR`, `PhysicalDeviceImageFormatInfo2`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ImageCompressionControlEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub flags: ImageCompressionFlagsEXT,
    pub compression_control_plane_count: u32,
    /// Len: `compression_control_plane_count`
    pub fixed_rate_flags: *mut ImageCompressionFixedRateFlagsEXT,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ImageCompressionControlEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ImageCompressionControlEXT,
            next: ptr::null_mut(),
            flags: Default::default(),
            compression_control_plane_count: 0,
            fixed_rate_flags: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsImageCreateInfo for ImageCompressionControlEXT<'_> {}
impl ExtendsSwapchainCreateInfoKHR for ImageCompressionControlEXT<'_> {}
impl ExtendsPhysicalDeviceImageFormatInfo2 for ImageCompressionControlEXT<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceImageCompressionControlFeaturesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub image_compression_control: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceImageCompressionControlFeaturesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceImageCompressionControlFeaturesEXT,
            next: ptr::null_mut(),
            image_compression_control: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceImageCompressionControlFeaturesEXT<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceImageCompressionControlFeaturesEXT<'_> {}

/// Extends: `ImageFormatProperties2`, `SurfaceFormat2KHR`, `SubresourceLayout2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ImageCompressionPropertiesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub image_compression_flags: ImageCompressionFlagsEXT,
    pub image_compression_fixed_rate_flags: ImageCompressionFixedRateFlagsEXT,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ImageCompressionPropertiesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ImageCompressionPropertiesEXT,
            next: ptr::null_mut(),
            image_compression_flags: Default::default(),
            image_compression_fixed_rate_flags: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsImageFormatProperties2 for ImageCompressionPropertiesEXT<'_> {}
impl ExtendsSurfaceFormat2KHR for ImageCompressionPropertiesEXT<'_> {}
impl ExtendsSubresourceLayout2 for ImageCompressionPropertiesEXT<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub image_compression_control_swapchain: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT,
            next: ptr::null_mut(),
            image_compression_control_swapchain: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2
    for PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT<'_>
{
}
impl ExtendsDeviceCreateInfo for PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT<'_> {}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ImageSubresource2<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub image_subresource: ImageSubresource,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ImageSubresource2<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ImageSubresource2,
            next: ptr::null_mut(),
            image_subresource: Default::default(),
            _marker: PhantomData,
        }
    }
}

pub type ImageSubresource2KHR<'a> = ImageSubresource2<'a>;
pub type ImageSubresource2EXT<'a> = ImageSubresource2<'a>;
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct SubresourceLayout2<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub subresource_layout: SubresourceLayout,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for SubresourceLayout2<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::SubresourceLayout2,
            next: ptr::null_mut(),
            subresource_layout: Default::default(),
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsSubresourceLayout2 {}
impl<'a> SubresourceLayout2<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsSubresourceLayout2>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

pub type SubresourceLayout2KHR<'a> = SubresourceLayout2<'a>;
pub type SubresourceLayout2EXT<'a> = SubresourceLayout2<'a>;
/// Extends: `RenderPassCreateInfo2`, `SubpassDescription2`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct RenderPassCreationControlEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub disallow_merging: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for RenderPassCreationControlEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::RenderPassCreationControlEXT,
            next: ptr::null_mut(),
            disallow_merging: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsRenderPassCreateInfo2 for RenderPassCreationControlEXT<'_> {}
impl ExtendsSubpassDescription2 for RenderPassCreationControlEXT<'_> {}

/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct RenderPassCreationFeedbackInfoEXT {
    pub post_merge_subpass_count: u32,
}
impl Default for RenderPassCreationFeedbackInfoEXT {
    fn default() -> Self {
        Self {
            post_merge_subpass_count: 0,
        }
    }
}

/// Extends: `RenderPassCreateInfo2`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct RenderPassCreationFeedbackCreateInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub render_pass_feedback: *mut RenderPassCreationFeedbackInfoEXT,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for RenderPassCreationFeedbackCreateInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::RenderPassCreationFeedbackCreateInfoEXT,
            next: ptr::null_mut(),
            render_pass_feedback: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsRenderPassCreateInfo2 for RenderPassCreationFeedbackCreateInfoEXT<'_> {}

/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct RenderPassSubpassFeedbackInfoEXT {
    pub subpass_merge_status: SubpassMergeStatusEXT,
    /// Len: null-terminated
    pub description: [c_char; MAX_DESCRIPTION_SIZE as usize],
    pub post_merge_index: u32,
}
impl Default for RenderPassSubpassFeedbackInfoEXT {
    fn default() -> Self {
        Self {
            subpass_merge_status: Default::default(),
            description: unsafe { mem::zeroed() },
            post_merge_index: 0,
        }
    }
}

/// Extends: `SubpassDescription2`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct RenderPassSubpassFeedbackCreateInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub subpass_feedback: *mut RenderPassSubpassFeedbackInfoEXT,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for RenderPassSubpassFeedbackCreateInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::RenderPassSubpassFeedbackCreateInfoEXT,
            next: ptr::null_mut(),
            subpass_feedback: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsSubpassDescription2 for RenderPassSubpassFeedbackCreateInfoEXT<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceSubpassMergeFeedbackFeaturesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub subpass_merge_feedback: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceSubpassMergeFeedbackFeaturesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceSubpassMergeFeedbackFeaturesEXT,
            next: ptr::null_mut(),
            subpass_merge_feedback: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceSubpassMergeFeedbackFeaturesEXT<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceSubpassMergeFeedbackFeaturesEXT<'_> {}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct MicromapBuildInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub ty: MicromapTypeEXT,
    pub flags: BuildMicromapFlagsEXT,
    pub mode: BuildMicromapModeEXT,
    pub dst_micromap: MicromapEXT,
    pub usage_counts_count: u32,
    /// Nullable
    /// Len: `usage_counts_count`
    pub usage_counts: *const MicromapUsageEXT,
    /// Nullable
    /// Len: `usage_counts_count`, `1`
    pub pp_usage_counts: *const *const MicromapUsageEXT,
    pub data: DeviceOrHostAddressConstKHR,
    pub scratch_data: DeviceOrHostAddressKHR,
    pub triangle_array: DeviceOrHostAddressConstKHR,
    pub triangle_array_stride: DeviceSize,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for MicromapBuildInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::MicromapBuildInfoEXT,
            next: ptr::null_mut(),
            ty: Default::default(),
            flags: Default::default(),
            mode: Default::default(),
            dst_micromap: Default::default(),
            usage_counts_count: 0,
            usage_counts: ptr::null_mut(),
            pp_usage_counts: ptr::null_mut(),
            data: Default::default(),
            scratch_data: Default::default(),
            triangle_array: Default::default(),
            triangle_array_stride: Default::default(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct MicromapCreateInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub create_flags: MicromapCreateFlagsEXT,
    pub buffer: Buffer,
    /// Specified in bytes
    pub offset: DeviceSize,
    pub size: DeviceSize,
    pub ty: MicromapTypeEXT,
    pub device_address: DeviceAddress,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for MicromapCreateInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::MicromapCreateInfoEXT,
            next: ptr::null_mut(),
            create_flags: Default::default(),
            buffer: Default::default(),
            offset: Default::default(),
            size: Default::default(),
            ty: Default::default(),
            device_address: Default::default(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct MicromapVersionInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    /// Len: 2 * UUID_SIZE
    pub version_data: *const u8,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for MicromapVersionInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::MicromapVersionInfoEXT,
            next: ptr::null_mut(),
            version_data: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct CopyMicromapInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub src: MicromapEXT,
    pub dst: MicromapEXT,
    pub mode: CopyMicromapModeEXT,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for CopyMicromapInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::CopyMicromapInfoEXT,
            next: ptr::null_mut(),
            src: Default::default(),
            dst: Default::default(),
            mode: Default::default(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct CopyMicromapToMemoryInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub src: MicromapEXT,
    pub dst: DeviceOrHostAddressKHR,
    pub mode: CopyMicromapModeEXT,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for CopyMicromapToMemoryInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::CopyMicromapToMemoryInfoEXT,
            next: ptr::null_mut(),
            src: Default::default(),
            dst: Default::default(),
            mode: Default::default(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct CopyMemoryToMicromapInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub src: DeviceOrHostAddressConstKHR,
    pub dst: MicromapEXT,
    pub mode: CopyMicromapModeEXT,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for CopyMemoryToMicromapInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::CopyMemoryToMicromapInfoEXT,
            next: ptr::null_mut(),
            src: Default::default(),
            dst: Default::default(),
            mode: Default::default(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct MicromapBuildSizesInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub micromap_size: DeviceSize,
    pub build_scratch_size: DeviceSize,
    pub discardable: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for MicromapBuildSizesInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::MicromapBuildSizesInfoEXT,
            next: ptr::null_mut(),
            micromap_size: Default::default(),
            build_scratch_size: Default::default(),
            discardable: FALSE,
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct MicromapUsageEXT {
    pub count: u32,
    pub subdivision_level: u32,
    /// Interpretation depends on parent type
    pub format: u32,
}
impl Default for MicromapUsageEXT {
    fn default() -> Self {
        Self {
            count: 0,
            subdivision_level: 0,
            format: 0,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct MicromapTriangleEXT {
    /// Specified in bytes
    pub data_offset: u32,
    pub subdivision_level: u16,
    pub format: u16,
}
impl Default for MicromapTriangleEXT {
    fn default() -> Self {
        Self {
            data_offset: 0,
            subdivision_level: 0,
            format: 0,
        }
    }
}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceOpacityMicromapFeaturesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub micromap: Bool32,
    pub micromap_capture_replay: Bool32,
    pub micromap_host_commands: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceOpacityMicromapFeaturesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceOpacityMicromapFeaturesEXT,
            next: ptr::null_mut(),
            micromap: FALSE,
            micromap_capture_replay: FALSE,
            micromap_host_commands: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceOpacityMicromapFeaturesEXT<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceOpacityMicromapFeaturesEXT<'_> {}

/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceOpacityMicromapPropertiesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub max_opacity2_state_subdivision_level: u32,
    pub max_opacity4_state_subdivision_level: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceOpacityMicromapPropertiesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceOpacityMicromapPropertiesEXT,
            next: ptr::null_mut(),
            max_opacity2_state_subdivision_level: 0,
            max_opacity4_state_subdivision_level: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceOpacityMicromapPropertiesEXT<'_> {}

/// Extends: `AccelerationStructureGeometryTrianglesDataKHR`, `AccelerationStructureDenseGeometryFormatTrianglesDataAMDX`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct AccelerationStructureTrianglesOpacityMicromapEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub index_type: IndexType,
    pub index_buffer: DeviceOrHostAddressConstKHR,
    pub index_stride: DeviceSize,
    pub base_triangle: u32,
    pub usage_counts_count: u32,
    /// Nullable
    /// Len: `usage_counts_count`
    pub usage_counts: *const MicromapUsageEXT,
    /// Nullable
    /// Len: `usage_counts_count`, `1`
    pub pp_usage_counts: *const *const MicromapUsageEXT,
    pub micromap: MicromapEXT,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for AccelerationStructureTrianglesOpacityMicromapEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::AccelerationStructureTrianglesOpacityMicromapEXT,
            next: ptr::null_mut(),
            index_type: Default::default(),
            index_buffer: Default::default(),
            index_stride: Default::default(),
            base_triangle: 0,
            usage_counts_count: 0,
            usage_counts: ptr::null_mut(),
            pp_usage_counts: ptr::null_mut(),
            micromap: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsAccelerationStructureGeometryTrianglesDataKHR
    for AccelerationStructureTrianglesOpacityMicromapEXT<'_>
{
}
impl ExtendsAccelerationStructureDenseGeometryFormatTrianglesDataAMDX
    for AccelerationStructureTrianglesOpacityMicromapEXT<'_>
{
}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceDisplacementMicromapFeaturesNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub displacement_micromap: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceDisplacementMicromapFeaturesNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceDisplacementMicromapFeaturesNV,
            next: ptr::null_mut(),
            displacement_micromap: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDisplacementMicromapFeaturesNV<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceDisplacementMicromapFeaturesNV<'_> {}

/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceDisplacementMicromapPropertiesNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub max_displacement_micromap_subdivision_level: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceDisplacementMicromapPropertiesNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceDisplacementMicromapPropertiesNV,
            next: ptr::null_mut(),
            max_displacement_micromap_subdivision_level: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDisplacementMicromapPropertiesNV<'_> {}

/// Extends: `AccelerationStructureGeometryTrianglesDataKHR`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct AccelerationStructureTrianglesDisplacementMicromapNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub displacement_bias_and_scale_format: Format,
    pub displacement_vector_format: Format,
    pub displacement_bias_and_scale_buffer: DeviceOrHostAddressConstKHR,
    pub displacement_bias_and_scale_stride: DeviceSize,
    pub displacement_vector_buffer: DeviceOrHostAddressConstKHR,
    pub displacement_vector_stride: DeviceSize,
    pub displaced_micromap_primitive_flags: DeviceOrHostAddressConstKHR,
    pub displaced_micromap_primitive_flags_stride: DeviceSize,
    pub index_type: IndexType,
    pub index_buffer: DeviceOrHostAddressConstKHR,
    pub index_stride: DeviceSize,
    pub base_triangle: u32,
    pub usage_counts_count: u32,
    /// Nullable
    /// Len: `usage_counts_count`
    pub usage_counts: *const MicromapUsageEXT,
    /// Nullable
    /// Len: `usage_counts_count`, `1`
    pub pp_usage_counts: *const *const MicromapUsageEXT,
    pub micromap: MicromapEXT,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for AccelerationStructureTrianglesDisplacementMicromapNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::AccelerationStructureTrianglesDisplacementMicromapNV,
            next: ptr::null_mut(),
            displacement_bias_and_scale_format: Default::default(),
            displacement_vector_format: Default::default(),
            displacement_bias_and_scale_buffer: Default::default(),
            displacement_bias_and_scale_stride: Default::default(),
            displacement_vector_buffer: Default::default(),
            displacement_vector_stride: Default::default(),
            displaced_micromap_primitive_flags: Default::default(),
            displaced_micromap_primitive_flags_stride: Default::default(),
            index_type: Default::default(),
            index_buffer: Default::default(),
            index_stride: Default::default(),
            base_triangle: 0,
            usage_counts_count: 0,
            usage_counts: ptr::null_mut(),
            pp_usage_counts: ptr::null_mut(),
            micromap: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsAccelerationStructureGeometryTrianglesDataKHR
    for AccelerationStructureTrianglesDisplacementMicromapNV<'_>
{
}

/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PipelinePropertiesIdentifierEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub pipeline_identifier: [u8; UUID_SIZE as usize],
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PipelinePropertiesIdentifierEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PipelinePropertiesIdentifierEXT,
            next: ptr::null_mut(),
            pipeline_identifier: unsafe { mem::zeroed() },
            _marker: PhantomData,
        }
    }
}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDevicePipelinePropertiesFeaturesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub pipeline_properties_identifier: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDevicePipelinePropertiesFeaturesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDevicePipelinePropertiesFeaturesEXT,
            next: ptr::null_mut(),
            pipeline_properties_identifier: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePipelinePropertiesFeaturesEXT<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDevicePipelinePropertiesFeaturesEXT<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub shader_early_and_late_fragment_tests: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD,
            next: ptr::null_mut(),
            shader_early_and_late_fragment_tests: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2
    for PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD<'_>
{
}
impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD<'_> {}

/// Extends: `BufferMemoryBarrier`, `BufferMemoryBarrier2`, `ImageMemoryBarrier`, `ImageMemoryBarrier2`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ExternalMemoryAcquireUnmodifiedEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub acquire_unmodified_memory: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ExternalMemoryAcquireUnmodifiedEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ExternalMemoryAcquireUnmodifiedEXT,
            next: ptr::null_mut(),
            acquire_unmodified_memory: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsBufferMemoryBarrier for ExternalMemoryAcquireUnmodifiedEXT<'_> {}
impl ExtendsBufferMemoryBarrier2 for ExternalMemoryAcquireUnmodifiedEXT<'_> {}
impl ExtendsImageMemoryBarrier for ExternalMemoryAcquireUnmodifiedEXT<'_> {}
impl ExtendsImageMemoryBarrier2 for ExternalMemoryAcquireUnmodifiedEXT<'_> {}

/// Extends: `InstanceCreateInfo`, `MemoryAllocateInfo`, `ImageCreateInfo`, `ImageViewCreateInfo`, `BufferViewCreateInfo`, `SemaphoreCreateInfo`, `EventCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ExportMetalObjectCreateInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub export_object_type: ExportMetalObjectTypeFlagsEXT,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ExportMetalObjectCreateInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ExportMetalObjectCreateInfoEXT,
            next: ptr::null_mut(),
            export_object_type: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsInstanceCreateInfo for ExportMetalObjectCreateInfoEXT<'_> {}
impl ExtendsMemoryAllocateInfo for ExportMetalObjectCreateInfoEXT<'_> {}
impl ExtendsImageCreateInfo for ExportMetalObjectCreateInfoEXT<'_> {}
impl ExtendsImageViewCreateInfo for ExportMetalObjectCreateInfoEXT<'_> {}
impl ExtendsBufferViewCreateInfo for ExportMetalObjectCreateInfoEXT<'_> {}
impl ExtendsSemaphoreCreateInfo for ExportMetalObjectCreateInfoEXT<'_> {}
impl ExtendsEventCreateInfo for ExportMetalObjectCreateInfoEXT<'_> {}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ExportMetalObjectsInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ExportMetalObjectsInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ExportMetalObjectsInfoEXT,
            next: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsExportMetalObjectsInfoEXT {}
impl<'a> ExportMetalObjectsInfoEXT<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsExportMetalObjectsInfoEXT>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

/// Extends: `ExportMetalObjectsInfoEXT`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ExportMetalDeviceInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub mtl_device: MTLDevice_id,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ExportMetalDeviceInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ExportMetalDeviceInfoEXT,
            next: ptr::null_mut(),
            mtl_device: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsExportMetalObjectsInfoEXT for ExportMetalDeviceInfoEXT<'_> {}

/// Extends: `ExportMetalObjectsInfoEXT`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ExportMetalCommandQueueInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub queue: vkQueue,
    pub mtl_command_queue: MTLCommandQueue_id,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ExportMetalCommandQueueInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ExportMetalCommandQueueInfoEXT,
            next: ptr::null_mut(),
            queue: Default::default(),
            mtl_command_queue: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsExportMetalObjectsInfoEXT for ExportMetalCommandQueueInfoEXT<'_> {}

/// Extends: `ExportMetalObjectsInfoEXT`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ExportMetalBufferInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub memory: DeviceMemory,
    pub mtl_buffer: MTLBuffer_id,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ExportMetalBufferInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ExportMetalBufferInfoEXT,
            next: ptr::null_mut(),
            memory: Default::default(),
            mtl_buffer: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsExportMetalObjectsInfoEXT for ExportMetalBufferInfoEXT<'_> {}

/// Extends: `MemoryAllocateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ImportMetalBufferInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub mtl_buffer: MTLBuffer_id,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ImportMetalBufferInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ImportMetalBufferInfoEXT,
            next: ptr::null_mut(),
            mtl_buffer: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsMemoryAllocateInfo for ImportMetalBufferInfoEXT<'_> {}

/// Extends: `ExportMetalObjectsInfoEXT`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ExportMetalTextureInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub image: Image,
    pub image_view: ImageView,
    pub buffer_view: BufferView,
    pub plane: ImageAspectFlags,
    pub mtl_texture: MTLTexture_id,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ExportMetalTextureInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ExportMetalTextureInfoEXT,
            next: ptr::null_mut(),
            image: Default::default(),
            image_view: Default::default(),
            buffer_view: Default::default(),
            plane: Default::default(),
            mtl_texture: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsExportMetalObjectsInfoEXT for ExportMetalTextureInfoEXT<'_> {}

/// Extends: `ImageCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ImportMetalTextureInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub plane: ImageAspectFlags,
    pub mtl_texture: MTLTexture_id,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ImportMetalTextureInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ImportMetalTextureInfoEXT,
            next: ptr::null_mut(),
            plane: Default::default(),
            mtl_texture: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsImageCreateInfo for ImportMetalTextureInfoEXT<'_> {}

/// Extends: `ExportMetalObjectsInfoEXT`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ExportMetalIOSurfaceInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub image: Image,
    pub io_surface: IOSurfaceRef,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ExportMetalIOSurfaceInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ExportMetalIOSurfaceInfoEXT,
            next: ptr::null_mut(),
            image: Default::default(),
            io_surface: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsExportMetalObjectsInfoEXT for ExportMetalIOSurfaceInfoEXT<'_> {}

/// Extends: `ImageCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ImportMetalIOSurfaceInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub io_surface: IOSurfaceRef,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ImportMetalIOSurfaceInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ImportMetalIOSurfaceInfoEXT,
            next: ptr::null_mut(),
            io_surface: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsImageCreateInfo for ImportMetalIOSurfaceInfoEXT<'_> {}

/// Extends: `ExportMetalObjectsInfoEXT`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ExportMetalSharedEventInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub semaphore: Semaphore,
    pub event: Event,
    pub mtl_shared_event: MTLSharedEvent_id,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ExportMetalSharedEventInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ExportMetalSharedEventInfoEXT,
            next: ptr::null_mut(),
            semaphore: Default::default(),
            event: Default::default(),
            mtl_shared_event: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsExportMetalObjectsInfoEXT for ExportMetalSharedEventInfoEXT<'_> {}

/// Extends: `SemaphoreCreateInfo`, `EventCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ImportMetalSharedEventInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub mtl_shared_event: MTLSharedEvent_id,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ImportMetalSharedEventInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ImportMetalSharedEventInfoEXT,
            next: ptr::null_mut(),
            mtl_shared_event: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsSemaphoreCreateInfo for ImportMetalSharedEventInfoEXT<'_> {}
impl ExtendsEventCreateInfo for ImportMetalSharedEventInfoEXT<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceNonSeamlessCubeMapFeaturesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub non_seamless_cube_map: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceNonSeamlessCubeMapFeaturesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceNonSeamlessCubeMapFeaturesEXT,
            next: ptr::null_mut(),
            non_seamless_cube_map: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceNonSeamlessCubeMapFeaturesEXT<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceNonSeamlessCubeMapFeaturesEXT<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDevicePipelineRobustnessFeatures<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub pipeline_robustness: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDevicePipelineRobustnessFeatures<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDevicePipelineRobustnessFeatures,
            next: ptr::null_mut(),
            pipeline_robustness: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePipelineRobustnessFeatures<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDevicePipelineRobustnessFeatures<'_> {}

pub type PhysicalDevicePipelineRobustnessFeaturesEXT<'a> =
    PhysicalDevicePipelineRobustnessFeatures<'a>;
/// Extends: `GraphicsPipelineCreateInfo`, `ComputePipelineCreateInfo`, `PipelineShaderStageCreateInfo`, `RayTracingPipelineCreateInfoKHR`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PipelineRobustnessCreateInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub storage_buffers: PipelineRobustnessBufferBehavior,
    pub uniform_buffers: PipelineRobustnessBufferBehavior,
    pub vertex_inputs: PipelineRobustnessBufferBehavior,
    pub images: PipelineRobustnessImageBehavior,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PipelineRobustnessCreateInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PipelineRobustnessCreateInfo,
            next: ptr::null_mut(),
            storage_buffers: Default::default(),
            uniform_buffers: Default::default(),
            vertex_inputs: Default::default(),
            images: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsGraphicsPipelineCreateInfo for PipelineRobustnessCreateInfo<'_> {}
impl ExtendsComputePipelineCreateInfo for PipelineRobustnessCreateInfo<'_> {}
impl ExtendsPipelineShaderStageCreateInfo for PipelineRobustnessCreateInfo<'_> {}
impl ExtendsRayTracingPipelineCreateInfoKHR for PipelineRobustnessCreateInfo<'_> {}

pub type PipelineRobustnessCreateInfoEXT<'a> = PipelineRobustnessCreateInfo<'a>;
/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDevicePipelineRobustnessProperties<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub default_robustness_storage_buffers: PipelineRobustnessBufferBehavior,
    pub default_robustness_uniform_buffers: PipelineRobustnessBufferBehavior,
    pub default_robustness_vertex_inputs: PipelineRobustnessBufferBehavior,
    pub default_robustness_images: PipelineRobustnessImageBehavior,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDevicePipelineRobustnessProperties<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDevicePipelineRobustnessProperties,
            next: ptr::null_mut(),
            default_robustness_storage_buffers: Default::default(),
            default_robustness_uniform_buffers: Default::default(),
            default_robustness_vertex_inputs: Default::default(),
            default_robustness_images: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2 for PhysicalDevicePipelineRobustnessProperties<'_> {}

pub type PhysicalDevicePipelineRobustnessPropertiesEXT<'a> =
    PhysicalDevicePipelineRobustnessProperties<'a>;
/// Extends: `ImageViewCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ImageViewSampleWeightCreateInfoQCOM<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub filter_center: Offset2D,
    pub filter_size: Extent2D,
    pub num_phases: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ImageViewSampleWeightCreateInfoQCOM<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ImageViewSampleWeightCreateInfoQCOM,
            next: ptr::null_mut(),
            filter_center: Default::default(),
            filter_size: Default::default(),
            num_phases: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsImageViewCreateInfo for ImageViewSampleWeightCreateInfoQCOM<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceImageProcessingFeaturesQCOM<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub texture_sample_weighted: Bool32,
    pub texture_box_filter: Bool32,
    pub texture_block_match: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceImageProcessingFeaturesQCOM<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceImageProcessingFeaturesQCOM,
            next: ptr::null_mut(),
            texture_sample_weighted: FALSE,
            texture_box_filter: FALSE,
            texture_block_match: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceImageProcessingFeaturesQCOM<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceImageProcessingFeaturesQCOM<'_> {}

/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceImageProcessingPropertiesQCOM<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub max_weight_filter_phases: u32,
    pub max_weight_filter_dimension: Extent2D,
    pub max_block_match_region: Extent2D,
    pub max_box_filter_block_size: Extent2D,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceImageProcessingPropertiesQCOM<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceImageProcessingPropertiesQCOM,
            next: ptr::null_mut(),
            max_weight_filter_phases: 0,
            max_weight_filter_dimension: Default::default(),
            max_block_match_region: Default::default(),
            max_box_filter_block_size: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceImageProcessingPropertiesQCOM<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceTilePropertiesFeaturesQCOM<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub tile_properties: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceTilePropertiesFeaturesQCOM<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceTilePropertiesFeaturesQCOM,
            next: ptr::null_mut(),
            tile_properties: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceTilePropertiesFeaturesQCOM<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceTilePropertiesFeaturesQCOM<'_> {}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct TilePropertiesQCOM<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub tile_size: Extent3D,
    pub apron_size: Extent2D,
    pub origin: Offset2D,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for TilePropertiesQCOM<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::TilePropertiesQCOM,
            next: ptr::null_mut(),
            tile_size: Default::default(),
            apron_size: Default::default(),
            origin: Default::default(),
            _marker: PhantomData,
        }
    }
}

/// Extends: `CommandBufferInheritanceInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct TileMemoryBindInfoQCOM<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub memory: DeviceMemory,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for TileMemoryBindInfoQCOM<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::TileMemoryBindInfoQCOM,
            next: ptr::null_mut(),
            memory: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsCommandBufferInheritanceInfo for TileMemoryBindInfoQCOM<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceAmigoProfilingFeaturesSEC<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub amigo_profiling: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceAmigoProfilingFeaturesSEC<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceAmigoProfilingFeaturesSEC,
            next: ptr::null_mut(),
            amigo_profiling: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceAmigoProfilingFeaturesSEC<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceAmigoProfilingFeaturesSEC<'_> {}

/// Extends: `SubmitInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct AmigoProfilingSubmitInfoSEC<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub first_draw_timestamp: u64,
    pub swap_buffer_timestamp: u64,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for AmigoProfilingSubmitInfoSEC<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::AmigoProfilingSubmitInfoSEC,
            next: ptr::null_mut(),
            first_draw_timestamp: 0,
            swap_buffer_timestamp: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsSubmitInfo for AmigoProfilingSubmitInfoSEC<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub attachment_feedback_loop_layout: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT,
            next: ptr::null_mut(),
            attachment_feedback_loop_layout: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT<'_> {}

pub type PhysicalDeviceDepthClampZeroOneFeaturesEXT<'a> =
    PhysicalDeviceDepthClampZeroOneFeaturesKHR<'a>;
/// Extends: `RenderingAttachmentInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct AttachmentFeedbackLoopInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub feedback_loop_enable: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for AttachmentFeedbackLoopInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::AttachmentFeedbackLoopInfoEXT,
            next: ptr::null_mut(),
            feedback_loop_enable: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsRenderingAttachmentInfo for AttachmentFeedbackLoopInfoEXT<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceAddressBindingReportFeaturesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub report_address_binding: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceAddressBindingReportFeaturesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceAddressBindingReportFeaturesEXT,
            next: ptr::null_mut(),
            report_address_binding: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceAddressBindingReportFeaturesEXT<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceAddressBindingReportFeaturesEXT<'_> {}

/// Extends: `RenderingAttachmentInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct RenderingAttachmentFlagsInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub flags: RenderingAttachmentFlagsKHR,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for RenderingAttachmentFlagsInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::RenderingAttachmentFlagsInfoKHR,
            next: ptr::null_mut(),
            flags: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsRenderingAttachmentInfo for RenderingAttachmentFlagsInfoKHR<'_> {}

/// Extends: `ResolveImageInfo2`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ResolveImageModeInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub flags: ResolveImageFlagsKHR,
    pub resolve_mode: ResolveModeFlags,
    pub stencil_resolve_mode: ResolveModeFlags,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ResolveImageModeInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ResolveImageModeInfoKHR,
            next: ptr::null_mut(),
            flags: Default::default(),
            resolve_mode: Default::default(),
            stencil_resolve_mode: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsResolveImageInfo2 for ResolveImageModeInfoKHR<'_> {}

/// Extends: `DebugUtilsMessengerCallbackDataEXT`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DeviceAddressBindingCallbackDataEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub flags: DeviceAddressBindingFlagsEXT,
    pub base_address: DeviceAddress,
    pub size: DeviceSize,
    pub binding_type: DeviceAddressBindingTypeEXT,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for DeviceAddressBindingCallbackDataEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::DeviceAddressBindingCallbackDataEXT,
            next: ptr::null_mut(),
            flags: Default::default(),
            base_address: Default::default(),
            size: Default::default(),
            binding_type: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsDebugUtilsMessengerCallbackDataEXT for DeviceAddressBindingCallbackDataEXT<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceOpticalFlowFeaturesNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub optical_flow: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceOpticalFlowFeaturesNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceOpticalFlowFeaturesNV,
            next: ptr::null_mut(),
            optical_flow: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceOpticalFlowFeaturesNV<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceOpticalFlowFeaturesNV<'_> {}

/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceOpticalFlowPropertiesNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub supported_output_grid_sizes: OpticalFlowGridSizeFlagsNV,
    pub supported_hint_grid_sizes: OpticalFlowGridSizeFlagsNV,
    pub hint_supported: Bool32,
    pub cost_supported: Bool32,
    pub bidirectional_flow_supported: Bool32,
    pub global_flow_supported: Bool32,
    pub min_width: u32,
    pub min_height: u32,
    pub max_width: u32,
    pub max_height: u32,
    pub max_num_regions_of_interest: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceOpticalFlowPropertiesNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceOpticalFlowPropertiesNV,
            next: ptr::null_mut(),
            supported_output_grid_sizes: Default::default(),
            supported_hint_grid_sizes: Default::default(),
            hint_supported: FALSE,
            cost_supported: FALSE,
            bidirectional_flow_supported: FALSE,
            global_flow_supported: FALSE,
            min_width: 0,
            min_height: 0,
            max_width: 0,
            max_height: 0,
            max_num_regions_of_interest: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceOpticalFlowPropertiesNV<'_> {}

/// Extends: `PhysicalDeviceImageFormatInfo2`, `ImageCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct OpticalFlowImageFormatInfoNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub usage: OpticalFlowUsageFlagsNV,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for OpticalFlowImageFormatInfoNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::OpticalFlowImageFormatInfoNV,
            next: ptr::null_mut(),
            usage: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceImageFormatInfo2 for OpticalFlowImageFormatInfoNV<'_> {}
impl ExtendsImageCreateInfo for OpticalFlowImageFormatInfoNV<'_> {}

/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct OpticalFlowImageFormatPropertiesNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub format: Format,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for OpticalFlowImageFormatPropertiesNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::OpticalFlowImageFormatPropertiesNV,
            next: ptr::null_mut(),
            format: Default::default(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct OpticalFlowSessionCreateInfoNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub width: u32,
    pub height: u32,
    pub image_format: Format,
    pub flow_vector_format: Format,
    pub cost_format: Format,
    pub output_grid_size: OpticalFlowGridSizeFlagsNV,
    pub hint_grid_size: OpticalFlowGridSizeFlagsNV,
    pub performance_level: OpticalFlowPerformanceLevelNV,
    pub flags: OpticalFlowSessionCreateFlagsNV,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for OpticalFlowSessionCreateInfoNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::OpticalFlowSessionCreateInfoNV,
            next: ptr::null_mut(),
            width: 0,
            height: 0,
            image_format: Default::default(),
            flow_vector_format: Default::default(),
            cost_format: Default::default(),
            output_grid_size: Default::default(),
            hint_grid_size: Default::default(),
            performance_level: Default::default(),
            flags: Default::default(),
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsOpticalFlowSessionCreateInfoNV {}
impl<'a> OpticalFlowSessionCreateInfoNV<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsOpticalFlowSessionCreateInfoNV>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

/// Extends: `OpticalFlowSessionCreateInfoNV`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct OpticalFlowSessionCreatePrivateDataInfoNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub id: u32,
    pub size: u32,
    pub private_data: *const c_void,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for OpticalFlowSessionCreatePrivateDataInfoNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::OpticalFlowSessionCreatePrivateDataInfoNV,
            next: ptr::null_mut(),
            id: 0,
            size: 0,
            private_data: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsOpticalFlowSessionCreateInfoNV for OpticalFlowSessionCreatePrivateDataInfoNV<'_> {}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct OpticalFlowExecuteInfoNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub flags: OpticalFlowExecuteFlagsNV,
    pub region_count: u32,
    /// Len: `region_count`
    pub regions: *const Rect2D,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for OpticalFlowExecuteInfoNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::OpticalFlowExecuteInfoNV,
            next: ptr::null_mut(),
            flags: Default::default(),
            region_count: 0,
            regions: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceFaultFeaturesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub device_fault: Bool32,
    pub device_fault_vendor_binary: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceFaultFeaturesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceFaultFeaturesEXT,
            next: ptr::null_mut(),
            device_fault: FALSE,
            device_fault_vendor_binary: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceFaultFeaturesEXT<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceFaultFeaturesEXT<'_> {}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DeviceFaultAddressInfoEXT {
    pub address_type: DeviceFaultAddressTypeEXT,
    pub reported_address: DeviceAddress,
    pub address_precision: DeviceSize,
}
impl Default for DeviceFaultAddressInfoEXT {
    fn default() -> Self {
        Self {
            address_type: Default::default(),
            reported_address: Default::default(),
            address_precision: Default::default(),
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DeviceFaultVendorInfoEXT {
    /// Free-form description of the fault
    /// Len: null-terminated
    pub description: [c_char; MAX_DESCRIPTION_SIZE as usize],
    pub vendor_fault_code: u64,
    pub vendor_fault_data: u64,
}
impl Default for DeviceFaultVendorInfoEXT {
    fn default() -> Self {
        Self {
            description: unsafe { mem::zeroed() },
            vendor_fault_code: 0,
            vendor_fault_data: 0,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DeviceFaultCountsEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub address_info_count: u32,
    pub vendor_info_count: u32,
    /// Specified in bytes
    pub vendor_binary_size: DeviceSize,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for DeviceFaultCountsEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::DeviceFaultCountsEXT,
            next: ptr::null_mut(),
            address_info_count: 0,
            vendor_info_count: 0,
            vendor_binary_size: Default::default(),
            _marker: PhantomData,
        }
    }
}

/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DeviceFaultInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    /// Free-form description of the fault
    /// Len: null-terminated
    pub description: [c_char; MAX_DESCRIPTION_SIZE as usize],
    /// Nullable
    pub address_infos: *mut DeviceFaultAddressInfoEXT,
    /// Nullable
    pub vendor_infos: *mut DeviceFaultVendorInfoEXT,
    /// Nullable
    pub vendor_binary_data: *mut c_void,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for DeviceFaultInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::DeviceFaultInfoEXT,
            next: ptr::null_mut(),
            description: unsafe { mem::zeroed() },
            address_infos: ptr::null_mut(),
            vendor_infos: ptr::null_mut(),
            vendor_binary_data: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DeviceFaultVendorBinaryHeaderVersionOneEXT {
    pub header_size: u32,
    pub header_version: DeviceFaultVendorBinaryHeaderVersionEXT,
    pub vendor_id: u32,
    pub device_id: u32,
    pub driver_version: u32,
    pub pipeline_cache_uuid: [u8; UUID_SIZE as usize],
    pub application_name_offset: u32,
    pub application_version: u32,
    pub engine_name_offset: u32,
    pub engine_version: u32,
    pub api_version: u32,
}
impl Default for DeviceFaultVendorBinaryHeaderVersionOneEXT {
    fn default() -> Self {
        Self {
            header_size: 0,
            header_version: Default::default(),
            vendor_id: 0,
            device_id: 0,
            driver_version: 0,
            pipeline_cache_uuid: unsafe { mem::zeroed() },
            application_name_offset: 0,
            application_version: 0,
            engine_name_offset: 0,
            engine_version: 0,
            api_version: 0,
        }
    }
}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub pipeline_library_group_handles: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT,
            next: ptr::null_mut(),
            pipeline_library_group_handles: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT<'_> {}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DepthBiasInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub depth_bias_constant_factor: f32,
    pub depth_bias_clamp: f32,
    pub depth_bias_slope_factor: f32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for DepthBiasInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::DepthBiasInfoEXT,
            next: ptr::null_mut(),
            depth_bias_constant_factor: 0.0,
            depth_bias_clamp: 0.0,
            depth_bias_slope_factor: 0.0,
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsDepthBiasInfoEXT {}
impl<'a> DepthBiasInfoEXT<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsDepthBiasInfoEXT>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

/// Extends: `DepthBiasInfoEXT`, `PipelineRasterizationStateCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DepthBiasRepresentationInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub depth_bias_representation: DepthBiasRepresentationEXT,
    pub depth_bias_exact: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for DepthBiasRepresentationInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::DepthBiasRepresentationInfoEXT,
            next: ptr::null_mut(),
            depth_bias_representation: Default::default(),
            depth_bias_exact: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsDepthBiasInfoEXT for DepthBiasRepresentationInfoEXT<'_> {}
impl ExtendsPipelineRasterizationStateCreateInfo for DepthBiasRepresentationInfoEXT<'_> {}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DecompressMemoryRegionNV {
    pub src_address: DeviceAddress,
    pub dst_address: DeviceAddress,
    /// Specified in bytes
    pub compressed_size: DeviceSize,
    /// Specified in bytes
    pub decompressed_size: DeviceSize,
    pub decompression_method: MemoryDecompressionMethodFlagsNV,
}
impl Default for DecompressMemoryRegionNV {
    fn default() -> Self {
        Self {
            src_address: Default::default(),
            dst_address: Default::default(),
            compressed_size: Default::default(),
            decompressed_size: Default::default(),
            decompression_method: Default::default(),
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DecompressMemoryRegionEXT {
    pub src_address: DeviceAddress,
    pub dst_address: DeviceAddress,
    /// Specified in bytes
    pub compressed_size: DeviceSize,
    /// Specified in bytes
    pub decompressed_size: DeviceSize,
}
impl Default for DecompressMemoryRegionEXT {
    fn default() -> Self {
        Self {
            src_address: Default::default(),
            dst_address: Default::default(),
            compressed_size: Default::default(),
            decompressed_size: Default::default(),
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DecompressMemoryInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub decompression_method: MemoryDecompressionMethodFlagsEXT,
    pub region_count: u32,
    /// Len: `region_count`
    pub regions: *const DecompressMemoryRegionEXT,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for DecompressMemoryInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::DecompressMemoryInfoEXT,
            next: ptr::null_mut(),
            decompression_method: Default::default(),
            region_count: 0,
            regions: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceShaderCoreBuiltinsPropertiesARM<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub shader_core_mask: u64,
    pub shader_core_count: u32,
    pub shader_warps_per_core: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceShaderCoreBuiltinsPropertiesARM<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceShaderCoreBuiltinsPropertiesARM,
            next: ptr::null_mut(),
            shader_core_mask: 0,
            shader_core_count: 0,
            shader_warps_per_core: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceShaderCoreBuiltinsPropertiesARM<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceShaderCoreBuiltinsFeaturesARM<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub shader_core_builtins: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceShaderCoreBuiltinsFeaturesARM<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceShaderCoreBuiltinsFeaturesARM,
            next: ptr::null_mut(),
            shader_core_builtins: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderCoreBuiltinsFeaturesARM<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderCoreBuiltinsFeaturesARM<'_> {}

/// Extends: `SubmitInfo`, `SubmitInfo2`, `PresentInfoKHR`, `BindSparseInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct FrameBoundaryEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub flags: FrameBoundaryFlagsEXT,
    pub frame_id: u64,
    pub image_count: u32,
    /// Nullable
    /// Len: `image_count`
    pub images: *const Image,
    pub buffer_count: u32,
    /// Nullable
    /// Len: `buffer_count`
    pub buffers: *const Buffer,
    pub tag_name: u64,
    pub tag_size: usize,
    /// Nullable
    /// Len: `tag_size`
    pub tag: *const c_void,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for FrameBoundaryEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::FrameBoundaryEXT,
            next: ptr::null_mut(),
            flags: Default::default(),
            frame_id: 0,
            image_count: 0,
            images: ptr::null_mut(),
            buffer_count: 0,
            buffers: ptr::null_mut(),
            tag_name: 0,
            tag_size: 0,
            tag: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsSubmitInfo for FrameBoundaryEXT<'_> {}
impl ExtendsSubmitInfo2 for FrameBoundaryEXT<'_> {}
impl ExtendsPresentInfoKHR for FrameBoundaryEXT<'_> {}
impl ExtendsBindSparseInfo for FrameBoundaryEXT<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceFrameBoundaryFeaturesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub frame_boundary: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceFrameBoundaryFeaturesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceFrameBoundaryFeaturesEXT,
            next: ptr::null_mut(),
            frame_boundary: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceFrameBoundaryFeaturesEXT<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceFrameBoundaryFeaturesEXT<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub dynamic_rendering_unused_attachments: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT,
            next: ptr::null_mut(),
            dynamic_rendering_unused_attachments: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2
    for PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT<'_>
{
}
impl ExtendsDeviceCreateInfo for PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceInternallySynchronizedQueuesFeaturesKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub internally_synchronized_queues: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceInternallySynchronizedQueuesFeaturesKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceInternallySynchronizedQueuesFeaturesKHR,
            next: ptr::null_mut(),
            internally_synchronized_queues: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceInternallySynchronizedQueuesFeaturesKHR<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceInternallySynchronizedQueuesFeaturesKHR<'_> {}

/// Extends: `PhysicalDeviceSurfaceInfo2KHR`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct SurfacePresentModeKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub present_mode: PresentModeKHR,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for SurfacePresentModeKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::SurfacePresentModeKHR,
            next: ptr::null_mut(),
            present_mode: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceSurfaceInfo2KHR for SurfacePresentModeKHR<'_> {}

pub type SurfacePresentModeEXT<'a> = SurfacePresentModeKHR<'a>;
/// Extends: `SurfaceCapabilities2KHR`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct SurfacePresentScalingCapabilitiesKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub supported_present_scaling: PresentScalingFlagsKHR,
    pub supported_present_gravity_x: PresentGravityFlagsKHR,
    pub supported_present_gravity_y: PresentGravityFlagsKHR,
    /// Supported minimum image width and height for the surface when scaling is used
    pub min_scaled_image_extent: Extent2D,
    /// Supported maximum image width and height for the surface when scaling is used
    pub max_scaled_image_extent: Extent2D,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for SurfacePresentScalingCapabilitiesKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::SurfacePresentScalingCapabilitiesKHR,
            next: ptr::null_mut(),
            supported_present_scaling: Default::default(),
            supported_present_gravity_x: Default::default(),
            supported_present_gravity_y: Default::default(),
            min_scaled_image_extent: Default::default(),
            max_scaled_image_extent: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsSurfaceCapabilities2KHR for SurfacePresentScalingCapabilitiesKHR<'_> {}

pub type SurfacePresentScalingCapabilitiesEXT<'a> = SurfacePresentScalingCapabilitiesKHR<'a>;
/// Extends: `SurfaceCapabilities2KHR`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct SurfacePresentModeCompatibilityKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub present_mode_count: u32,
    /// Output list of present modes compatible with the one specified in VkSurfacePresentModeKHR
    /// Nullable
    /// Len: `present_mode_count`
    pub present_modes: *mut PresentModeKHR,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for SurfacePresentModeCompatibilityKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::SurfacePresentModeCompatibilityKHR,
            next: ptr::null_mut(),
            present_mode_count: 0,
            present_modes: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsSurfaceCapabilities2KHR for SurfacePresentModeCompatibilityKHR<'_> {}

pub type SurfacePresentModeCompatibilityEXT<'a> = SurfacePresentModeCompatibilityKHR<'a>;
/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceSwapchainMaintenance1FeaturesKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub swapchain_maintenance1: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceSwapchainMaintenance1FeaturesKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceSwapchainMaintenance1FeaturesKHR,
            next: ptr::null_mut(),
            swapchain_maintenance1: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceSwapchainMaintenance1FeaturesKHR<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceSwapchainMaintenance1FeaturesKHR<'_> {}

pub type PhysicalDeviceSwapchainMaintenance1FeaturesEXT<'a> =
    PhysicalDeviceSwapchainMaintenance1FeaturesKHR<'a>;
/// Extends: `PresentInfoKHR`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct SwapchainPresentFenceInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    /// Copy of VkPresentInfoKHR::swapchainCount
    pub swapchain_count: u32,
    /// Fence to signal for each swapchain
    /// Nullable
    /// Len: `swapchain_count`
    pub fences: *const Fence,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for SwapchainPresentFenceInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::SwapchainPresentFenceInfoKHR,
            next: ptr::null_mut(),
            swapchain_count: 0,
            fences: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsPresentInfoKHR for SwapchainPresentFenceInfoKHR<'_> {}

pub type SwapchainPresentFenceInfoEXT<'a> = SwapchainPresentFenceInfoKHR<'a>;
/// Extends: `SwapchainCreateInfoKHR`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct SwapchainPresentModesCreateInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub present_mode_count: u32,
    /// Len: `present_mode_count`
    pub present_modes: *const PresentModeKHR,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for SwapchainPresentModesCreateInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::SwapchainPresentModesCreateInfoKHR,
            next: ptr::null_mut(),
            present_mode_count: 0,
            present_modes: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsSwapchainCreateInfoKHR for SwapchainPresentModesCreateInfoKHR<'_> {}

pub type SwapchainPresentModesCreateInfoEXT<'a> = SwapchainPresentModesCreateInfoKHR<'a>;
/// Extends: `PresentInfoKHR`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct SwapchainPresentModeInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    /// Copy of VkPresentInfoKHR::swapchainCount
    pub swapchain_count: u32,
    /// Presentation mode for each swapchain
    /// Len: `swapchain_count`
    pub present_modes: *const PresentModeKHR,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for SwapchainPresentModeInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::SwapchainPresentModeInfoKHR,
            next: ptr::null_mut(),
            swapchain_count: 0,
            present_modes: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsPresentInfoKHR for SwapchainPresentModeInfoKHR<'_> {}

pub type SwapchainPresentModeInfoEXT<'a> = SwapchainPresentModeInfoKHR<'a>;
/// Extends: `SwapchainCreateInfoKHR`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct SwapchainPresentScalingCreateInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub scaling_behavior: PresentScalingFlagsKHR,
    pub present_gravity_x: PresentGravityFlagsKHR,
    pub present_gravity_y: PresentGravityFlagsKHR,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for SwapchainPresentScalingCreateInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::SwapchainPresentScalingCreateInfoKHR,
            next: ptr::null_mut(),
            scaling_behavior: Default::default(),
            present_gravity_x: Default::default(),
            present_gravity_y: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsSwapchainCreateInfoKHR for SwapchainPresentScalingCreateInfoKHR<'_> {}

pub type SwapchainPresentScalingCreateInfoEXT<'a> = SwapchainPresentScalingCreateInfoKHR<'a>;
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ReleaseSwapchainImagesInfoKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    /// Swapchain for which images are being released
    pub swapchain: SwapchainKHR,
    /// Number of indices to release
    pub image_index_count: u32,
    /// Indices of which presentable images to release
    /// Len: `image_index_count`
    pub image_indices: *const u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ReleaseSwapchainImagesInfoKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ReleaseSwapchainImagesInfoKHR,
            next: ptr::null_mut(),
            swapchain: Default::default(),
            image_index_count: 0,
            image_indices: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

pub type ReleaseSwapchainImagesInfoEXT<'a> = ReleaseSwapchainImagesInfoKHR<'a>;
/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceDepthBiasControlFeaturesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub depth_bias_control: Bool32,
    pub least_representable_value_force_unorm_representation: Bool32,
    pub float_representation: Bool32,
    pub depth_bias_exact: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceDepthBiasControlFeaturesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceDepthBiasControlFeaturesEXT,
            next: ptr::null_mut(),
            depth_bias_control: FALSE,
            least_representable_value_force_unorm_representation: FALSE,
            float_representation: FALSE,
            depth_bias_exact: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDepthBiasControlFeaturesEXT<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceDepthBiasControlFeaturesEXT<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceRayTracingInvocationReorderFeaturesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub ray_tracing_invocation_reorder: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceRayTracingInvocationReorderFeaturesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceRayTracingInvocationReorderFeaturesEXT,
            next: ptr::null_mut(),
            ray_tracing_invocation_reorder: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceRayTracingInvocationReorderFeaturesEXT<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceRayTracingInvocationReorderFeaturesEXT<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceRayTracingInvocationReorderFeaturesNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub ray_tracing_invocation_reorder: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceRayTracingInvocationReorderFeaturesNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceRayTracingInvocationReorderFeaturesNV,
            next: ptr::null_mut(),
            ray_tracing_invocation_reorder: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceRayTracingInvocationReorderFeaturesNV<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceRayTracingInvocationReorderFeaturesNV<'_> {}

/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceRayTracingInvocationReorderPropertiesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub ray_tracing_invocation_reorder_reordering_hint: RayTracingInvocationReorderModeEXT,
    pub max_shader_binding_table_record_index: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceRayTracingInvocationReorderPropertiesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceRayTracingInvocationReorderPropertiesEXT,
            next: ptr::null_mut(),
            ray_tracing_invocation_reorder_reordering_hint: Default::default(),
            max_shader_binding_table_record_index: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2
    for PhysicalDeviceRayTracingInvocationReorderPropertiesEXT<'_>
{
}

/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceRayTracingInvocationReorderPropertiesNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub ray_tracing_invocation_reorder_reordering_hint: RayTracingInvocationReorderModeEXT,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceRayTracingInvocationReorderPropertiesNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceRayTracingInvocationReorderPropertiesNV,
            next: ptr::null_mut(),
            ray_tracing_invocation_reorder_reordering_hint: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2
    for PhysicalDeviceRayTracingInvocationReorderPropertiesNV<'_>
{
}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub extended_sparse_address_space: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV,
            next: ptr::null_mut(),
            extended_sparse_address_space: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV<'_> {}

/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceExtendedSparseAddressSpacePropertiesNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    /// Total address space available for extended sparse allocations (bytes)
    pub extended_sparse_address_space_size: DeviceSize,
    /// Bitfield of which image usages are supported for extended sparse allocations
    pub extended_sparse_image_usage_flags: ImageUsageFlags,
    /// Bitfield of which buffer usages are supported for extended sparse allocations
    pub extended_sparse_buffer_usage_flags: BufferUsageFlags,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceExtendedSparseAddressSpacePropertiesNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceExtendedSparseAddressSpacePropertiesNV,
            next: ptr::null_mut(),
            extended_sparse_address_space_size: Default::default(),
            extended_sparse_image_usage_flags: Default::default(),
            extended_sparse_buffer_usage_flags: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceExtendedSparseAddressSpacePropertiesNV<'_> {}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DirectDriverLoadingInfoLUNARG<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub flags: DirectDriverLoadingFlagsLUNARG,
    pub pfn_get_instance_proc_addr: PFN_vkGetInstanceProcAddrLUNARG,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for DirectDriverLoadingInfoLUNARG<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::DirectDriverLoadingInfoLUNARG,
            next: ptr::null_mut(),
            flags: Default::default(),
            pfn_get_instance_proc_addr: Default::default(),
            _marker: PhantomData,
        }
    }
}

/// Extends: `InstanceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DirectDriverLoadingListLUNARG<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub mode: DirectDriverLoadingModeLUNARG,
    pub driver_count: u32,
    /// Len: `driver_count`
    pub drivers: *const DirectDriverLoadingInfoLUNARG<'a>,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for DirectDriverLoadingListLUNARG<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::DirectDriverLoadingListLUNARG,
            next: ptr::null_mut(),
            mode: Default::default(),
            driver_count: 0,
            drivers: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsInstanceCreateInfo for DirectDriverLoadingListLUNARG<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub multiview_per_view_viewports: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM,
            next: ptr::null_mut(),
            multiview_per_view_viewports: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceRayTracingPositionFetchFeaturesKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub ray_tracing_position_fetch: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceRayTracingPositionFetchFeaturesKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceRayTracingPositionFetchFeaturesKHR,
            next: ptr::null_mut(),
            ray_tracing_position_fetch: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceRayTracingPositionFetchFeaturesKHR<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceRayTracingPositionFetchFeaturesKHR<'_> {}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DeviceImageSubresourceInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub create_info: *const ImageCreateInfo<'a>,
    pub subresource: *const ImageSubresource2<'a>,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for DeviceImageSubresourceInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::DeviceImageSubresourceInfo,
            next: ptr::null_mut(),
            create_info: ptr::null_mut(),
            subresource: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

pub type DeviceImageSubresourceInfoKHR<'a> = DeviceImageSubresourceInfo<'a>;
/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceShaderCorePropertiesARM<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub pixel_rate: u32,
    pub texel_rate: u32,
    pub fma_rate: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceShaderCorePropertiesARM<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceShaderCorePropertiesARM,
            next: ptr::null_mut(),
            pixel_rate: 0,
            texel_rate: 0,
            fma_rate: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceShaderCorePropertiesARM<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub multiview_per_view_render_areas: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM,
            next: ptr::null_mut(),
            multiview_per_view_render_areas: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM<'_> {}

/// Extends: `RenderPassBeginInfo`, `RenderingInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub per_view_render_area_count: u32,
    /// Len: `per_view_render_area_count`
    pub per_view_render_areas: *const Rect2D,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM,
            next: ptr::null_mut(),
            per_view_render_area_count: 0,
            per_view_render_areas: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsRenderPassBeginInfo for MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM<'_> {}
impl ExtendsRenderingInfo for MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM<'_> {}

/// Extends: `SemaphoreCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct QueryLowLatencySupportNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub queried_low_latency_data: *mut c_void,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for QueryLowLatencySupportNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::QueryLowLatencySupportNV,
            next: ptr::null_mut(),
            queried_low_latency_data: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsSemaphoreCreateInfo for QueryLowLatencySupportNV<'_> {}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct MemoryMapInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub flags: MemoryMapFlags,
    pub memory: DeviceMemory,
    pub offset: DeviceSize,
    pub size: DeviceSize,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for MemoryMapInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::MemoryMapInfo,
            next: ptr::null_mut(),
            flags: Default::default(),
            memory: Default::default(),
            offset: Default::default(),
            size: Default::default(),
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsMemoryMapInfo {}
impl<'a> MemoryMapInfo<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsMemoryMapInfo>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

pub type MemoryMapInfoKHR<'a> = MemoryMapInfo<'a>;
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct MemoryUnmapInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub flags: MemoryUnmapFlags,
    pub memory: DeviceMemory,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for MemoryUnmapInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::MemoryUnmapInfo,
            next: ptr::null_mut(),
            flags: Default::default(),
            memory: Default::default(),
            _marker: PhantomData,
        }
    }
}

pub type MemoryUnmapInfoKHR<'a> = MemoryUnmapInfo<'a>;
/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceShaderObjectFeaturesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub shader_object: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceShaderObjectFeaturesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceShaderObjectFeaturesEXT,
            next: ptr::null_mut(),
            shader_object: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderObjectFeaturesEXT<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderObjectFeaturesEXT<'_> {}

/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceShaderObjectPropertiesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub shader_binary_uuid: [u8; UUID_SIZE as usize],
    pub shader_binary_version: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceShaderObjectPropertiesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceShaderObjectPropertiesEXT,
            next: ptr::null_mut(),
            shader_binary_uuid: unsafe { mem::zeroed() },
            shader_binary_version: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceShaderObjectPropertiesEXT<'_> {}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ShaderCreateInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub flags: ShaderCreateFlagsEXT,
    pub stage: ShaderStageFlags,
    pub next_stage: ShaderStageFlags,
    pub code_type: ShaderCodeTypeEXT,
    pub code_size: usize,
    /// Len: `code_size`
    pub code: *const c_void,
    /// Nullable
    /// Len: null-terminated
    pub name: *const c_char,
    pub set_layout_count: u32,
    /// Nullable
    /// Len: `set_layout_count`
    pub set_layouts: *const DescriptorSetLayout,
    pub push_constant_range_count: u32,
    /// Nullable
    /// Len: `push_constant_range_count`
    pub push_constant_ranges: *const PushConstantRange,
    /// Nullable
    pub specialization_info: *const SpecializationInfo<'a>,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ShaderCreateInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ShaderCreateInfoEXT,
            next: ptr::null_mut(),
            flags: Default::default(),
            stage: Default::default(),
            next_stage: Default::default(),
            code_type: Default::default(),
            code_size: 0,
            code: ptr::null_mut(),
            name: ptr::null_mut(),
            set_layout_count: 0,
            set_layouts: ptr::null_mut(),
            push_constant_range_count: 0,
            push_constant_ranges: ptr::null_mut(),
            specialization_info: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsShaderCreateInfoEXT {}
impl<'a> ShaderCreateInfoEXT<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsShaderCreateInfoEXT>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceShaderTileImageFeaturesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub shader_tile_image_color_read_access: Bool32,
    pub shader_tile_image_depth_read_access: Bool32,
    pub shader_tile_image_stencil_read_access: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceShaderTileImageFeaturesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceShaderTileImageFeaturesEXT,
            next: ptr::null_mut(),
            shader_tile_image_color_read_access: FALSE,
            shader_tile_image_depth_read_access: FALSE,
            shader_tile_image_stencil_read_access: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderTileImageFeaturesEXT<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderTileImageFeaturesEXT<'_> {}

/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceShaderTileImagePropertiesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub shader_tile_image_coherent_read_accelerated: Bool32,
    pub shader_tile_image_read_sample_from_pixel_rate_invocation: Bool32,
    pub shader_tile_image_read_from_helper_invocation: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceShaderTileImagePropertiesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceShaderTileImagePropertiesEXT,
            next: ptr::null_mut(),
            shader_tile_image_coherent_read_accelerated: FALSE,
            shader_tile_image_read_sample_from_pixel_rate_invocation: FALSE,
            shader_tile_image_read_from_helper_invocation: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceShaderTileImagePropertiesEXT<'_> {}

/// Extends: `MemoryAllocateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ImportScreenBufferInfoQNX<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub buffer: *mut _screen_buffer,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ImportScreenBufferInfoQNX<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ImportScreenBufferInfoQNX,
            next: ptr::null_mut(),
            buffer: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsMemoryAllocateInfo for ImportScreenBufferInfoQNX<'_> {}

/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ScreenBufferPropertiesQNX<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub allocation_size: DeviceSize,
    pub memory_type_bits: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ScreenBufferPropertiesQNX<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ScreenBufferPropertiesQNX,
            next: ptr::null_mut(),
            allocation_size: Default::default(),
            memory_type_bits: 0,
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsScreenBufferPropertiesQNX {}
impl<'a> ScreenBufferPropertiesQNX<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsScreenBufferPropertiesQNX>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

/// Extends: `ScreenBufferPropertiesQNX`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ScreenBufferFormatPropertiesQNX<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub format: Format,
    pub external_format: u64,
    pub screen_usage: u64,
    pub format_features: FormatFeatureFlags,
    pub sampler_ycbcr_conversion_components: ComponentMapping,
    pub suggested_ycbcr_model: SamplerYcbcrModelConversion,
    pub suggested_ycbcr_range: SamplerYcbcrRange,
    pub suggested_x_chroma_offset: ChromaLocation,
    pub suggested_y_chroma_offset: ChromaLocation,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ScreenBufferFormatPropertiesQNX<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ScreenBufferFormatPropertiesQNX,
            next: ptr::null_mut(),
            format: Default::default(),
            external_format: 0,
            screen_usage: 0,
            format_features: Default::default(),
            sampler_ycbcr_conversion_components: Default::default(),
            suggested_ycbcr_model: Default::default(),
            suggested_ycbcr_range: Default::default(),
            suggested_x_chroma_offset: Default::default(),
            suggested_y_chroma_offset: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsScreenBufferPropertiesQNX for ScreenBufferFormatPropertiesQNX<'_> {}

/// Extends: `ImageCreateInfo`, `SamplerYcbcrConversionCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ExternalFormatQNX<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub external_format: u64,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ExternalFormatQNX<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ExternalFormatQNX,
            next: ptr::null_mut(),
            external_format: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsImageCreateInfo for ExternalFormatQNX<'_> {}
impl ExtendsSamplerYcbcrConversionCreateInfo for ExternalFormatQNX<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub screen_buffer_import: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX,
            next: ptr::null_mut(),
            screen_buffer_import: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceCooperativeMatrixFeaturesKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub cooperative_matrix: Bool32,
    pub cooperative_matrix_robust_buffer_access: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceCooperativeMatrixFeaturesKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceCooperativeMatrixFeaturesKHR,
            next: ptr::null_mut(),
            cooperative_matrix: FALSE,
            cooperative_matrix_robust_buffer_access: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceCooperativeMatrixFeaturesKHR<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceCooperativeMatrixFeaturesKHR<'_> {}

/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct CooperativeMatrixPropertiesKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub m_size: u32,
    pub n_size: u32,
    pub k_size: u32,
    pub a_type: ComponentTypeKHR,
    pub b_type: ComponentTypeKHR,
    pub c_type: ComponentTypeKHR,
    pub result_type: ComponentTypeKHR,
    pub saturating_accumulation: Bool32,
    pub scope: ScopeKHR,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for CooperativeMatrixPropertiesKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::CooperativeMatrixPropertiesKHR,
            next: ptr::null_mut(),
            m_size: 0,
            n_size: 0,
            k_size: 0,
            a_type: Default::default(),
            b_type: Default::default(),
            c_type: Default::default(),
            result_type: Default::default(),
            saturating_accumulation: FALSE,
            scope: Default::default(),
            _marker: PhantomData,
        }
    }
}

/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceCooperativeMatrixPropertiesKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub cooperative_matrix_supported_stages: ShaderStageFlags,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceCooperativeMatrixPropertiesKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceCooperativeMatrixPropertiesKHR,
            next: ptr::null_mut(),
            cooperative_matrix_supported_stages: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceCooperativeMatrixPropertiesKHR<'_> {}

/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceShaderEnqueuePropertiesAMDX<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub max_execution_graph_depth: u32,
    pub max_execution_graph_shader_output_nodes: u32,
    pub max_execution_graph_shader_payload_size: u32,
    pub max_execution_graph_shader_payload_count: u32,
    pub execution_graph_dispatch_address_alignment: u32,
    pub max_execution_graph_workgroup_count: [u32; 3],
    pub max_execution_graph_workgroups: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceShaderEnqueuePropertiesAMDX<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceShaderEnqueuePropertiesAMDX,
            next: ptr::null_mut(),
            max_execution_graph_depth: 0,
            max_execution_graph_shader_output_nodes: 0,
            max_execution_graph_shader_payload_size: 0,
            max_execution_graph_shader_payload_count: 0,
            execution_graph_dispatch_address_alignment: 0,
            max_execution_graph_workgroup_count: unsafe { mem::zeroed() },
            max_execution_graph_workgroups: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceShaderEnqueuePropertiesAMDX<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceShaderEnqueueFeaturesAMDX<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub shader_enqueue: Bool32,
    pub shader_mesh_enqueue: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceShaderEnqueueFeaturesAMDX<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceShaderEnqueueFeaturesAMDX,
            next: ptr::null_mut(),
            shader_enqueue: FALSE,
            shader_mesh_enqueue: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderEnqueueFeaturesAMDX<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderEnqueueFeaturesAMDX<'_> {}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ExecutionGraphPipelineCreateInfoAMDX<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub flags: PipelineCreateFlags,
    pub stage_count: u32,
    /// Nullable
    /// Len: `stage_count`
    pub stages: *const PipelineShaderStageCreateInfo<'a>,
    /// Nullable
    pub library_info: *const PipelineLibraryCreateInfoKHR<'a>,
    /// Interface layout of the pipeline
    pub layout: PipelineLayout,
    pub base_pipeline_handle: Pipeline,
    pub base_pipeline_index: i32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ExecutionGraphPipelineCreateInfoAMDX<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ExecutionGraphPipelineCreateInfoAMDX,
            next: ptr::null_mut(),
            flags: Default::default(),
            stage_count: 0,
            stages: ptr::null_mut(),
            library_info: ptr::null_mut(),
            layout: Default::default(),
            base_pipeline_handle: Default::default(),
            base_pipeline_index: 0,
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsExecutionGraphPipelineCreateInfoAMDX {}
impl<'a> ExecutionGraphPipelineCreateInfoAMDX<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsExecutionGraphPipelineCreateInfoAMDX>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

/// Extends: `PipelineShaderStageCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PipelineShaderStageNodeCreateInfoAMDX<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    /// Nullable
    /// Len: null-terminated
    pub name: *const c_char,
    pub index: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PipelineShaderStageNodeCreateInfoAMDX<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PipelineShaderStageNodeCreateInfoAMDX,
            next: ptr::null_mut(),
            name: ptr::null_mut(),
            index: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPipelineShaderStageCreateInfo for PipelineShaderStageNodeCreateInfoAMDX<'_> {}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ExecutionGraphPipelineScratchSizeAMDX<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub min_size: DeviceSize,
    pub max_size: DeviceSize,
    pub size_granularity: DeviceSize,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ExecutionGraphPipelineScratchSizeAMDX<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ExecutionGraphPipelineScratchSizeAMDX,
            next: ptr::null_mut(),
            min_size: Default::default(),
            max_size: Default::default(),
            size_granularity: Default::default(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DispatchGraphInfoAMDX {
    pub node_index: u32,
    pub payload_count: u32,
    pub payloads: DeviceOrHostAddressConstAMDX,
    pub payload_stride: u64,
}
impl Default for DispatchGraphInfoAMDX {
    fn default() -> Self {
        Self {
            node_index: 0,
            payload_count: 0,
            payloads: Default::default(),
            payload_stride: 0,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DispatchGraphCountInfoAMDX {
    pub count: u32,
    pub infos: DeviceOrHostAddressConstAMDX,
    pub stride: u64,
}
impl Default for DispatchGraphCountInfoAMDX {
    fn default() -> Self {
        Self {
            count: 0,
            infos: Default::default(),
            stride: 0,
        }
    }
}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceAntiLagFeaturesAMD<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub anti_lag: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceAntiLagFeaturesAMD<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceAntiLagFeaturesAMD,
            next: ptr::null_mut(),
            anti_lag: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceAntiLagFeaturesAMD<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceAntiLagFeaturesAMD<'_> {}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct AntiLagDataAMD<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub mode: AntiLagModeAMD,
    pub max_fps: u32,
    /// Nullable
    pub presentation_info: *const AntiLagPresentationInfoAMD<'a>,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for AntiLagDataAMD<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::AntiLagDataAMD,
            next: ptr::null_mut(),
            mode: Default::default(),
            max_fps: 0,
            presentation_info: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct AntiLagPresentationInfoAMD<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub stage: AntiLagStageAMD,
    pub frame_index: u64,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for AntiLagPresentationInfoAMD<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::AntiLagPresentationInfoAMD,
            next: ptr::null_mut(),
            stage: Default::default(),
            frame_index: 0,
            _marker: PhantomData,
        }
    }
}

/// Extends: `BindBufferMemoryInfo`, `BindImageMemoryInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct BindMemoryStatus<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub result: *mut vkResult,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for BindMemoryStatus<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::BindMemoryStatus,
            next: ptr::null_mut(),
            result: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsBindBufferMemoryInfo for BindMemoryStatus<'_> {}
impl ExtendsBindImageMemoryInfo for BindMemoryStatus<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceTileMemoryHeapFeaturesQCOM<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub tile_memory_heap: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceTileMemoryHeapFeaturesQCOM<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceTileMemoryHeapFeaturesQCOM,
            next: ptr::null_mut(),
            tile_memory_heap: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceTileMemoryHeapFeaturesQCOM<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceTileMemoryHeapFeaturesQCOM<'_> {}

/// Extends: `PhysicalDeviceProperties2`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceTileMemoryHeapPropertiesQCOM<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub queue_submit_boundary: Bool32,
    pub tile_buffer_transfers: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceTileMemoryHeapPropertiesQCOM<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceTileMemoryHeapPropertiesQCOM,
            next: ptr::null_mut(),
            queue_submit_boundary: FALSE,
            tile_buffer_transfers: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceTileMemoryHeapPropertiesQCOM<'_> {}

/// Extends: `RenderPassCreateInfo`, `RenderPassCreateInfo2`, `RenderingInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct TileMemorySizeInfoQCOM<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub size: DeviceSize,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for TileMemorySizeInfoQCOM<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::TileMemorySizeInfoQCOM,
            next: ptr::null_mut(),
            size: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsRenderPassCreateInfo for TileMemorySizeInfoQCOM<'_> {}
impl ExtendsRenderPassCreateInfo2 for TileMemorySizeInfoQCOM<'_> {}
impl ExtendsRenderingInfo for TileMemorySizeInfoQCOM<'_> {}

/// Extends: `MemoryRequirements2`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct TileMemoryRequirementsQCOM<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub size: DeviceSize,
    pub alignment: DeviceSize,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for TileMemoryRequirementsQCOM<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::TileMemoryRequirementsQCOM,
            next: ptr::null_mut(),
            size: Default::default(),
            alignment: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsMemoryRequirements2 for TileMemoryRequirementsQCOM<'_> {}

pub type BindMemoryStatusKHR<'a> = BindMemoryStatus<'a>;
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct BindDescriptorSetsInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub stage_flags: ShaderStageFlags,
    pub layout: PipelineLayout,
    pub first_set: u32,
    pub descriptor_set_count: u32,
    /// Len: `descriptor_set_count`
    pub descriptor_sets: *const DescriptorSet,
    pub dynamic_offset_count: u32,
    /// Nullable
    /// Len: `dynamic_offset_count`
    pub dynamic_offsets: *const u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for BindDescriptorSetsInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::BindDescriptorSetsInfo,
            next: ptr::null_mut(),
            stage_flags: Default::default(),
            layout: Default::default(),
            first_set: 0,
            descriptor_set_count: 0,
            descriptor_sets: ptr::null_mut(),
            dynamic_offset_count: 0,
            dynamic_offsets: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsBindDescriptorSetsInfo {}
impl<'a> BindDescriptorSetsInfo<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsBindDescriptorSetsInfo>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

pub type BindDescriptorSetsInfoKHR<'a> = BindDescriptorSetsInfo<'a>;
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PushConstantsInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub layout: PipelineLayout,
    pub stage_flags: ShaderStageFlags,
    pub offset: u32,
    pub size: u32,
    /// Len: `size`
    pub values: *const c_void,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PushConstantsInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PushConstantsInfo,
            next: ptr::null_mut(),
            layout: Default::default(),
            stage_flags: Default::default(),
            offset: 0,
            size: 0,
            values: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsPushConstantsInfo {}
impl<'a> PushConstantsInfo<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsPushConstantsInfo>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

pub type PushConstantsInfoKHR<'a> = PushConstantsInfo<'a>;
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PushDescriptorSetInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub stage_flags: ShaderStageFlags,
    pub layout: PipelineLayout,
    pub set: u32,
    pub descriptor_write_count: u32,
    /// Len: `descriptor_write_count`
    pub descriptor_writes: *const WriteDescriptorSet<'a>,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PushDescriptorSetInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PushDescriptorSetInfo,
            next: ptr::null_mut(),
            stage_flags: Default::default(),
            layout: Default::default(),
            set: 0,
            descriptor_write_count: 0,
            descriptor_writes: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsPushDescriptorSetInfo {}
impl<'a> PushDescriptorSetInfo<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsPushDescriptorSetInfo>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

pub type PushDescriptorSetInfoKHR<'a> = PushDescriptorSetInfo<'a>;
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PushDescriptorSetWithTemplateInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub descriptor_update_template: DescriptorUpdateTemplate,
    pub layout: PipelineLayout,
    pub set: u32,
    pub data: *const c_void,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PushDescriptorSetWithTemplateInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PushDescriptorSetWithTemplateInfo,
            next: ptr::null_mut(),
            descriptor_update_template: Default::default(),
            layout: Default::default(),
            set: 0,
            data: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsPushDescriptorSetWithTemplateInfo {}
impl<'a> PushDescriptorSetWithTemplateInfo<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsPushDescriptorSetWithTemplateInfo>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

pub type PushDescriptorSetWithTemplateInfoKHR<'a> = PushDescriptorSetWithTemplateInfo<'a>;
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct SetDescriptorBufferOffsetsInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub stage_flags: ShaderStageFlags,
    pub layout: PipelineLayout,
    pub first_set: u32,
    pub set_count: u32,
    /// Len: `set_count`
    pub buffer_indices: *const u32,
    /// Len: `set_count`
    pub offsets: *const DeviceSize,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for SetDescriptorBufferOffsetsInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::SetDescriptorBufferOffsetsInfoEXT,
            next: ptr::null_mut(),
            stage_flags: Default::default(),
            layout: Default::default(),
            first_set: 0,
            set_count: 0,
            buffer_indices: ptr::null_mut(),
            offsets: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsSetDescriptorBufferOffsetsInfoEXT {}
impl<'a> SetDescriptorBufferOffsetsInfoEXT<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsSetDescriptorBufferOffsetsInfoEXT>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct BindDescriptorBufferEmbeddedSamplersInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub stage_flags: ShaderStageFlags,
    pub layout: PipelineLayout,
    pub set: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for BindDescriptorBufferEmbeddedSamplersInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::BindDescriptorBufferEmbeddedSamplersInfoEXT,
            next: ptr::null_mut(),
            stage_flags: Default::default(),
            layout: Default::default(),
            set: 0,
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsBindDescriptorBufferEmbeddedSamplersInfoEXT {}
impl<'a> BindDescriptorBufferEmbeddedSamplersInfoEXT<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsBindDescriptorBufferEmbeddedSamplersInfoEXT>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceCubicClampFeaturesQCOM<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub cubic_range_clamp: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceCubicClampFeaturesQCOM<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceCubicClampFeaturesQCOM,
            next: ptr::null_mut(),
            cubic_range_clamp: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceCubicClampFeaturesQCOM<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceCubicClampFeaturesQCOM<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceYcbcrDegammaFeaturesQCOM<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub ycbcr_degamma: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceYcbcrDegammaFeaturesQCOM<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceYcbcrDegammaFeaturesQCOM,
            next: ptr::null_mut(),
            ycbcr_degamma: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceYcbcrDegammaFeaturesQCOM<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceYcbcrDegammaFeaturesQCOM<'_> {}

/// Extends: `SamplerYcbcrConversionCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub enable_y_degamma: Bool32,
    pub enable_cb_cr_degamma: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM,
            next: ptr::null_mut(),
            enable_y_degamma: FALSE,
            enable_cb_cr_degamma: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsSamplerYcbcrConversionCreateInfo
    for SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM<'_>
{
}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceCubicWeightsFeaturesQCOM<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub selectable_cubic_weights: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceCubicWeightsFeaturesQCOM<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceCubicWeightsFeaturesQCOM,
            next: ptr::null_mut(),
            selectable_cubic_weights: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceCubicWeightsFeaturesQCOM<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceCubicWeightsFeaturesQCOM<'_> {}

/// Extends: `SamplerCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct SamplerCubicWeightsCreateInfoQCOM<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub cubic_weights: CubicFilterWeightsQCOM,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for SamplerCubicWeightsCreateInfoQCOM<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::SamplerCubicWeightsCreateInfoQCOM,
            next: ptr::null_mut(),
            cubic_weights: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsSamplerCreateInfo for SamplerCubicWeightsCreateInfoQCOM<'_> {}

/// Extends: `BlitImageInfo2`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct BlitImageCubicWeightsInfoQCOM<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub cubic_weights: CubicFilterWeightsQCOM,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for BlitImageCubicWeightsInfoQCOM<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::BlitImageCubicWeightsInfoQCOM,
            next: ptr::null_mut(),
            cubic_weights: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsBlitImageInfo2 for BlitImageCubicWeightsInfoQCOM<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceImageProcessing2FeaturesQCOM<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub texture_block_match2: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceImageProcessing2FeaturesQCOM<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceImageProcessing2FeaturesQCOM,
            next: ptr::null_mut(),
            texture_block_match2: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceImageProcessing2FeaturesQCOM<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceImageProcessing2FeaturesQCOM<'_> {}

/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceImageProcessing2PropertiesQCOM<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub max_block_match_window: Extent2D,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceImageProcessing2PropertiesQCOM<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceImageProcessing2PropertiesQCOM,
            next: ptr::null_mut(),
            max_block_match_window: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceImageProcessing2PropertiesQCOM<'_> {}

/// Extends: `SamplerCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct SamplerBlockMatchWindowCreateInfoQCOM<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub window_extent: Extent2D,
    pub window_compare_mode: BlockMatchWindowCompareModeQCOM,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for SamplerBlockMatchWindowCreateInfoQCOM<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::SamplerBlockMatchWindowCreateInfoQCOM,
            next: ptr::null_mut(),
            window_extent: Default::default(),
            window_compare_mode: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsSamplerCreateInfo for SamplerBlockMatchWindowCreateInfoQCOM<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceDescriptorPoolOverallocationFeaturesNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub descriptor_pool_overallocation: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceDescriptorPoolOverallocationFeaturesNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceDescriptorPoolOverallocationFeaturesNV,
            next: ptr::null_mut(),
            descriptor_pool_overallocation: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDescriptorPoolOverallocationFeaturesNV<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceDescriptorPoolOverallocationFeaturesNV<'_> {}

/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceLayeredDriverPropertiesMSFT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub underlying_api: LayeredDriverUnderlyingApiMSFT,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceLayeredDriverPropertiesMSFT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceLayeredDriverPropertiesMSFT,
            next: ptr::null_mut(),
            underlying_api: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceLayeredDriverPropertiesMSFT<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDevicePerStageDescriptorSetFeaturesNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub per_stage_descriptor_set: Bool32,
    pub dynamic_pipeline_layout: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDevicePerStageDescriptorSetFeaturesNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDevicePerStageDescriptorSetFeaturesNV,
            next: ptr::null_mut(),
            per_stage_descriptor_set: FALSE,
            dynamic_pipeline_layout: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePerStageDescriptorSetFeaturesNV<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDevicePerStageDescriptorSetFeaturesNV<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceExternalFormatResolveFeaturesANDROID<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub external_format_resolve: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceExternalFormatResolveFeaturesANDROID<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceExternalFormatResolveFeaturesANDROID,
            next: ptr::null_mut(),
            external_format_resolve: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceExternalFormatResolveFeaturesANDROID<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceExternalFormatResolveFeaturesANDROID<'_> {}

/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceExternalFormatResolvePropertiesANDROID<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub null_color_attachment_with_external_format_resolve: Bool32,
    pub external_format_resolve_chroma_offset_x: ChromaLocation,
    pub external_format_resolve_chroma_offset_y: ChromaLocation,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceExternalFormatResolvePropertiesANDROID<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceExternalFormatResolvePropertiesANDROID,
            next: ptr::null_mut(),
            null_color_attachment_with_external_format_resolve: FALSE,
            external_format_resolve_chroma_offset_x: Default::default(),
            external_format_resolve_chroma_offset_y: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceExternalFormatResolvePropertiesANDROID<'_> {}

/// Extends: `AndroidHardwareBufferPropertiesANDROID`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct AndroidHardwareBufferFormatResolvePropertiesANDROID<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub color_attachment_format: Format,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for AndroidHardwareBufferFormatResolvePropertiesANDROID<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::AndroidHardwareBufferFormatResolvePropertiesANDROID,
            next: ptr::null_mut(),
            color_attachment_format: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsAndroidHardwareBufferPropertiesANDROID
    for AndroidHardwareBufferFormatResolvePropertiesANDROID<'_>
{
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct LatencySleepModeInfoNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub low_latency_mode: Bool32,
    pub low_latency_boost: Bool32,
    pub minimum_interval_us: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for LatencySleepModeInfoNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::LatencySleepModeInfoNV,
            next: ptr::null_mut(),
            low_latency_mode: FALSE,
            low_latency_boost: FALSE,
            minimum_interval_us: 0,
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct LatencySleepInfoNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub signal_semaphore: Semaphore,
    pub value: u64,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for LatencySleepInfoNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::LatencySleepInfoNV,
            next: ptr::null_mut(),
            signal_semaphore: Default::default(),
            value: 0,
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct SetLatencyMarkerInfoNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub present_id: u64,
    pub marker: LatencyMarkerNV,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for SetLatencyMarkerInfoNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::SetLatencyMarkerInfoNV,
            next: ptr::null_mut(),
            present_id: 0,
            marker: Default::default(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct GetLatencyMarkerInfoNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub timing_count: u32,
    /// Nullable
    /// Len: `timing_count`
    pub timings: *mut LatencyTimingsFrameReportNV<'a>,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for GetLatencyMarkerInfoNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::GetLatencyMarkerInfoNV,
            next: ptr::null_mut(),
            timing_count: 0,
            timings: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct LatencyTimingsFrameReportNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub present_id: u64,
    pub input_sample_time_us: u64,
    pub sim_start_time_us: u64,
    pub sim_end_time_us: u64,
    pub render_submit_start_time_us: u64,
    pub render_submit_end_time_us: u64,
    pub present_start_time_us: u64,
    pub present_end_time_us: u64,
    pub driver_start_time_us: u64,
    pub driver_end_time_us: u64,
    pub os_render_queue_start_time_us: u64,
    pub os_render_queue_end_time_us: u64,
    pub gpu_render_start_time_us: u64,
    pub gpu_render_end_time_us: u64,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for LatencyTimingsFrameReportNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::LatencyTimingsFrameReportNV,
            next: ptr::null_mut(),
            present_id: 0,
            input_sample_time_us: 0,
            sim_start_time_us: 0,
            sim_end_time_us: 0,
            render_submit_start_time_us: 0,
            render_submit_end_time_us: 0,
            present_start_time_us: 0,
            present_end_time_us: 0,
            driver_start_time_us: 0,
            driver_end_time_us: 0,
            os_render_queue_start_time_us: 0,
            os_render_queue_end_time_us: 0,
            gpu_render_start_time_us: 0,
            gpu_render_end_time_us: 0,
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct OutOfBandQueueTypeInfoNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub queue_type: OutOfBandQueueTypeNV,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for OutOfBandQueueTypeInfoNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::OutOfBandQueueTypeInfoNV,
            next: ptr::null_mut(),
            queue_type: Default::default(),
            _marker: PhantomData,
        }
    }
}

/// Extends: `SubmitInfo`, `SubmitInfo2`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct LatencySubmissionPresentIdNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub present_id: u64,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for LatencySubmissionPresentIdNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::LatencySubmissionPresentIdNV,
            next: ptr::null_mut(),
            present_id: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsSubmitInfo for LatencySubmissionPresentIdNV<'_> {}
impl ExtendsSubmitInfo2 for LatencySubmissionPresentIdNV<'_> {}

/// Extends: `SwapchainCreateInfoKHR`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct SwapchainLatencyCreateInfoNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub latency_mode_enable: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for SwapchainLatencyCreateInfoNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::SwapchainLatencyCreateInfoNV,
            next: ptr::null_mut(),
            latency_mode_enable: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsSwapchainCreateInfoKHR for SwapchainLatencyCreateInfoNV<'_> {}

/// Extends: `SurfaceCapabilities2KHR`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct LatencySurfaceCapabilitiesNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub present_mode_count: u32,
    /// Nullable
    /// Len: `present_mode_count`
    pub present_modes: *mut PresentModeKHR,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for LatencySurfaceCapabilitiesNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::LatencySurfaceCapabilitiesNV,
            next: ptr::null_mut(),
            present_mode_count: 0,
            present_modes: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsSurfaceCapabilities2KHR for LatencySurfaceCapabilitiesNV<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceCudaKernelLaunchFeaturesNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub cuda_kernel_launch_features: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceCudaKernelLaunchFeaturesNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceCudaKernelLaunchFeaturesNV,
            next: ptr::null_mut(),
            cuda_kernel_launch_features: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceCudaKernelLaunchFeaturesNV<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceCudaKernelLaunchFeaturesNV<'_> {}

/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceCudaKernelLaunchPropertiesNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub compute_capability_minor: u32,
    pub compute_capability_major: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceCudaKernelLaunchPropertiesNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceCudaKernelLaunchPropertiesNV,
            next: ptr::null_mut(),
            compute_capability_minor: 0,
            compute_capability_major: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceCudaKernelLaunchPropertiesNV<'_> {}

/// Extends: `DeviceQueueCreateInfo`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DeviceQueueShaderCoreControlCreateInfoARM<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub shader_core_count: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for DeviceQueueShaderCoreControlCreateInfoARM<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::DeviceQueueShaderCoreControlCreateInfoARM,
            next: ptr::null_mut(),
            shader_core_count: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsDeviceQueueCreateInfo for DeviceQueueShaderCoreControlCreateInfoARM<'_> {}
impl ExtendsDeviceCreateInfo for DeviceQueueShaderCoreControlCreateInfoARM<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceSchedulingControlsFeaturesARM<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub scheduling_controls: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceSchedulingControlsFeaturesARM<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceSchedulingControlsFeaturesARM,
            next: ptr::null_mut(),
            scheduling_controls: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceSchedulingControlsFeaturesARM<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceSchedulingControlsFeaturesARM<'_> {}

/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceSchedulingControlsPropertiesARM<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub scheduling_controls_flags: PhysicalDeviceSchedulingControlsFlagsARM,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceSchedulingControlsPropertiesARM<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceSchedulingControlsPropertiesARM,
            next: ptr::null_mut(),
            scheduling_controls_flags: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceSchedulingControlsPropertiesARM<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceRelaxedLineRasterizationFeaturesIMG<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub relaxed_line_rasterization: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceRelaxedLineRasterizationFeaturesIMG<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceRelaxedLineRasterizationFeaturesIMG,
            next: ptr::null_mut(),
            relaxed_line_rasterization: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceRelaxedLineRasterizationFeaturesIMG<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceRelaxedLineRasterizationFeaturesIMG<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceRenderPassStripedFeaturesARM<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub render_pass_striped: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceRenderPassStripedFeaturesARM<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceRenderPassStripedFeaturesARM,
            next: ptr::null_mut(),
            render_pass_striped: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceRenderPassStripedFeaturesARM<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceRenderPassStripedFeaturesARM<'_> {}

/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceRenderPassStripedPropertiesARM<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub render_pass_stripe_granularity: Extent2D,
    pub max_render_pass_stripes: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceRenderPassStripedPropertiesARM<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceRenderPassStripedPropertiesARM,
            next: ptr::null_mut(),
            render_pass_stripe_granularity: Default::default(),
            max_render_pass_stripes: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceRenderPassStripedPropertiesARM<'_> {}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct RenderPassStripeInfoARM<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub stripe_area: Rect2D,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for RenderPassStripeInfoARM<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::RenderPassStripeInfoARM,
            next: ptr::null_mut(),
            stripe_area: Default::default(),
            _marker: PhantomData,
        }
    }
}

/// Extends: `RenderingInfo`, `RenderPassBeginInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct RenderPassStripeBeginInfoARM<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub stripe_info_count: u32,
    /// Len: `stripe_info_count`
    pub stripe_infos: *const RenderPassStripeInfoARM<'a>,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for RenderPassStripeBeginInfoARM<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::RenderPassStripeBeginInfoARM,
            next: ptr::null_mut(),
            stripe_info_count: 0,
            stripe_infos: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsRenderingInfo for RenderPassStripeBeginInfoARM<'_> {}
impl ExtendsRenderPassBeginInfo for RenderPassStripeBeginInfoARM<'_> {}

/// Extends: `CommandBufferSubmitInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct RenderPassStripeSubmitInfoARM<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub stripe_semaphore_info_count: u32,
    /// Len: `stripe_semaphore_info_count`
    pub stripe_semaphore_infos: *const SemaphoreSubmitInfo<'a>,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for RenderPassStripeSubmitInfoARM<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::RenderPassStripeSubmitInfoARM,
            next: ptr::null_mut(),
            stripe_semaphore_info_count: 0,
            stripe_semaphore_infos: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsCommandBufferSubmitInfo for RenderPassStripeSubmitInfoARM<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDevicePipelineOpacityMicromapFeaturesARM<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub pipeline_opacity_micromap: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDevicePipelineOpacityMicromapFeaturesARM<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDevicePipelineOpacityMicromapFeaturesARM,
            next: ptr::null_mut(),
            pipeline_opacity_micromap: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePipelineOpacityMicromapFeaturesARM<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDevicePipelineOpacityMicromapFeaturesARM<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub shader_maximal_reconvergence: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR,
            next: ptr::null_mut(),
            shader_maximal_reconvergence: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceShaderSubgroupRotateFeatures<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub shader_subgroup_rotate: Bool32,
    pub shader_subgroup_rotate_clustered: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceShaderSubgroupRotateFeatures<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceShaderSubgroupRotateFeatures,
            next: ptr::null_mut(),
            shader_subgroup_rotate: FALSE,
            shader_subgroup_rotate_clustered: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderSubgroupRotateFeatures<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderSubgroupRotateFeatures<'_> {}

pub type PhysicalDeviceShaderSubgroupRotateFeaturesKHR<'a> =
    PhysicalDeviceShaderSubgroupRotateFeatures<'a>;
/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceShaderExpectAssumeFeatures<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub shader_expect_assume: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceShaderExpectAssumeFeatures<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceShaderExpectAssumeFeatures,
            next: ptr::null_mut(),
            shader_expect_assume: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderExpectAssumeFeatures<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderExpectAssumeFeatures<'_> {}

pub type PhysicalDeviceShaderExpectAssumeFeaturesKHR<'a> =
    PhysicalDeviceShaderExpectAssumeFeatures<'a>;
/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceShaderFloatControls2Features<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub shader_float_controls2: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceShaderFloatControls2Features<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceShaderFloatControls2Features,
            next: ptr::null_mut(),
            shader_float_controls2: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderFloatControls2Features<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderFloatControls2Features<'_> {}

pub type PhysicalDeviceShaderFloatControls2FeaturesKHR<'a> =
    PhysicalDeviceShaderFloatControls2Features<'a>;
/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceDynamicRenderingLocalReadFeatures<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub dynamic_rendering_local_read: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceDynamicRenderingLocalReadFeatures<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceDynamicRenderingLocalReadFeatures,
            next: ptr::null_mut(),
            dynamic_rendering_local_read: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDynamicRenderingLocalReadFeatures<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceDynamicRenderingLocalReadFeatures<'_> {}

pub type PhysicalDeviceDynamicRenderingLocalReadFeaturesKHR<'a> =
    PhysicalDeviceDynamicRenderingLocalReadFeatures<'a>;
/// Extends: `GraphicsPipelineCreateInfo`, `CommandBufferInheritanceInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct RenderingAttachmentLocationInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub color_attachment_count: u32,
    /// Len: `color_attachment_count`
    pub color_attachment_locations: *const u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for RenderingAttachmentLocationInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::RenderingAttachmentLocationInfo,
            next: ptr::null_mut(),
            color_attachment_count: 0,
            color_attachment_locations: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsGraphicsPipelineCreateInfo for RenderingAttachmentLocationInfo<'_> {}
impl ExtendsCommandBufferInheritanceInfo for RenderingAttachmentLocationInfo<'_> {}

pub type RenderingAttachmentLocationInfoKHR<'a> = RenderingAttachmentLocationInfo<'a>;
/// Extends: `GraphicsPipelineCreateInfo`, `CommandBufferInheritanceInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct RenderingInputAttachmentIndexInfo<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub color_attachment_count: u32,
    /// Nullable
    /// Len: `color_attachment_count`
    pub color_attachment_input_indices: *const u32,
    /// Nullable
    pub depth_input_attachment_index: *const u32,
    /// Nullable
    pub stencil_input_attachment_index: *const u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for RenderingInputAttachmentIndexInfo<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::RenderingInputAttachmentIndexInfo,
            next: ptr::null_mut(),
            color_attachment_count: 0,
            color_attachment_input_indices: ptr::null_mut(),
            depth_input_attachment_index: ptr::null_mut(),
            stencil_input_attachment_index: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsGraphicsPipelineCreateInfo for RenderingInputAttachmentIndexInfo<'_> {}
impl ExtendsCommandBufferInheritanceInfo for RenderingInputAttachmentIndexInfo<'_> {}

pub type RenderingInputAttachmentIndexInfoKHR<'a> = RenderingInputAttachmentIndexInfo<'a>;
/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceShaderQuadControlFeaturesKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub shader_quad_control: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceShaderQuadControlFeaturesKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceShaderQuadControlFeaturesKHR,
            next: ptr::null_mut(),
            shader_quad_control: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderQuadControlFeaturesKHR<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderQuadControlFeaturesKHR<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub shader_float16_vector_atomics: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV,
            next: ptr::null_mut(),
            shader_float16_vector_atomics: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceMapMemoryPlacedFeaturesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub memory_map_placed: Bool32,
    pub memory_map_range_placed: Bool32,
    pub memory_unmap_reserve: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceMapMemoryPlacedFeaturesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceMapMemoryPlacedFeaturesEXT,
            next: ptr::null_mut(),
            memory_map_placed: FALSE,
            memory_map_range_placed: FALSE,
            memory_unmap_reserve: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMapMemoryPlacedFeaturesEXT<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceMapMemoryPlacedFeaturesEXT<'_> {}

/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceMapMemoryPlacedPropertiesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub min_placed_memory_map_alignment: DeviceSize,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceMapMemoryPlacedPropertiesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceMapMemoryPlacedPropertiesEXT,
            next: ptr::null_mut(),
            min_placed_memory_map_alignment: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMapMemoryPlacedPropertiesEXT<'_> {}

/// Extends: `MemoryMapInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct MemoryMapPlacedInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub placed_address: *mut c_void,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for MemoryMapPlacedInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::MemoryMapPlacedInfoEXT,
            next: ptr::null_mut(),
            placed_address: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsMemoryMapInfo for MemoryMapPlacedInfoEXT<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceShaderBfloat16FeaturesKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub shader_b_float16_type: Bool32,
    pub shader_b_float16_dot_product: Bool32,
    pub shader_b_float16_cooperative_matrix: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceShaderBfloat16FeaturesKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceShaderBfloat16FeaturesKHR,
            next: ptr::null_mut(),
            shader_b_float16_type: FALSE,
            shader_b_float16_dot_product: FALSE,
            shader_b_float16_cooperative_matrix: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderBfloat16FeaturesKHR<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderBfloat16FeaturesKHR<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceRawAccessChainsFeaturesNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub shader_raw_access_chains: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceRawAccessChainsFeaturesNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceRawAccessChainsFeaturesNV,
            next: ptr::null_mut(),
            shader_raw_access_chains: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceRawAccessChainsFeaturesNV<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceRawAccessChainsFeaturesNV<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceCommandBufferInheritanceFeaturesNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub command_buffer_inheritance: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceCommandBufferInheritanceFeaturesNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceCommandBufferInheritanceFeaturesNV,
            next: ptr::null_mut(),
            command_buffer_inheritance: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceCommandBufferInheritanceFeaturesNV<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceCommandBufferInheritanceFeaturesNV<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceImageAlignmentControlFeaturesMESA<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub image_alignment_control: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceImageAlignmentControlFeaturesMESA<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceImageAlignmentControlFeaturesMESA,
            next: ptr::null_mut(),
            image_alignment_control: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceImageAlignmentControlFeaturesMESA<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceImageAlignmentControlFeaturesMESA<'_> {}

/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceImageAlignmentControlPropertiesMESA<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub supported_image_alignment_mask: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceImageAlignmentControlPropertiesMESA<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceImageAlignmentControlPropertiesMESA,
            next: ptr::null_mut(),
            supported_image_alignment_mask: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceImageAlignmentControlPropertiesMESA<'_> {}

/// Extends: `ImageCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ImageAlignmentControlCreateInfoMESA<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub maximum_requested_alignment: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ImageAlignmentControlCreateInfoMESA<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ImageAlignmentControlCreateInfoMESA,
            next: ptr::null_mut(),
            maximum_requested_alignment: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsImageCreateInfo for ImageAlignmentControlCreateInfoMESA<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceShaderReplicatedCompositesFeaturesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub shader_replicated_composites: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceShaderReplicatedCompositesFeaturesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceShaderReplicatedCompositesFeaturesEXT,
            next: ptr::null_mut(),
            shader_replicated_composites: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderReplicatedCompositesFeaturesEXT<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderReplicatedCompositesFeaturesEXT<'_> {}

pub type PhysicalDevicePresentModeFifoLatestReadyFeaturesEXT<'a> =
    PhysicalDevicePresentModeFifoLatestReadyFeaturesKHR<'a>;
/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDevicePresentModeFifoLatestReadyFeaturesKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub present_mode_fifo_latest_ready: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDevicePresentModeFifoLatestReadyFeaturesKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDevicePresentModeFifoLatestReadyFeaturesKHR,
            next: ptr::null_mut(),
            present_mode_fifo_latest_ready: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePresentModeFifoLatestReadyFeaturesKHR<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDevicePresentModeFifoLatestReadyFeaturesKHR<'_> {}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DepthClampRangeEXT {
    pub min_depth_clamp: f32,
    pub max_depth_clamp: f32,
}
impl Default for DepthClampRangeEXT {
    fn default() -> Self {
        Self {
            min_depth_clamp: 0.0,
            max_depth_clamp: 0.0,
        }
    }
}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceCooperativeMatrix2FeaturesNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub cooperative_matrix_workgroup_scope: Bool32,
    pub cooperative_matrix_flexible_dimensions: Bool32,
    pub cooperative_matrix_reductions: Bool32,
    pub cooperative_matrix_conversions: Bool32,
    pub cooperative_matrix_per_element_operations: Bool32,
    pub cooperative_matrix_tensor_addressing: Bool32,
    pub cooperative_matrix_block_loads: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceCooperativeMatrix2FeaturesNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceCooperativeMatrix2FeaturesNV,
            next: ptr::null_mut(),
            cooperative_matrix_workgroup_scope: FALSE,
            cooperative_matrix_flexible_dimensions: FALSE,
            cooperative_matrix_reductions: FALSE,
            cooperative_matrix_conversions: FALSE,
            cooperative_matrix_per_element_operations: FALSE,
            cooperative_matrix_tensor_addressing: FALSE,
            cooperative_matrix_block_loads: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceCooperativeMatrix2FeaturesNV<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceCooperativeMatrix2FeaturesNV<'_> {}

/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceCooperativeMatrix2PropertiesNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub cooperative_matrix_workgroup_scope_max_workgroup_size: u32,
    pub cooperative_matrix_flexible_dimensions_max_dimension: u32,
    pub cooperative_matrix_workgroup_scope_reserved_shared_memory: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceCooperativeMatrix2PropertiesNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceCooperativeMatrix2PropertiesNV,
            next: ptr::null_mut(),
            cooperative_matrix_workgroup_scope_max_workgroup_size: 0,
            cooperative_matrix_flexible_dimensions_max_dimension: 0,
            cooperative_matrix_workgroup_scope_reserved_shared_memory: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceCooperativeMatrix2PropertiesNV<'_> {}

/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct CooperativeMatrixFlexibleDimensionsPropertiesNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub m_granularity: u32,
    pub n_granularity: u32,
    pub k_granularity: u32,
    pub a_type: ComponentTypeKHR,
    pub b_type: ComponentTypeKHR,
    pub c_type: ComponentTypeKHR,
    pub result_type: ComponentTypeKHR,
    pub saturating_accumulation: Bool32,
    pub scope: ScopeKHR,
    pub workgroup_invocations: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for CooperativeMatrixFlexibleDimensionsPropertiesNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::CooperativeMatrixFlexibleDimensionsPropertiesNV,
            next: ptr::null_mut(),
            m_granularity: 0,
            n_granularity: 0,
            k_granularity: 0,
            a_type: Default::default(),
            b_type: Default::default(),
            c_type: Default::default(),
            result_type: Default::default(),
            saturating_accumulation: FALSE,
            scope: Default::default(),
            workgroup_invocations: 0,
            _marker: PhantomData,
        }
    }
}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceHdrVividFeaturesHUAWEI<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub hdr_vivid: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceHdrVividFeaturesHUAWEI<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceHdrVividFeaturesHUAWEI,
            next: ptr::null_mut(),
            hdr_vivid: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceHdrVividFeaturesHUAWEI<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceHdrVividFeaturesHUAWEI<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceVertexAttributeRobustnessFeaturesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub vertex_attribute_robustness: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceVertexAttributeRobustnessFeaturesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceVertexAttributeRobustnessFeaturesEXT,
            next: ptr::null_mut(),
            vertex_attribute_robustness: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVertexAttributeRobustnessFeaturesEXT<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceVertexAttributeRobustnessFeaturesEXT<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceDenseGeometryFormatFeaturesAMDX<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub dense_geometry_format: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceDenseGeometryFormatFeaturesAMDX<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceDenseGeometryFormatFeaturesAMDX,
            next: ptr::null_mut(),
            dense_geometry_format: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDenseGeometryFormatFeaturesAMDX<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceDenseGeometryFormatFeaturesAMDX<'_> {}

/// Extends: `AccelerationStructureGeometryKHR`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct AccelerationStructureDenseGeometryFormatTrianglesDataAMDX<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub compressed_data: DeviceOrHostAddressConstKHR,
    pub data_size: DeviceSize,
    pub num_triangles: u32,
    pub num_vertices: u32,
    pub max_primitive_index: u32,
    pub max_geometry_index: u32,
    pub format: CompressedTriangleFormatAMDX,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for AccelerationStructureDenseGeometryFormatTrianglesDataAMDX<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::AccelerationStructureDenseGeometryFormatTrianglesDataAMDX,
            next: ptr::null_mut(),
            compressed_data: Default::default(),
            data_size: Default::default(),
            num_triangles: 0,
            num_vertices: 0,
            max_primitive_index: 0,
            max_geometry_index: 0,
            format: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsAccelerationStructureGeometryKHR
    for AccelerationStructureDenseGeometryFormatTrianglesDataAMDX<'_>
{
}
pub trait ExtendsAccelerationStructureDenseGeometryFormatTrianglesDataAMDX {}
impl<'a> AccelerationStructureDenseGeometryFormatTrianglesDataAMDX<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsAccelerationStructureDenseGeometryFormatTrianglesDataAMDX>(
        mut self,
        next: &'a mut T,
    ) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceDepthClampZeroOneFeaturesKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub depth_clamp_zero_one: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceDepthClampZeroOneFeaturesKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceDepthClampZeroOneFeaturesKHR,
            next: ptr::null_mut(),
            depth_clamp_zero_one: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDepthClampZeroOneFeaturesKHR<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceDepthClampZeroOneFeaturesKHR<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceCooperativeVectorFeaturesNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub cooperative_vector: Bool32,
    pub cooperative_vector_training: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceCooperativeVectorFeaturesNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceCooperativeVectorFeaturesNV,
            next: ptr::null_mut(),
            cooperative_vector: FALSE,
            cooperative_vector_training: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceCooperativeVectorFeaturesNV<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceCooperativeVectorFeaturesNV<'_> {}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct CooperativeVectorPropertiesNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub input_type: ComponentTypeKHR,
    pub input_interpretation: ComponentTypeKHR,
    pub matrix_interpretation: ComponentTypeKHR,
    pub bias_interpretation: ComponentTypeKHR,
    pub result_type: ComponentTypeKHR,
    pub transpose: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for CooperativeVectorPropertiesNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::CooperativeVectorPropertiesNV,
            next: ptr::null_mut(),
            input_type: Default::default(),
            input_interpretation: Default::default(),
            matrix_interpretation: Default::default(),
            bias_interpretation: Default::default(),
            result_type: Default::default(),
            transpose: FALSE,
            _marker: PhantomData,
        }
    }
}

/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceCooperativeVectorPropertiesNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub cooperative_vector_supported_stages: ShaderStageFlags,
    pub cooperative_vector_training_float16_accumulation: Bool32,
    pub cooperative_vector_training_float32_accumulation: Bool32,
    pub max_cooperative_vector_components: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceCooperativeVectorPropertiesNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceCooperativeVectorPropertiesNV,
            next: ptr::null_mut(),
            cooperative_vector_supported_stages: Default::default(),
            cooperative_vector_training_float16_accumulation: FALSE,
            cooperative_vector_training_float32_accumulation: FALSE,
            max_cooperative_vector_components: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceCooperativeVectorPropertiesNV<'_> {}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ConvertCooperativeVectorMatrixInfoNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub src_size: usize,
    pub src_data: DeviceOrHostAddressConstKHR,
    /// Nullable
    pub dst_size: *mut usize,
    pub dst_data: DeviceOrHostAddressKHR,
    pub src_component_type: ComponentTypeKHR,
    pub dst_component_type: ComponentTypeKHR,
    pub num_rows: u32,
    pub num_columns: u32,
    pub src_layout: CooperativeVectorMatrixLayoutNV,
    pub src_stride: usize,
    pub dst_layout: CooperativeVectorMatrixLayoutNV,
    pub dst_stride: usize,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ConvertCooperativeVectorMatrixInfoNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ConvertCooperativeVectorMatrixInfoNV,
            next: ptr::null_mut(),
            src_size: 0,
            src_data: Default::default(),
            dst_size: ptr::null_mut(),
            dst_data: Default::default(),
            src_component_type: Default::default(),
            dst_component_type: Default::default(),
            num_rows: 0,
            num_columns: 0,
            src_layout: Default::default(),
            src_stride: 0,
            dst_layout: Default::default(),
            dst_stride: 0,
            _marker: PhantomData,
        }
    }
}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceTileShadingFeaturesQCOM<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub tile_shading: Bool32,
    pub tile_shading_fragment_stage: Bool32,
    pub tile_shading_color_attachments: Bool32,
    pub tile_shading_depth_attachments: Bool32,
    pub tile_shading_stencil_attachments: Bool32,
    pub tile_shading_input_attachments: Bool32,
    pub tile_shading_sampled_attachments: Bool32,
    pub tile_shading_per_tile_draw: Bool32,
    pub tile_shading_per_tile_dispatch: Bool32,
    pub tile_shading_dispatch_tile: Bool32,
    pub tile_shading_apron: Bool32,
    pub tile_shading_anisotropic_apron: Bool32,
    pub tile_shading_atomic_ops: Bool32,
    pub tile_shading_image_processing: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceTileShadingFeaturesQCOM<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceTileShadingFeaturesQCOM,
            next: ptr::null_mut(),
            tile_shading: FALSE,
            tile_shading_fragment_stage: FALSE,
            tile_shading_color_attachments: FALSE,
            tile_shading_depth_attachments: FALSE,
            tile_shading_stencil_attachments: FALSE,
            tile_shading_input_attachments: FALSE,
            tile_shading_sampled_attachments: FALSE,
            tile_shading_per_tile_draw: FALSE,
            tile_shading_per_tile_dispatch: FALSE,
            tile_shading_dispatch_tile: FALSE,
            tile_shading_apron: FALSE,
            tile_shading_anisotropic_apron: FALSE,
            tile_shading_atomic_ops: FALSE,
            tile_shading_image_processing: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceTileShadingFeaturesQCOM<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceTileShadingFeaturesQCOM<'_> {}

/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceTileShadingPropertiesQCOM<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub max_apron_size: u32,
    pub prefer_non_coherent: Bool32,
    pub tile_granularity: Extent2D,
    pub max_tile_shading_rate: Extent2D,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceTileShadingPropertiesQCOM<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceTileShadingPropertiesQCOM,
            next: ptr::null_mut(),
            max_apron_size: 0,
            prefer_non_coherent: FALSE,
            tile_granularity: Default::default(),
            max_tile_shading_rate: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceTileShadingPropertiesQCOM<'_> {}

/// Extends: `RenderPassCreateInfo`, `RenderPassCreateInfo2`, `RenderingInfo`, `CommandBufferInheritanceInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct RenderPassTileShadingCreateInfoQCOM<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub flags: TileShadingRenderPassFlagsQCOM,
    pub tile_apron_size: Extent2D,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for RenderPassTileShadingCreateInfoQCOM<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::RenderPassTileShadingCreateInfoQCOM,
            next: ptr::null_mut(),
            flags: Default::default(),
            tile_apron_size: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsRenderPassCreateInfo for RenderPassTileShadingCreateInfoQCOM<'_> {}
impl ExtendsRenderPassCreateInfo2 for RenderPassTileShadingCreateInfoQCOM<'_> {}
impl ExtendsRenderingInfo for RenderPassTileShadingCreateInfoQCOM<'_> {}
impl ExtendsCommandBufferInheritanceInfo for RenderPassTileShadingCreateInfoQCOM<'_> {}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PerTileBeginInfoQCOM<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PerTileBeginInfoQCOM<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PerTileBeginInfoQCOM,
            next: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PerTileEndInfoQCOM<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PerTileEndInfoQCOM<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PerTileEndInfoQCOM,
            next: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DispatchTileInfoQCOM<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for DispatchTileInfoQCOM<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::DispatchTileInfoQCOM,
            next: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub max_fragment_density_map_layers: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE,
            next: ptr::null_mut(),
            max_fragment_density_map_layers: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2
    for PhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE<'_>
{
}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub fragment_density_map_layered: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE,
            next: ptr::null_mut(),
            fragment_density_map_layered: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE<'_> {}

/// Extends: `GraphicsPipelineCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PipelineFragmentDensityMapLayeredCreateInfoVALVE<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub max_fragment_density_map_layers: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PipelineFragmentDensityMapLayeredCreateInfoVALVE<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PipelineFragmentDensityMapLayeredCreateInfoVALVE,
            next: ptr::null_mut(),
            max_fragment_density_map_layers: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsGraphicsPipelineCreateInfo for PipelineFragmentDensityMapLayeredCreateInfoVALVE<'_> {}

/// Extends: `PresentInfoKHR`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct SetPresentConfigNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub num_frames_per_batch: u32,
    pub present_config_feedback: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for SetPresentConfigNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::SetPresentConfigNV,
            next: ptr::null_mut(),
            num_frames_per_batch: 0,
            present_config_feedback: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPresentInfoKHR for SetPresentConfigNV<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDevicePresentMeteringFeaturesNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub present_metering: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDevicePresentMeteringFeaturesNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDevicePresentMeteringFeaturesNV,
            next: ptr::null_mut(),
            present_metering: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePresentMeteringFeaturesNV<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDevicePresentMeteringFeaturesNV<'_> {}

/// Extends: `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ExternalComputeQueueDeviceCreateInfoNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub reserved_external_queues: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ExternalComputeQueueDeviceCreateInfoNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ExternalComputeQueueDeviceCreateInfoNV,
            next: ptr::null_mut(),
            reserved_external_queues: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsDeviceCreateInfo for ExternalComputeQueueDeviceCreateInfoNV<'_> {}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ExternalComputeQueueCreateInfoNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub preferred_queue: vkQueue,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ExternalComputeQueueCreateInfoNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ExternalComputeQueueCreateInfoNV,
            next: ptr::null_mut(),
            preferred_queue: Default::default(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ExternalComputeQueueDataParamsNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub device_index: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ExternalComputeQueueDataParamsNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ExternalComputeQueueDataParamsNV,
            next: ptr::null_mut(),
            device_index: 0,
            _marker: PhantomData,
        }
    }
}

/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceExternalComputeQueuePropertiesNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub external_data_size: u32,
    pub max_external_queues: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceExternalComputeQueuePropertiesNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceExternalComputeQueuePropertiesNV,
            next: ptr::null_mut(),
            external_data_size: 0,
            max_external_queues: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceExternalComputeQueuePropertiesNV<'_> {}

#[repr(transparent)]
#[derive(Debug, Default)]
pub struct ExternalComputeQueueNV(*mut u8);
impl ExternalComputeQueueNV {
    #[inline]
    pub const fn null() -> Self {
        Self(ptr::null_mut())
    }
    #[inline]
    pub const fn is_null(self) -> bool {
        self.0.is_null()
    }
}
impl Copy for ExternalComputeQueueNV {}
impl Clone for ExternalComputeQueueNV {
    fn clone(&self) -> Self {
        *self
    }
}
unsafe impl Send for ExternalComputeQueueNV {}
unsafe impl Sync for ExternalComputeQueueNV {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub shader_uniform_buffer_unsized_array: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT,
            next: ptr::null_mut(),
            shader_uniform_buffer_unsized_array: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2
    for PhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT<'_>
{
}
impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceFormatPackFeaturesARM<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub format_pack: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceFormatPackFeaturesARM<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceFormatPackFeaturesARM,
            next: ptr::null_mut(),
            format_pack: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceFormatPackFeaturesARM<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceFormatPackFeaturesARM<'_> {}

/// Extends: `DataGraphPipelineResourceInfoARM`, `DataGraphPipelineConstantARM`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct TensorDescriptionARM<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub tiling: TensorTilingARM,
    pub format: Format,
    pub dimension_count: u32,
    /// Len: `dimension_count`
    pub dimensions: *const i64,
    /// Nullable
    /// Len: `dimension_count`
    pub strides: *const i64,
    pub usage: TensorUsageFlagsARM,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for TensorDescriptionARM<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::TensorDescriptionARM,
            next: ptr::null_mut(),
            tiling: Default::default(),
            format: Default::default(),
            dimension_count: 0,
            dimensions: ptr::null_mut(),
            strides: ptr::null_mut(),
            usage: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsDataGraphPipelineResourceInfoARM for TensorDescriptionARM<'_> {}
impl ExtendsDataGraphPipelineConstantARM for TensorDescriptionARM<'_> {}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct TensorCreateInfoARM<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub flags: TensorCreateFlagsARM,
    pub description: *const TensorDescriptionARM<'a>,
    pub sharing_mode: SharingMode,
    pub queue_family_index_count: u32,
    /// Len: `queue_family_index_count`
    pub queue_family_indices: *const u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for TensorCreateInfoARM<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::TensorCreateInfoARM,
            next: ptr::null_mut(),
            flags: Default::default(),
            description: ptr::null_mut(),
            sharing_mode: Default::default(),
            queue_family_index_count: 0,
            queue_family_indices: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsTensorCreateInfoARM {}
impl<'a> TensorCreateInfoARM<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsTensorCreateInfoARM>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct TensorViewCreateInfoARM<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub flags: TensorViewCreateFlagsARM,
    pub tensor: TensorARM,
    pub format: Format,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for TensorViewCreateInfoARM<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::TensorViewCreateInfoARM,
            next: ptr::null_mut(),
            flags: Default::default(),
            tensor: Default::default(),
            format: Default::default(),
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsTensorViewCreateInfoARM {}
impl<'a> TensorViewCreateInfoARM<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsTensorViewCreateInfoARM>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct TensorMemoryRequirementsInfoARM<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub tensor: TensorARM,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for TensorMemoryRequirementsInfoARM<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::TensorMemoryRequirementsInfoARM,
            next: ptr::null_mut(),
            tensor: Default::default(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct BindTensorMemoryInfoARM<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub tensor: TensorARM,
    pub memory: DeviceMemory,
    pub memory_offset: DeviceSize,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for BindTensorMemoryInfoARM<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::BindTensorMemoryInfoARM,
            next: ptr::null_mut(),
            tensor: Default::default(),
            memory: Default::default(),
            memory_offset: Default::default(),
            _marker: PhantomData,
        }
    }
}

/// Extends: `WriteDescriptorSet`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct WriteDescriptorSetTensorARM<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub tensor_view_count: u32,
    /// Nullable
    /// Len: `tensor_view_count`
    pub tensor_views: *const TensorViewARM,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for WriteDescriptorSetTensorARM<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::WriteDescriptorSetTensorARM,
            next: ptr::null_mut(),
            tensor_view_count: 0,
            tensor_views: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsWriteDescriptorSet for WriteDescriptorSetTensorARM<'_> {}

/// Extends: `FormatProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct TensorFormatPropertiesARM<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub optimal_tiling_tensor_features: FormatFeatureFlags2,
    pub linear_tiling_tensor_features: FormatFeatureFlags2,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for TensorFormatPropertiesARM<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::TensorFormatPropertiesARM,
            next: ptr::null_mut(),
            optimal_tiling_tensor_features: Default::default(),
            linear_tiling_tensor_features: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsFormatProperties2 for TensorFormatPropertiesARM<'_> {}

/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceTensorPropertiesARM<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub max_tensor_dimension_count: u32,
    pub max_tensor_elements: u64,
    pub max_per_dimension_tensor_elements: u64,
    pub max_tensor_stride: i64,
    pub max_tensor_size: u64,
    pub max_tensor_shader_access_array_length: u32,
    pub max_tensor_shader_access_size: u32,
    pub max_descriptor_set_storage_tensors: u32,
    pub max_per_stage_descriptor_set_storage_tensors: u32,
    pub max_descriptor_set_update_after_bind_storage_tensors: u32,
    pub max_per_stage_descriptor_update_after_bind_storage_tensors: u32,
    pub shader_storage_tensor_array_non_uniform_indexing_native: Bool32,
    pub shader_tensor_supported_stages: ShaderStageFlags,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceTensorPropertiesARM<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceTensorPropertiesARM,
            next: ptr::null_mut(),
            max_tensor_dimension_count: 0,
            max_tensor_elements: 0,
            max_per_dimension_tensor_elements: 0,
            max_tensor_stride: 0,
            max_tensor_size: 0,
            max_tensor_shader_access_array_length: 0,
            max_tensor_shader_access_size: 0,
            max_descriptor_set_storage_tensors: 0,
            max_per_stage_descriptor_set_storage_tensors: 0,
            max_descriptor_set_update_after_bind_storage_tensors: 0,
            max_per_stage_descriptor_update_after_bind_storage_tensors: 0,
            shader_storage_tensor_array_non_uniform_indexing_native: FALSE,
            shader_tensor_supported_stages: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceTensorPropertiesARM<'_> {}

/// Extends: `DependencyInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct TensorMemoryBarrierARM<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub src_stage_mask: PipelineStageFlags2,
    pub src_access_mask: AccessFlags2,
    pub dst_stage_mask: PipelineStageFlags2,
    pub dst_access_mask: AccessFlags2,
    pub src_queue_family_index: u32,
    pub dst_queue_family_index: u32,
    pub tensor: TensorARM,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for TensorMemoryBarrierARM<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::TensorMemoryBarrierARM,
            next: ptr::null_mut(),
            src_stage_mask: Default::default(),
            src_access_mask: Default::default(),
            dst_stage_mask: Default::default(),
            dst_access_mask: Default::default(),
            src_queue_family_index: 0,
            dst_queue_family_index: 0,
            tensor: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsDependencyInfo for TensorMemoryBarrierARM<'_> {}

/// Extends: `DependencyInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct TensorDependencyInfoARM<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub tensor_memory_barrier_count: u32,
    pub tensor_memory_barriers: *const TensorMemoryBarrierARM<'a>,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for TensorDependencyInfoARM<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::TensorDependencyInfoARM,
            next: ptr::null_mut(),
            tensor_memory_barrier_count: 0,
            tensor_memory_barriers: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsDependencyInfo for TensorDependencyInfoARM<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceTensorFeaturesARM<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub tensor_non_packed: Bool32,
    pub shader_tensor_access: Bool32,
    pub shader_storage_tensor_array_dynamic_indexing: Bool32,
    pub shader_storage_tensor_array_non_uniform_indexing: Bool32,
    pub descriptor_binding_storage_tensor_update_after_bind: Bool32,
    pub tensors: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceTensorFeaturesARM<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceTensorFeaturesARM,
            next: ptr::null_mut(),
            tensor_non_packed: FALSE,
            shader_tensor_access: FALSE,
            shader_storage_tensor_array_dynamic_indexing: FALSE,
            shader_storage_tensor_array_non_uniform_indexing: FALSE,
            descriptor_binding_storage_tensor_update_after_bind: FALSE,
            tensors: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceTensorFeaturesARM<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceTensorFeaturesARM<'_> {}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DeviceTensorMemoryRequirementsARM<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub create_info: *const TensorCreateInfoARM<'a>,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for DeviceTensorMemoryRequirementsARM<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::DeviceTensorMemoryRequirementsARM,
            next: ptr::null_mut(),
            create_info: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct CopyTensorInfoARM<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub src_tensor: TensorARM,
    pub dst_tensor: TensorARM,
    pub region_count: u32,
    /// Len: `region_count`
    pub regions: *const TensorCopyARM<'a>,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for CopyTensorInfoARM<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::CopyTensorInfoARM,
            next: ptr::null_mut(),
            src_tensor: Default::default(),
            dst_tensor: Default::default(),
            region_count: 0,
            regions: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct TensorCopyARM<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub dimension_count: u32,
    /// Nullable
    /// Len: `dimension_count`
    pub src_offset: *const u64,
    /// Nullable
    /// Len: `dimension_count`
    pub dst_offset: *const u64,
    /// Nullable
    /// Len: `dimension_count`
    pub extent: *const u64,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for TensorCopyARM<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::TensorCopyARM,
            next: ptr::null_mut(),
            dimension_count: 0,
            src_offset: ptr::null_mut(),
            dst_offset: ptr::null_mut(),
            extent: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

/// Extends: `MemoryAllocateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct MemoryDedicatedAllocateInfoTensorARM<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    /// Tensor that this allocation will be bound to
    pub tensor: TensorARM,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for MemoryDedicatedAllocateInfoTensorARM<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::MemoryDedicatedAllocateInfoTensorARM,
            next: ptr::null_mut(),
            tensor: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsMemoryAllocateInfo for MemoryDedicatedAllocateInfoTensorARM<'_> {}

/// Extends: `PhysicalDeviceProperties2`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceDescriptorBufferTensorPropertiesARM<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub tensor_capture_replay_descriptor_data_size: usize,
    pub tensor_view_capture_replay_descriptor_data_size: usize,
    pub tensor_descriptor_size: usize,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceDescriptorBufferTensorPropertiesARM<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceDescriptorBufferTensorPropertiesARM,
            next: ptr::null_mut(),
            tensor_capture_replay_descriptor_data_size: 0,
            tensor_view_capture_replay_descriptor_data_size: 0,
            tensor_descriptor_size: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDescriptorBufferTensorPropertiesARM<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceDescriptorBufferTensorFeaturesARM<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub descriptor_buffer_tensor_descriptors: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceDescriptorBufferTensorFeaturesARM<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceDescriptorBufferTensorFeaturesARM,
            next: ptr::null_mut(),
            descriptor_buffer_tensor_descriptors: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDescriptorBufferTensorFeaturesARM<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceDescriptorBufferTensorFeaturesARM<'_> {}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct TensorCaptureDescriptorDataInfoARM<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub tensor: TensorARM,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for TensorCaptureDescriptorDataInfoARM<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::TensorCaptureDescriptorDataInfoARM,
            next: ptr::null_mut(),
            tensor: Default::default(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct TensorViewCaptureDescriptorDataInfoARM<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub tensor_view: TensorViewARM,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for TensorViewCaptureDescriptorDataInfoARM<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::TensorViewCaptureDescriptorDataInfoARM,
            next: ptr::null_mut(),
            tensor_view: Default::default(),
            _marker: PhantomData,
        }
    }
}

/// Extends: `DescriptorGetInfoEXT`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DescriptorGetTensorInfoARM<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub tensor_view: TensorViewARM,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for DescriptorGetTensorInfoARM<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::DescriptorGetTensorInfoARM,
            next: ptr::null_mut(),
            tensor_view: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsDescriptorGetInfoEXT for DescriptorGetTensorInfoARM<'_> {}

/// Extends: `SubmitInfo`, `SubmitInfo2`, `PresentInfoKHR`, `BindSparseInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct FrameBoundaryTensorsARM<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub tensor_count: u32,
    /// Len: `tensor_count`
    pub tensors: *const TensorARM,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for FrameBoundaryTensorsARM<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::FrameBoundaryTensorsARM,
            next: ptr::null_mut(),
            tensor_count: 0,
            tensors: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsSubmitInfo for FrameBoundaryTensorsARM<'_> {}
impl ExtendsSubmitInfo2 for FrameBoundaryTensorsARM<'_> {}
impl ExtendsPresentInfoKHR for FrameBoundaryTensorsARM<'_> {}
impl ExtendsBindSparseInfo for FrameBoundaryTensorsARM<'_> {}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceExternalTensorInfoARM<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub flags: TensorCreateFlagsARM,
    pub description: *const TensorDescriptionARM<'a>,
    pub handle_type: ExternalMemoryHandleTypeFlags,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceExternalTensorInfoARM<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceExternalTensorInfoARM,
            next: ptr::null_mut(),
            flags: Default::default(),
            description: ptr::null_mut(),
            handle_type: Default::default(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ExternalTensorPropertiesARM<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub external_memory_properties: ExternalMemoryProperties,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ExternalTensorPropertiesARM<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ExternalTensorPropertiesARM,
            next: ptr::null_mut(),
            external_memory_properties: Default::default(),
            _marker: PhantomData,
        }
    }
}

/// Extends: `TensorCreateInfoARM`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ExternalMemoryTensorCreateInfoARM<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub handle_types: ExternalMemoryHandleTypeFlags,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ExternalMemoryTensorCreateInfoARM<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ExternalMemoryTensorCreateInfoARM,
            next: ptr::null_mut(),
            handle_types: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsTensorCreateInfoARM for ExternalMemoryTensorCreateInfoARM<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceShaderFloat8FeaturesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub shader_float8: Bool32,
    pub shader_float8_cooperative_matrix: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceShaderFloat8FeaturesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceShaderFloat8FeaturesEXT,
            next: ptr::null_mut(),
            shader_float8: FALSE,
            shader_float8_cooperative_matrix: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderFloat8FeaturesEXT<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderFloat8FeaturesEXT<'_> {}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct SurfaceCreateInfoOHOS<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub flags: SurfaceCreateFlagsOHOS,
    pub window: *mut OHNativeWindow,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for SurfaceCreateInfoOHOS<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::SurfaceCreateInfoOHOS,
            next: ptr::null_mut(),
            flags: Default::default(),
            window: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceDataGraphFeaturesARM<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub data_graph: Bool32,
    pub data_graph_update_after_bind: Bool32,
    pub data_graph_specialization_constants: Bool32,
    pub data_graph_descriptor_buffer: Bool32,
    pub data_graph_shader_module: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceDataGraphFeaturesARM<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceDataGraphFeaturesARM,
            next: ptr::null_mut(),
            data_graph: FALSE,
            data_graph_update_after_bind: FALSE,
            data_graph_specialization_constants: FALSE,
            data_graph_descriptor_buffer: FALSE,
            data_graph_shader_module: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDataGraphFeaturesARM<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceDataGraphFeaturesARM<'_> {}

/// Extends: `DataGraphPipelineConstantARM`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub dimension: u32,
    pub zero_count: u32,
    pub group_size: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM,
            next: ptr::null_mut(),
            dimension: 0,
            zero_count: 0,
            group_size: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsDataGraphPipelineConstantARM
    for DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM<'_>
{
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DataGraphPipelineConstantARM<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub id: u32,
    pub constant_data: *const c_void,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for DataGraphPipelineConstantARM<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::DataGraphPipelineConstantARM,
            next: ptr::null_mut(),
            id: 0,
            constant_data: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsDataGraphPipelineConstantARM {}
impl<'a> DataGraphPipelineConstantARM<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsDataGraphPipelineConstantARM>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DataGraphPipelineResourceInfoARM<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub descriptor_set: u32,
    pub binding: u32,
    pub array_element: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for DataGraphPipelineResourceInfoARM<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::DataGraphPipelineResourceInfoARM,
            next: ptr::null_mut(),
            descriptor_set: 0,
            binding: 0,
            array_element: 0,
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsDataGraphPipelineResourceInfoARM {}
impl<'a> DataGraphPipelineResourceInfoARM<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsDataGraphPipelineResourceInfoARM>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

/// Extends: `DataGraphPipelineCreateInfoARM`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DataGraphPipelineCompilerControlCreateInfoARM<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    /// Len: null-terminated
    pub vendor_options: *const c_char,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for DataGraphPipelineCompilerControlCreateInfoARM<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::DataGraphPipelineCompilerControlCreateInfoARM,
            next: ptr::null_mut(),
            vendor_options: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsDataGraphPipelineCreateInfoARM for DataGraphPipelineCompilerControlCreateInfoARM<'_> {}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DataGraphPipelineCreateInfoARM<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub flags: PipelineCreateFlags2KHR,
    pub layout: PipelineLayout,
    pub resource_info_count: u32,
    /// Len: `resource_info_count`
    pub resource_infos: *const DataGraphPipelineResourceInfoARM<'a>,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for DataGraphPipelineCreateInfoARM<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::DataGraphPipelineCreateInfoARM,
            next: ptr::null_mut(),
            flags: Default::default(),
            layout: Default::default(),
            resource_info_count: 0,
            resource_infos: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsDataGraphPipelineCreateInfoARM {}
impl<'a> DataGraphPipelineCreateInfoARM<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsDataGraphPipelineCreateInfoARM>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

/// Extends: `DataGraphPipelineCreateInfoARM`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DataGraphPipelineShaderModuleCreateInfoARM<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub module: ShaderModule,
    /// Len: null-terminated
    pub name: *const c_char,
    /// Nullable
    pub specialization_info: *const SpecializationInfo<'a>,
    pub constant_count: u32,
    /// Nullable
    /// Len: `constant_count`
    pub constants: *const DataGraphPipelineConstantARM<'a>,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for DataGraphPipelineShaderModuleCreateInfoARM<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::DataGraphPipelineShaderModuleCreateInfoARM,
            next: ptr::null_mut(),
            module: Default::default(),
            name: ptr::null_mut(),
            specialization_info: ptr::null_mut(),
            constant_count: 0,
            constants: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsDataGraphPipelineCreateInfoARM for DataGraphPipelineShaderModuleCreateInfoARM<'_> {}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DataGraphPipelineSessionCreateInfoARM<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub flags: DataGraphPipelineSessionCreateFlagsARM,
    pub data_graph_pipeline: Pipeline,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for DataGraphPipelineSessionCreateInfoARM<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::DataGraphPipelineSessionCreateInfoARM,
            next: ptr::null_mut(),
            flags: Default::default(),
            data_graph_pipeline: Default::default(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DataGraphPipelineSessionBindPointRequirementsInfoARM<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub session: DataGraphPipelineSessionARM,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for DataGraphPipelineSessionBindPointRequirementsInfoARM<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::DataGraphPipelineSessionBindPointRequirementsInfoARM,
            next: ptr::null_mut(),
            session: Default::default(),
            _marker: PhantomData,
        }
    }
}

/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DataGraphPipelineSessionBindPointRequirementARM<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub bind_point: DataGraphPipelineSessionBindPointARM,
    pub bind_point_type: DataGraphPipelineSessionBindPointTypeARM,
    pub num_objects: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for DataGraphPipelineSessionBindPointRequirementARM<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::DataGraphPipelineSessionBindPointRequirementARM,
            next: ptr::null_mut(),
            bind_point: Default::default(),
            bind_point_type: Default::default(),
            num_objects: 0,
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DataGraphPipelineSessionMemoryRequirementsInfoARM<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub session: DataGraphPipelineSessionARM,
    pub bind_point: DataGraphPipelineSessionBindPointARM,
    pub object_index: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for DataGraphPipelineSessionMemoryRequirementsInfoARM<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::DataGraphPipelineSessionMemoryRequirementsInfoARM,
            next: ptr::null_mut(),
            session: Default::default(),
            bind_point: Default::default(),
            object_index: 0,
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct BindDataGraphPipelineSessionMemoryInfoARM<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub session: DataGraphPipelineSessionARM,
    pub bind_point: DataGraphPipelineSessionBindPointARM,
    pub object_index: u32,
    pub memory: DeviceMemory,
    pub memory_offset: DeviceSize,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for BindDataGraphPipelineSessionMemoryInfoARM<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::BindDataGraphPipelineSessionMemoryInfoARM,
            next: ptr::null_mut(),
            session: Default::default(),
            bind_point: Default::default(),
            object_index: 0,
            memory: Default::default(),
            memory_offset: Default::default(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DataGraphPipelineInfoARM<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub data_graph_pipeline: Pipeline,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for DataGraphPipelineInfoARM<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::DataGraphPipelineInfoARM,
            next: ptr::null_mut(),
            data_graph_pipeline: Default::default(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DataGraphPipelinePropertyQueryResultARM<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub property: DataGraphPipelinePropertyARM,
    pub is_text: Bool32,
    pub data_size: usize,
    /// Nullable
    /// Len: `data_size`
    pub data: *mut c_void,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for DataGraphPipelinePropertyQueryResultARM<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::DataGraphPipelinePropertyQueryResultARM,
            next: ptr::null_mut(),
            property: Default::default(),
            is_text: FALSE,
            data_size: 0,
            data: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

/// Extends: `DataGraphPipelineCreateInfoARM`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DataGraphPipelineIdentifierCreateInfoARM<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub identifier_size: u32,
    /// Len: `identifier_size`
    pub identifier: *const u8,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for DataGraphPipelineIdentifierCreateInfoARM<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::DataGraphPipelineIdentifierCreateInfoARM,
            next: ptr::null_mut(),
            identifier_size: 0,
            identifier: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsDataGraphPipelineCreateInfoARM for DataGraphPipelineIdentifierCreateInfoARM<'_> {}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DataGraphPipelineDispatchInfoARM<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub flags: DataGraphPipelineDispatchFlagsARM,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for DataGraphPipelineDispatchInfoARM<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::DataGraphPipelineDispatchInfoARM,
            next: ptr::null_mut(),
            flags: Default::default(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceDataGraphProcessingEngineARM {
    pub ty: PhysicalDeviceDataGraphProcessingEngineTypeARM,
    pub is_foreign: Bool32,
}
impl Default for PhysicalDeviceDataGraphProcessingEngineARM {
    fn default() -> Self {
        Self {
            ty: Default::default(),
            is_foreign: FALSE,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceDataGraphOperationSupportARM {
    pub operation_type: PhysicalDeviceDataGraphOperationTypeARM,
    /// Len: null-terminated
    pub name: [c_char; MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM as usize],
    pub version: u32,
}
impl Default for PhysicalDeviceDataGraphOperationSupportARM {
    fn default() -> Self {
        Self {
            operation_type: Default::default(),
            name: unsafe { mem::zeroed() },
            version: 0,
        }
    }
}

/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct QueueFamilyDataGraphPropertiesARM<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub engine: PhysicalDeviceDataGraphProcessingEngineARM,
    pub operation: PhysicalDeviceDataGraphOperationSupportARM,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for QueueFamilyDataGraphPropertiesARM<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::QueueFamilyDataGraphPropertiesARM,
            next: ptr::null_mut(),
            engine: Default::default(),
            operation: Default::default(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub queue_family_index: u32,
    pub engine_type: PhysicalDeviceDataGraphProcessingEngineTypeARM,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM,
            next: ptr::null_mut(),
            queue_family_index: 0,
            engine_type: Default::default(),
            _marker: PhantomData,
        }
    }
}

/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct QueueFamilyDataGraphProcessingEnginePropertiesARM<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub foreign_semaphore_handle_types: ExternalSemaphoreHandleTypeFlags,
    pub foreign_memory_handle_types: ExternalMemoryHandleTypeFlags,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for QueueFamilyDataGraphProcessingEnginePropertiesARM<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::QueueFamilyDataGraphProcessingEnginePropertiesARM,
            next: ptr::null_mut(),
            foreign_semaphore_handle_types: Default::default(),
            foreign_memory_handle_types: Default::default(),
            _marker: PhantomData,
        }
    }
}

/// Extends: `DataGraphPipelineCreateInfoARM`, `DescriptorPoolCreateInfo`, `CommandPoolCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DataGraphProcessingEngineCreateInfoARM<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub processing_engine_count: u32,
    /// Len: `processing_engine_count`
    pub processing_engines: *mut PhysicalDeviceDataGraphProcessingEngineARM,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for DataGraphProcessingEngineCreateInfoARM<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::DataGraphProcessingEngineCreateInfoARM,
            next: ptr::null_mut(),
            processing_engine_count: 0,
            processing_engines: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsDataGraphPipelineCreateInfoARM for DataGraphProcessingEngineCreateInfoARM<'_> {}
impl ExtendsDescriptorPoolCreateInfo for DataGraphProcessingEngineCreateInfoARM<'_> {}
impl ExtendsCommandPoolCreateInfo for DataGraphProcessingEngineCreateInfoARM<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDevicePipelineCacheIncrementalModeFeaturesSEC<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub pipeline_cache_incremental_mode: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDevicePipelineCacheIncrementalModeFeaturesSEC<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDevicePipelineCacheIncrementalModeFeaturesSEC,
            next: ptr::null_mut(),
            pipeline_cache_incremental_mode: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePipelineCacheIncrementalModeFeaturesSEC<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDevicePipelineCacheIncrementalModeFeaturesSEC<'_> {}

/// Extends: `DataGraphPipelineCreateInfoARM`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DataGraphPipelineBuiltinModelCreateInfoQCOM<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub operation: *const PhysicalDeviceDataGraphOperationSupportARM,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for DataGraphPipelineBuiltinModelCreateInfoQCOM<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::DataGraphPipelineBuiltinModelCreateInfoQCOM,
            next: ptr::null_mut(),
            operation: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsDataGraphPipelineCreateInfoARM for DataGraphPipelineBuiltinModelCreateInfoQCOM<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceDataGraphModelFeaturesQCOM<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub data_graph_model: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceDataGraphModelFeaturesQCOM<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceDataGraphModelFeaturesQCOM,
            next: ptr::null_mut(),
            data_graph_model: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDataGraphModelFeaturesQCOM<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceDataGraphModelFeaturesQCOM<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceShaderUntypedPointersFeaturesKHR<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub shader_untyped_pointers: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceShaderUntypedPointersFeaturesKHR<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceShaderUntypedPointersFeaturesKHR,
            next: ptr::null_mut(),
            shader_untyped_pointers: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderUntypedPointersFeaturesKHR<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderUntypedPointersFeaturesKHR<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub video_encode_rgb_conversion: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE,
            next: ptr::null_mut(),
            video_encode_rgb_conversion: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE<'_> {}

/// Extends: `VideoCapabilitiesKHR`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VideoEncodeRgbConversionCapabilitiesVALVE<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub rgb_models: VideoEncodeRgbModelConversionFlagsVALVE,
    pub rgb_ranges: VideoEncodeRgbRangeCompressionFlagsVALVE,
    pub x_chroma_offsets: VideoEncodeRgbChromaOffsetFlagsVALVE,
    pub y_chroma_offsets: VideoEncodeRgbChromaOffsetFlagsVALVE,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for VideoEncodeRgbConversionCapabilitiesVALVE<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::VideoEncodeRgbConversionCapabilitiesVALVE,
            next: ptr::null_mut(),
            rgb_models: Default::default(),
            rgb_ranges: Default::default(),
            x_chroma_offsets: Default::default(),
            y_chroma_offsets: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsVideoCapabilitiesKHR for VideoEncodeRgbConversionCapabilitiesVALVE<'_> {}

/// Extends: `VideoProfileInfoKHR`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VideoEncodeProfileRgbConversionInfoVALVE<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub perform_encode_rgb_conversion: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for VideoEncodeProfileRgbConversionInfoVALVE<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::VideoEncodeProfileRgbConversionInfoVALVE,
            next: ptr::null_mut(),
            perform_encode_rgb_conversion: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsVideoProfileInfoKHR for VideoEncodeProfileRgbConversionInfoVALVE<'_> {}

/// Extends: `VideoSessionCreateInfoKHR`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct VideoEncodeSessionRgbConversionCreateInfoVALVE<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub rgb_model: VideoEncodeRgbModelConversionFlagsVALVE,
    pub rgb_range: VideoEncodeRgbRangeCompressionFlagsVALVE,
    pub x_chroma_offset: VideoEncodeRgbChromaOffsetFlagsVALVE,
    pub y_chroma_offset: VideoEncodeRgbChromaOffsetFlagsVALVE,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for VideoEncodeSessionRgbConversionCreateInfoVALVE<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::VideoEncodeSessionRgbConversionCreateInfoVALVE,
            next: ptr::null_mut(),
            rgb_model: Default::default(),
            rgb_range: Default::default(),
            x_chroma_offset: Default::default(),
            y_chroma_offset: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsVideoSessionCreateInfoKHR for VideoEncodeSessionRgbConversionCreateInfoVALVE<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceShader64BitIndexingFeaturesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub shader64_bit_indexing: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceShader64BitIndexingFeaturesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceShader64BitIndexingFeaturesEXT,
            next: ptr::null_mut(),
            shader64_bit_indexing: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShader64BitIndexingFeaturesEXT<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceShader64BitIndexingFeaturesEXT<'_> {}

/// Extends: `ImageFormatProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct NativeBufferUsageOHOS<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub ohos_native_buffer_usage: u64,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for NativeBufferUsageOHOS<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::NativeBufferUsageOHOS,
            next: ptr::null_mut(),
            ohos_native_buffer_usage: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsImageFormatProperties2 for NativeBufferUsageOHOS<'_> {}

/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct NativeBufferPropertiesOHOS<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub allocation_size: DeviceSize,
    pub memory_type_bits: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for NativeBufferPropertiesOHOS<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::NativeBufferPropertiesOHOS,
            next: ptr::null_mut(),
            allocation_size: Default::default(),
            memory_type_bits: 0,
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsNativeBufferPropertiesOHOS {}
impl<'a> NativeBufferPropertiesOHOS<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsNativeBufferPropertiesOHOS>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

/// Extends: `NativeBufferPropertiesOHOS`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct NativeBufferFormatPropertiesOHOS<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub format: Format,
    pub external_format: u64,
    pub format_features: FormatFeatureFlags,
    pub sampler_ycbcr_conversion_components: ComponentMapping,
    pub suggested_ycbcr_model: SamplerYcbcrModelConversion,
    pub suggested_ycbcr_range: SamplerYcbcrRange,
    pub suggested_x_chroma_offset: ChromaLocation,
    pub suggested_y_chroma_offset: ChromaLocation,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for NativeBufferFormatPropertiesOHOS<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::NativeBufferFormatPropertiesOHOS,
            next: ptr::null_mut(),
            format: Default::default(),
            external_format: 0,
            format_features: Default::default(),
            sampler_ycbcr_conversion_components: Default::default(),
            suggested_ycbcr_model: Default::default(),
            suggested_ycbcr_range: Default::default(),
            suggested_x_chroma_offset: Default::default(),
            suggested_y_chroma_offset: Default::default(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsNativeBufferPropertiesOHOS for NativeBufferFormatPropertiesOHOS<'_> {}

/// Extends: `MemoryAllocateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ImportNativeBufferInfoOHOS<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub buffer: *mut OH_NativeBuffer,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ImportNativeBufferInfoOHOS<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ImportNativeBufferInfoOHOS,
            next: ptr::null_mut(),
            buffer: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsMemoryAllocateInfo for ImportNativeBufferInfoOHOS<'_> {}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct MemoryGetNativeBufferInfoOHOS<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub memory: DeviceMemory,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for MemoryGetNativeBufferInfoOHOS<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::MemoryGetNativeBufferInfoOHOS,
            next: ptr::null_mut(),
            memory: Default::default(),
            _marker: PhantomData,
        }
    }
}

/// Extends: `ImageCreateInfo`, `SamplerYcbcrConversionCreateInfo`, `AttachmentDescription2`, `GraphicsPipelineCreateInfo`, `CommandBufferInheritanceInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ExternalFormatOHOS<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub external_format: u64,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ExternalFormatOHOS<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ExternalFormatOHOS,
            next: ptr::null_mut(),
            external_format: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsImageCreateInfo for ExternalFormatOHOS<'_> {}
impl ExtendsSamplerYcbcrConversionCreateInfo for ExternalFormatOHOS<'_> {}
impl ExtendsAttachmentDescription2 for ExternalFormatOHOS<'_> {}
impl ExtendsGraphicsPipelineCreateInfo for ExternalFormatOHOS<'_> {}
impl ExtendsCommandBufferInheritanceInfo for ExternalFormatOHOS<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDevicePerformanceCountersByRegionFeaturesARM<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub performance_counters_by_region: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDevicePerformanceCountersByRegionFeaturesARM<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDevicePerformanceCountersByRegionFeaturesARM,
            next: ptr::null_mut(),
            performance_counters_by_region: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePerformanceCountersByRegionFeaturesARM<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDevicePerformanceCountersByRegionFeaturesARM<'_> {}

/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDevicePerformanceCountersByRegionPropertiesARM<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub max_per_region_performance_counters: u32,
    pub performance_counter_region_size: Extent2D,
    pub row_stride_alignment: u32,
    pub region_alignment: u32,
    pub identity_transform_order: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDevicePerformanceCountersByRegionPropertiesARM<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDevicePerformanceCountersByRegionPropertiesARM,
            next: ptr::null_mut(),
            max_per_region_performance_counters: 0,
            performance_counter_region_size: Default::default(),
            row_stride_alignment: 0,
            region_alignment: 0,
            identity_transform_order: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2
    for PhysicalDevicePerformanceCountersByRegionPropertiesARM<'_>
{
}

/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PerformanceCounterARM<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub counter_id: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PerformanceCounterARM<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PerformanceCounterARM,
            next: ptr::null_mut(),
            counter_id: 0,
            _marker: PhantomData,
        }
    }
}

/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PerformanceCounterDescriptionARM<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub flags: PerformanceCounterDescriptionFlagsARM,
    /// Len: null-terminated
    pub name: [c_char; MAX_DESCRIPTION_SIZE as usize],
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PerformanceCounterDescriptionARM<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PerformanceCounterDescriptionARM,
            next: ptr::null_mut(),
            flags: Default::default(),
            name: unsafe { mem::zeroed() },
            _marker: PhantomData,
        }
    }
}

/// Extends: `RenderPassBeginInfo`, `RenderingInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct RenderPassPerformanceCountersByRegionBeginInfoARM<'a> {
    pub s_type: StructureType,
    /// Pointer to next structure
    /// Nullable
    pub next: *mut c_void,
    pub counter_address_count: u32,
    pub counter_addresses: *const DeviceAddress,
    pub serialize_regions: Bool32,
    pub counter_index_count: u32,
    pub counter_indices: *mut u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for RenderPassPerformanceCountersByRegionBeginInfoARM<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::RenderPassPerformanceCountersByRegionBeginInfoARM,
            next: ptr::null_mut(),
            counter_address_count: 0,
            counter_addresses: ptr::null_mut(),
            serialize_regions: FALSE,
            counter_index_count: 0,
            counter_indices: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsRenderPassBeginInfo for RenderPassPerformanceCountersByRegionBeginInfoARM<'_> {}
impl ExtendsRenderingInfo for RenderPassPerformanceCountersByRegionBeginInfoARM<'_> {}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ComputeOccupancyPriorityParametersNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub occupancy_priority: f32,
    pub occupancy_throttling: f32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ComputeOccupancyPriorityParametersNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ComputeOccupancyPriorityParametersNV,
            next: ptr::null_mut(),
            occupancy_priority: 0.0,
            occupancy_throttling: 0.0,
            _marker: PhantomData,
        }
    }
}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceComputeOccupancyPriorityFeaturesNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub compute_occupancy_priority: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceComputeOccupancyPriorityFeaturesNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceComputeOccupancyPriorityFeaturesNV,
            next: ptr::null_mut(),
            compute_occupancy_priority: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceComputeOccupancyPriorityFeaturesNV<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceComputeOccupancyPriorityFeaturesNV<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceShaderLongVectorFeaturesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub long_vector: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceShaderLongVectorFeaturesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceShaderLongVectorFeaturesEXT,
            next: ptr::null_mut(),
            long_vector: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderLongVectorFeaturesEXT<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderLongVectorFeaturesEXT<'_> {}

/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceShaderLongVectorPropertiesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub max_vector_components: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceShaderLongVectorPropertiesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceShaderLongVectorPropertiesEXT,
            next: ptr::null_mut(),
            max_vector_components: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceShaderLongVectorPropertiesEXT<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceTextureCompressionASTC3DFeaturesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub texture_compression_astc_3d: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceTextureCompressionASTC3DFeaturesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceTextureCompressionASTC3DFeaturesEXT,
            next: ptr::null_mut(),
            texture_compression_astc_3d: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceTextureCompressionASTC3DFeaturesEXT<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceTextureCompressionASTC3DFeaturesEXT<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceShaderSubgroupPartitionedFeaturesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub shader_subgroup_partitioned: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceShaderSubgroupPartitionedFeaturesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceShaderSubgroupPartitionedFeaturesEXT,
            next: ptr::null_mut(),
            shader_subgroup_partitioned: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderSubgroupPartitionedFeaturesEXT<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderSubgroupPartitionedFeaturesEXT<'_> {}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct HostAddressRangeEXT<'a> {
    /// Len: `size`
    pub address: *mut c_void,
    pub size: usize,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for HostAddressRangeEXT<'_> {
    fn default() -> Self {
        Self {
            address: ptr::null_mut(),
            size: 0,
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct HostAddressRangeConstEXT<'a> {
    /// Len: `size`
    pub address: *const c_void,
    pub size: usize,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for HostAddressRangeConstEXT<'_> {
    fn default() -> Self {
        Self {
            address: ptr::null_mut(),
            size: 0,
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DeviceAddressRangeEXT {
    pub address: DeviceAddress,
    pub size: DeviceSize,
}
impl Default for DeviceAddressRangeEXT {
    fn default() -> Self {
        Self {
            address: Default::default(),
            size: Default::default(),
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct TexelBufferDescriptorInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub format: Format,
    pub address_range: DeviceAddressRangeEXT,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for TexelBufferDescriptorInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::TexelBufferDescriptorInfoEXT,
            next: ptr::null_mut(),
            format: Default::default(),
            address_range: Default::default(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ImageDescriptorInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub view: *const ImageViewCreateInfo<'a>,
    pub layout: ImageLayout,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ImageDescriptorInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ImageDescriptorInfoEXT,
            next: ptr::null_mut(),
            view: ptr::null_mut(),
            layout: Default::default(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub union ResourceDescriptorDataEXT<'a> {
    /// Nullable
    pub image: *const ImageDescriptorInfoEXT<'a>,
    /// Nullable
    pub texel_buffer: *const TexelBufferDescriptorInfoEXT<'a>,
    /// Nullable
    pub address_range: *const DeviceAddressRangeEXT,
    /// Nullable
    pub tensor_arm: *const TensorViewCreateInfoARM<'a>,
}
impl Default for ResourceDescriptorDataEXT<'_> {
    fn default() -> Self {
        unsafe { mem::zeroed() }
    }
}

impl fmt::Debug for ResourceDescriptorDataEXT<'_> {
    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
        fmt.debug_struct("ResourceDescriptorDataEXT").finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ResourceDescriptorInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub ty: DescriptorType,
    pub data: ResourceDescriptorDataEXT<'a>,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ResourceDescriptorInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ResourceDescriptorInfoEXT,
            next: ptr::null_mut(),
            ty: Default::default(),
            data: Default::default(),
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsResourceDescriptorInfoEXT {}
impl<'a> ResourceDescriptorInfoEXT<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsResourceDescriptorInfoEXT>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct BindHeapInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub heap_range: DeviceAddressRangeEXT,
    pub reserved_range_offset: DeviceSize,
    pub reserved_range_size: DeviceSize,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for BindHeapInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::BindHeapInfoEXT,
            next: ptr::null_mut(),
            heap_range: Default::default(),
            reserved_range_offset: Default::default(),
            reserved_range_size: Default::default(),
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PushDataInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub offset: u32,
    pub data: HostAddressRangeConstEXT<'a>,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PushDataInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PushDataInfoEXT,
            next: ptr::null_mut(),
            offset: 0,
            data: Default::default(),
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsPushDataInfoEXT {}
impl<'a> PushDataInfoEXT<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsPushDataInfoEXT>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DescriptorMappingSourceConstantOffsetEXT<'a> {
    pub heap_offset: u32,
    pub heap_array_stride: u32,
    /// Nullable
    pub embedded_sampler: *const SamplerCreateInfo<'a>,
    pub sampler_heap_offset: u32,
    pub sampler_heap_array_stride: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for DescriptorMappingSourceConstantOffsetEXT<'_> {
    fn default() -> Self {
        Self {
            heap_offset: 0,
            heap_array_stride: 0,
            embedded_sampler: ptr::null_mut(),
            sampler_heap_offset: 0,
            sampler_heap_array_stride: 0,
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DescriptorMappingSourcePushIndexEXT<'a> {
    pub heap_offset: u32,
    pub push_offset: u32,
    pub heap_index_stride: u32,
    pub heap_array_stride: u32,
    /// Nullable
    pub embedded_sampler: *const SamplerCreateInfo<'a>,
    pub use_combined_image_sampler_index: Bool32,
    pub sampler_heap_offset: u32,
    pub sampler_push_offset: u32,
    pub sampler_heap_index_stride: u32,
    pub sampler_heap_array_stride: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for DescriptorMappingSourcePushIndexEXT<'_> {
    fn default() -> Self {
        Self {
            heap_offset: 0,
            push_offset: 0,
            heap_index_stride: 0,
            heap_array_stride: 0,
            embedded_sampler: ptr::null_mut(),
            use_combined_image_sampler_index: FALSE,
            sampler_heap_offset: 0,
            sampler_push_offset: 0,
            sampler_heap_index_stride: 0,
            sampler_heap_array_stride: 0,
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DescriptorMappingSourceIndirectIndexEXT<'a> {
    pub heap_offset: u32,
    pub push_offset: u32,
    pub address_offset: u32,
    pub heap_index_stride: u32,
    pub heap_array_stride: u32,
    /// Nullable
    pub embedded_sampler: *const SamplerCreateInfo<'a>,
    pub use_combined_image_sampler_index: Bool32,
    pub sampler_heap_offset: u32,
    pub sampler_push_offset: u32,
    pub sampler_address_offset: u32,
    pub sampler_heap_index_stride: u32,
    pub sampler_heap_array_stride: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for DescriptorMappingSourceIndirectIndexEXT<'_> {
    fn default() -> Self {
        Self {
            heap_offset: 0,
            push_offset: 0,
            address_offset: 0,
            heap_index_stride: 0,
            heap_array_stride: 0,
            embedded_sampler: ptr::null_mut(),
            use_combined_image_sampler_index: FALSE,
            sampler_heap_offset: 0,
            sampler_push_offset: 0,
            sampler_address_offset: 0,
            sampler_heap_index_stride: 0,
            sampler_heap_array_stride: 0,
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DescriptorMappingSourceIndirectIndexArrayEXT<'a> {
    pub heap_offset: u32,
    pub push_offset: u32,
    pub address_offset: u32,
    pub heap_index_stride: u32,
    /// Nullable
    pub embedded_sampler: *const SamplerCreateInfo<'a>,
    pub use_combined_image_sampler_index: Bool32,
    pub sampler_heap_offset: u32,
    pub sampler_push_offset: u32,
    pub sampler_address_offset: u32,
    pub sampler_heap_index_stride: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for DescriptorMappingSourceIndirectIndexArrayEXT<'_> {
    fn default() -> Self {
        Self {
            heap_offset: 0,
            push_offset: 0,
            address_offset: 0,
            heap_index_stride: 0,
            embedded_sampler: ptr::null_mut(),
            use_combined_image_sampler_index: FALSE,
            sampler_heap_offset: 0,
            sampler_push_offset: 0,
            sampler_address_offset: 0,
            sampler_heap_index_stride: 0,
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DescriptorMappingSourceHeapDataEXT {
    pub heap_offset: u32,
    pub push_offset: u32,
}
impl Default for DescriptorMappingSourceHeapDataEXT {
    fn default() -> Self {
        Self {
            heap_offset: 0,
            push_offset: 0,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DescriptorMappingSourceShaderRecordIndexEXT<'a> {
    pub heap_offset: u32,
    pub shader_record_offset: u32,
    pub heap_index_stride: u32,
    pub heap_array_stride: u32,
    /// Nullable
    pub embedded_sampler: *const SamplerCreateInfo<'a>,
    pub use_combined_image_sampler_index: Bool32,
    pub sampler_heap_offset: u32,
    pub sampler_shader_record_offset: u32,
    pub sampler_heap_index_stride: u32,
    pub sampler_heap_array_stride: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for DescriptorMappingSourceShaderRecordIndexEXT<'_> {
    fn default() -> Self {
        Self {
            heap_offset: 0,
            shader_record_offset: 0,
            heap_index_stride: 0,
            heap_array_stride: 0,
            embedded_sampler: ptr::null_mut(),
            use_combined_image_sampler_index: FALSE,
            sampler_heap_offset: 0,
            sampler_shader_record_offset: 0,
            sampler_heap_index_stride: 0,
            sampler_heap_array_stride: 0,
            _marker: PhantomData,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DescriptorMappingSourceIndirectAddressEXT {
    pub push_offset: u32,
    pub address_offset: u32,
}
impl Default for DescriptorMappingSourceIndirectAddressEXT {
    fn default() -> Self {
        Self {
            push_offset: 0,
            address_offset: 0,
        }
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub union DescriptorMappingSourceDataEXT<'a> {
    pub constant_offset: DescriptorMappingSourceConstantOffsetEXT<'a>,
    pub push_index: DescriptorMappingSourcePushIndexEXT<'a>,
    pub indirect_index: DescriptorMappingSourceIndirectIndexEXT<'a>,
    pub indirect_index_array: DescriptorMappingSourceIndirectIndexArrayEXT<'a>,
    pub heap_data: DescriptorMappingSourceHeapDataEXT,
    pub push_data_offset: u32,
    pub push_address_offset: u32,
    pub indirect_address: DescriptorMappingSourceIndirectAddressEXT,
    pub shader_record_index: DescriptorMappingSourceShaderRecordIndexEXT<'a>,
    pub shader_record_data_offset: u32,
    pub shader_record_address_offset: u32,
}
impl Default for DescriptorMappingSourceDataEXT<'_> {
    fn default() -> Self {
        unsafe { mem::zeroed() }
    }
}

impl fmt::Debug for DescriptorMappingSourceDataEXT<'_> {
    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
        fmt.debug_struct("DescriptorMappingSourceDataEXT").finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DescriptorSetAndBindingMappingEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub descriptor_set: u32,
    pub first_binding: u32,
    pub binding_count: u32,
    pub resource_mask: SpirvResourceTypeFlagsEXT,
    pub source: DescriptorMappingSourceEXT,
    pub source_data: DescriptorMappingSourceDataEXT<'a>,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for DescriptorSetAndBindingMappingEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::DescriptorSetAndBindingMappingEXT,
            next: ptr::null_mut(),
            descriptor_set: 0,
            first_binding: 0,
            binding_count: 0,
            resource_mask: Default::default(),
            source: Default::default(),
            source_data: Default::default(),
            _marker: PhantomData,
        }
    }
}

pub trait ExtendsDescriptorSetAndBindingMappingEXT {}
impl<'a> DescriptorSetAndBindingMappingEXT<'a> {
    /// Prepends the given extension struct between the root and the first pointer.
    /// If the chain looks like `A -> B -> C`, and you call `x.next(&mut D)`,
    /// then the chain will look like `A -> D -> B -> C`.
    #[inline]
    pub fn next<T: ExtendsDescriptorSetAndBindingMappingEXT>(mut self, next: &'a mut T) -> Self {
        unsafe {
            let next_base: *mut BaseOutStructure = ptr::from_mut(next).cast();

            debug_assert!(
                (*next_base).next.is_null(),
                "next of inserted struct must be null (already in a chain?)"
            );

            (*next_base).next = self.next as _;
            self.next = ptr::from_mut(next).cast();
        }

        self
    }
}

/// Extends: `PipelineShaderStageCreateInfo`, `ShaderCreateInfoEXT`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct ShaderDescriptorSetAndBindingMappingInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub mapping_count: u32,
    /// Len: `mapping_count`
    pub mappings: *const DescriptorSetAndBindingMappingEXT<'a>,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for ShaderDescriptorSetAndBindingMappingInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::ShaderDescriptorSetAndBindingMappingInfoEXT,
            next: ptr::null_mut(),
            mapping_count: 0,
            mappings: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsPipelineShaderStageCreateInfo for ShaderDescriptorSetAndBindingMappingInfoEXT<'_> {}
impl ExtendsShaderCreateInfoEXT for ShaderDescriptorSetAndBindingMappingInfoEXT<'_> {}

/// Extends: `SamplerCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct SamplerCustomBorderColorIndexCreateInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub index: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for SamplerCustomBorderColorIndexCreateInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::SamplerCustomBorderColorIndexCreateInfoEXT,
            next: ptr::null_mut(),
            index: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsSamplerCreateInfo for SamplerCustomBorderColorIndexCreateInfoEXT<'_> {}

/// Extends: `ImageCreateInfo`, `TensorCreateInfoARM`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct OpaqueCaptureDataCreateInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    /// Nullable
    pub data: *const HostAddressRangeConstEXT<'a>,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for OpaqueCaptureDataCreateInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::OpaqueCaptureDataCreateInfoEXT,
            next: ptr::null_mut(),
            data: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsImageCreateInfo for OpaqueCaptureDataCreateInfoEXT<'_> {}
impl ExtendsTensorCreateInfoARM for OpaqueCaptureDataCreateInfoEXT<'_> {}

/// Extends: `IndirectCommandsLayoutTokenNV`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct IndirectCommandsLayoutPushDataTokenNV<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub push_data_offset: u32,
    pub push_data_size: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for IndirectCommandsLayoutPushDataTokenNV<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::IndirectCommandsLayoutPushDataTokenNV,
            next: ptr::null_mut(),
            push_data_offset: 0,
            push_data_size: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsIndirectCommandsLayoutTokenNV for IndirectCommandsLayoutPushDataTokenNV<'_> {}

/// Extends: `ImageFormatProperties2`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct SubsampledImageFormatPropertiesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    pub subsampled_image_descriptor_count: u32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for SubsampledImageFormatPropertiesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::SubsampledImageFormatPropertiesEXT,
            next: ptr::null_mut(),
            subsampled_image_descriptor_count: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsImageFormatProperties2 for SubsampledImageFormatPropertiesEXT<'_> {}

/// Extends: `PhysicalDeviceFeatures2`, `DeviceCreateInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceDescriptorHeapFeaturesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub descriptor_heap: Bool32,
    pub descriptor_heap_capture_replay: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceDescriptorHeapFeaturesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceDescriptorHeapFeaturesEXT,
            next: ptr::null_mut(),
            descriptor_heap: FALSE,
            descriptor_heap_capture_replay: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDescriptorHeapFeaturesEXT<'_> {}
impl ExtendsDeviceCreateInfo for PhysicalDeviceDescriptorHeapFeaturesEXT<'_> {}

/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceDescriptorHeapPropertiesEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub sampler_heap_alignment: DeviceSize,
    pub resource_heap_alignment: DeviceSize,
    pub max_sampler_heap_size: DeviceSize,
    pub max_resource_heap_size: DeviceSize,
    pub min_sampler_heap_reserved_range: DeviceSize,
    pub min_sampler_heap_reserved_range_with_embedded: DeviceSize,
    pub min_resource_heap_reserved_range: DeviceSize,
    pub sampler_descriptor_size: DeviceSize,
    pub image_descriptor_size: DeviceSize,
    pub buffer_descriptor_size: DeviceSize,
    pub sampler_descriptor_alignment: DeviceSize,
    pub image_descriptor_alignment: DeviceSize,
    pub buffer_descriptor_alignment: DeviceSize,
    pub max_push_data_size: DeviceSize,
    pub image_capture_replay_opaque_data_size: usize,
    pub max_descriptor_heap_embedded_samplers: u32,
    pub sampler_ycbcr_conversion_count: u32,
    pub sparse_descriptor_heaps: Bool32,
    pub protected_descriptor_heaps: Bool32,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceDescriptorHeapPropertiesEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceDescriptorHeapPropertiesEXT,
            next: ptr::null_mut(),
            sampler_heap_alignment: Default::default(),
            resource_heap_alignment: Default::default(),
            max_sampler_heap_size: Default::default(),
            max_resource_heap_size: Default::default(),
            min_sampler_heap_reserved_range: Default::default(),
            min_sampler_heap_reserved_range_with_embedded: Default::default(),
            min_resource_heap_reserved_range: Default::default(),
            sampler_descriptor_size: Default::default(),
            image_descriptor_size: Default::default(),
            buffer_descriptor_size: Default::default(),
            sampler_descriptor_alignment: Default::default(),
            image_descriptor_alignment: Default::default(),
            buffer_descriptor_alignment: Default::default(),
            max_push_data_size: Default::default(),
            image_capture_replay_opaque_data_size: 0,
            max_descriptor_heap_embedded_samplers: 0,
            sampler_ycbcr_conversion_count: 0,
            sparse_descriptor_heaps: FALSE,
            protected_descriptor_heaps: FALSE,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDescriptorHeapPropertiesEXT<'_> {}

/// Extends: `CommandBufferInheritanceInfo`
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct CommandBufferInheritanceDescriptorHeapInfoEXT<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *const c_void,
    /// Nullable
    pub sampler_heap_bind_info: *const BindHeapInfoEXT<'a>,
    /// Nullable
    pub resource_heap_bind_info: *const BindHeapInfoEXT<'a>,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for CommandBufferInheritanceDescriptorHeapInfoEXT<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::CommandBufferInheritanceDescriptorHeapInfoEXT,
            next: ptr::null_mut(),
            sampler_heap_bind_info: ptr::null_mut(),
            resource_heap_bind_info: ptr::null_mut(),
            _marker: PhantomData,
        }
    }
}

impl ExtendsCommandBufferInheritanceInfo for CommandBufferInheritanceDescriptorHeapInfoEXT<'_> {}

/// Extends: `PhysicalDeviceProperties2`
/// returned_only
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct PhysicalDeviceDescriptorHeapTensorPropertiesARM<'a> {
    pub s_type: StructureType,
    /// Nullable
    pub next: *mut c_void,
    pub tensor_descriptor_size: DeviceSize,
    pub tensor_descriptor_alignment: DeviceSize,
    pub tensor_capture_replay_opaque_data_size: usize,
    pub _marker: PhantomData<&'a ()>,
}
impl Default for PhysicalDeviceDescriptorHeapTensorPropertiesARM<'_> {
    fn default() -> Self {
        Self {
            s_type: StructureType::PhysicalDeviceDescriptorHeapTensorPropertiesARM,
            next: ptr::null_mut(),
            tensor_descriptor_size: Default::default(),
            tensor_descriptor_alignment: Default::default(),
            tensor_capture_replay_opaque_data_size: 0,
            _marker: PhantomData,
        }
    }
}

impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDescriptorHeapTensorPropertiesARM<'_> {}
