// generated file, do not modify manually

use crate::ffi::*;
use crate::*;

/// `VK_MAX_PHYSICAL_DEVICE_NAME_SIZE` = `256`
pub const VK_MAX_PHYSICAL_DEVICE_NAME_SIZE: uint32_t = 256;

/// `VK_UUID_SIZE` = `16`
pub const VK_UUID_SIZE: uint32_t = 16;

/// `VK_LUID_SIZE` = `8`
pub const VK_LUID_SIZE: uint32_t = 8;

/// `VK_MAX_EXTENSION_NAME_SIZE` = `256`
pub const VK_MAX_EXTENSION_NAME_SIZE: uint32_t = 256;

/// `VK_MAX_DESCRIPTION_SIZE` = `256`
pub const VK_MAX_DESCRIPTION_SIZE: uint32_t = 256;

/// `VK_MAX_MEMORY_TYPES` = `32`
pub const VK_MAX_MEMORY_TYPES: uint32_t = 32;

/// `VK_MAX_MEMORY_HEAPS` = `16`
/// 
/// The maximum number of unique memory heaps, each of which supporting 1 or more memory types
pub const VK_MAX_MEMORY_HEAPS: uint32_t = 16;

/// `VK_LOD_CLAMP_NONE` = `1000.0F`
pub const VK_LOD_CLAMP_NONE: float = 1000.0f32;

/// `VK_REMAINING_MIP_LEVELS` = `(~0U)`
pub const VK_REMAINING_MIP_LEVELS: uint32_t = (!0u32);

/// `VK_REMAINING_ARRAY_LAYERS` = `(~0U)`
pub const VK_REMAINING_ARRAY_LAYERS: uint32_t = (!0u32);

/// `VK_REMAINING_3D_SLICES_EXT` = `(~0U)`
pub const VK_REMAINING_3D_SLICES_EXT: uint32_t = (!0u32);

/// `VK_WHOLE_SIZE` = `(~0ULL)`
pub const VK_WHOLE_SIZE: uint64_t = (!0u64);

/// `VK_ATTACHMENT_UNUSED` = `(~0U)`
pub const VK_ATTACHMENT_UNUSED: uint32_t = (!0u32);

/// `VK_TRUE` = `1`
pub const VK_TRUE: uint32_t = 1;

/// `VK_FALSE` = `0`
pub const VK_FALSE: uint32_t = 0;

/// `VK_QUEUE_FAMILY_IGNORED` = `(~0U)`
pub const VK_QUEUE_FAMILY_IGNORED: uint32_t = (!0u32);

/// `VK_QUEUE_FAMILY_EXTERNAL` = `(~1U)`
pub const VK_QUEUE_FAMILY_EXTERNAL: uint32_t = (!1u32);

/// `VK_QUEUE_FAMILY_FOREIGN_EXT` = `(~2U)`
pub const VK_QUEUE_FAMILY_FOREIGN_EXT: uint32_t = (!2u32);

/// `VK_SUBPASS_EXTERNAL` = `(~0U)`
pub const VK_SUBPASS_EXTERNAL: uint32_t = (!0u32);

/// `VK_MAX_DEVICE_GROUP_SIZE` = `32`
pub const VK_MAX_DEVICE_GROUP_SIZE: uint32_t = 32;

/// `VK_MAX_DRIVER_NAME_SIZE` = `256`
pub const VK_MAX_DRIVER_NAME_SIZE: uint32_t = 256;

/// `VK_MAX_DRIVER_INFO_SIZE` = `256`
pub const VK_MAX_DRIVER_INFO_SIZE: uint32_t = 256;

/// `VK_SHADER_UNUSED_KHR` = `(~0U)`
pub const VK_SHADER_UNUSED_KHR: uint32_t = (!0u32);

/// `VK_MAX_GLOBAL_PRIORITY_SIZE` = `16`
pub const VK_MAX_GLOBAL_PRIORITY_SIZE: uint32_t = 16;

/// `VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT` = `32`
pub const VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT: uint32_t = 32;

/// `VK_MAX_PIPELINE_BINARY_KEY_SIZE_KHR` = `32`
pub const VK_MAX_PIPELINE_BINARY_KEY_SIZE_KHR: uint32_t = 32;

/// `VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR` = `7`
pub const VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR: uint32_t = 7;

/// `VK_MAX_VIDEO_VP9_REFERENCES_PER_FRAME_KHR` = `3`
pub const VK_MAX_VIDEO_VP9_REFERENCES_PER_FRAME_KHR: uint32_t = 3;

/// `VK_SHADER_INDEX_UNUSED_AMDX` = `(~0U)`
pub const VK_SHADER_INDEX_UNUSED_AMDX: uint32_t = (!0u32);

/// `VK_PARTITIONED_ACCELERATION_STRUCTURE_PARTITION_INDEX_GLOBAL_NV` = `(~0U)`
pub const VK_PARTITIONED_ACCELERATION_STRUCTURE_PARTITION_INDEX_GLOBAL_NV: uint32_t = (!0u32);

/// `VK_COMPRESSED_TRIANGLE_FORMAT_DGF1_BYTE_ALIGNMENT_AMDX` = `128`
pub const VK_COMPRESSED_TRIANGLE_FORMAT_DGF1_BYTE_ALIGNMENT_AMDX: uint32_t = 128;

/// `VK_COMPRESSED_TRIANGLE_FORMAT_DGF1_BYTE_STRIDE_AMDX` = `128`
pub const VK_COMPRESSED_TRIANGLE_FORMAT_DGF1_BYTE_STRIDE_AMDX: uint32_t = 128;

/// `VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM` = `128`
pub const VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM: uint32_t = 128;

/// `VK_DATA_GRAPH_MODEL_TOOLCHAIN_VERSION_LENGTH_QCOM` = `3`
pub const VK_DATA_GRAPH_MODEL_TOOLCHAIN_VERSION_LENGTH_QCOM: uint32_t = 3;

/// `VK_COMPUTE_OCCUPANCY_PRIORITY_LOW_NV` = `0.25f`
pub const VK_COMPUTE_OCCUPANCY_PRIORITY_LOW_NV: float = 0.25f32;

/// `VK_COMPUTE_OCCUPANCY_PRIORITY_NORMAL_NV` = `0.50f`
pub const VK_COMPUTE_OCCUPANCY_PRIORITY_NORMAL_NV: float = 0.50f32;

/// `VK_COMPUTE_OCCUPANCY_PRIORITY_HIGH_NV` = `0.75f`
pub const VK_COMPUTE_OCCUPANCY_PRIORITY_HIGH_NV: float = 0.75f32;

/// `PFN_vkAllocationFunction`
pub type PFN_vkAllocationFunction = Option<FN_vkAllocationFunction>;

/// `PFN_vkAllocationFunction`
pub type FN_vkAllocationFunction = unsafe extern "system" fn(pUserData: *mut void, size: size_t, alignment: size_t, allocationScope: VkSystemAllocationScope) -> *mut void;

/// `PFN_vkDebugReportCallbackEXT`
pub type PFN_vkDebugReportCallbackEXT = Option<FN_vkDebugReportCallbackEXT>;

/// `PFN_vkDebugReportCallbackEXT`
pub type FN_vkDebugReportCallbackEXT = unsafe extern "system" fn(flags: VkDebugReportFlagsEXT, objectType: VkDebugReportObjectTypeEXT, object: uint64_t, location: size_t, messageCode: int32_t, pLayerPrefix: *const c_char, pMessage: *const c_char, pUserData: *mut void) -> VkBool32;

/// `PFN_vkDebugUtilsMessengerCallbackEXT`
pub type PFN_vkDebugUtilsMessengerCallbackEXT = Option<FN_vkDebugUtilsMessengerCallbackEXT>;

/// `PFN_vkDebugUtilsMessengerCallbackEXT`
pub type FN_vkDebugUtilsMessengerCallbackEXT = unsafe extern "system" fn(messageSeverity: VkDebugUtilsMessageSeverityFlagsEXT, messageTypes: VkDebugUtilsMessageTypeFlagsEXT, pCallbackData: *const VkDebugUtilsMessengerCallbackDataEXT, pUserData: *mut void) -> VkBool32;

/// `PFN_vkDeviceMemoryReportCallbackEXT`
pub type PFN_vkDeviceMemoryReportCallbackEXT = Option<FN_vkDeviceMemoryReportCallbackEXT>;

/// `PFN_vkDeviceMemoryReportCallbackEXT`
pub type FN_vkDeviceMemoryReportCallbackEXT = unsafe extern "system" fn(pCallbackData: *const VkDeviceMemoryReportCallbackDataEXT, pUserData: *mut void) -> ();

/// `PFN_vkFaultCallbackFunction`
pub type PFN_vkFaultCallbackFunction = Option<FN_vkFaultCallbackFunction>;

/// `PFN_vkFaultCallbackFunction`
pub type FN_vkFaultCallbackFunction = unsafe extern "system" fn(unrecordedFaults: VkBool32, faultCount: uint32_t, pFaults: *const VkFaultData) -> ();

/// `PFN_vkFreeFunction`
pub type PFN_vkFreeFunction = Option<FN_vkFreeFunction>;

/// `PFN_vkFreeFunction`
pub type FN_vkFreeFunction = unsafe extern "system" fn(pUserData: *mut void, pMemory: *mut void) -> ();

/// `PFN_vkGetInstanceProcAddrLUNARG`
pub type PFN_vkGetInstanceProcAddrLUNARG = Option<FN_vkGetInstanceProcAddrLUNARG>;

/// `PFN_vkGetInstanceProcAddrLUNARG`
pub type FN_vkGetInstanceProcAddrLUNARG = unsafe extern "system" fn(instance: VkInstance, pName: *const c_char) -> PFN_vkVoidFunction;

/// `PFN_vkInternalAllocationNotification`
pub type PFN_vkInternalAllocationNotification = Option<FN_vkInternalAllocationNotification>;

/// `PFN_vkInternalAllocationNotification`
pub type FN_vkInternalAllocationNotification = unsafe extern "system" fn(pUserData: *mut void, size: size_t, allocationType: VkInternalAllocationType, allocationScope: VkSystemAllocationScope) -> ();

/// `PFN_vkInternalFreeNotification`
pub type PFN_vkInternalFreeNotification = Option<FN_vkInternalFreeNotification>;

/// `PFN_vkInternalFreeNotification`
pub type FN_vkInternalFreeNotification = unsafe extern "system" fn(pUserData: *mut void, size: size_t, allocationType: VkInternalAllocationType, allocationScope: VkSystemAllocationScope) -> ();

/// `PFN_vkReallocationFunction`
pub type PFN_vkReallocationFunction = Option<FN_vkReallocationFunction>;

/// `PFN_vkReallocationFunction`
pub type FN_vkReallocationFunction = unsafe extern "system" fn(pUserData: *mut void, pOriginal: *mut void, size: size_t, alignment: size_t, allocationScope: VkSystemAllocationScope) -> *mut void;

/// `PFN_vkVoidFunction`
pub type PFN_vkVoidFunction = Option<FN_vkVoidFunction>;

/// `PFN_vkVoidFunction`
pub type FN_vkVoidFunction = unsafe extern "system" fn() -> ();

/// `VkAabbPositionsKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkAabbPositionsKHR {
    pub minX: float,
    pub minY: float,
    pub minZ: float,
    pub maxX: float,
    pub maxY: float,
    pub maxZ: float,
}
impl_default_zeroed!(VkAabbPositionsKHR);

/// `VkAabbPositionsKHR`
pub type VkAabbPositionsNV = VkAabbPositionsKHR;

/// `VkAccelerationStructureBuildGeometryInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkAccelerationStructureBuildGeometryInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub r#type: VkAccelerationStructureTypeKHR,
    pub flags: VkBuildAccelerationStructureFlagsKHR,
    pub mode: VkBuildAccelerationStructureModeKHR,
    pub srcAccelerationStructure: VkAccelerationStructureKHR,
    pub dstAccelerationStructure: VkAccelerationStructureKHR,
    pub geometryCount: uint32_t,
    pub pGeometries: *const VkAccelerationStructureGeometryKHR,
    pub ppGeometries: *const *const VkAccelerationStructureGeometryKHR,
    pub scratchData: VkDeviceOrHostAddressKHR,
}
impl_default_zeroed_with_s_type!(VkAccelerationStructureBuildGeometryInfoKHR : VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR);

/// `VkAccelerationStructureBuildRangeInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkAccelerationStructureBuildRangeInfoKHR {
    pub primitiveCount: uint32_t,
    pub primitiveOffset: uint32_t,
    pub firstVertex: uint32_t,
    pub transformOffset: uint32_t,
}
impl_default_zeroed!(VkAccelerationStructureBuildRangeInfoKHR);

/// `VkAccelerationStructureBuildSizesInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkAccelerationStructureBuildSizesInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub accelerationStructureSize: VkDeviceSize,
    pub updateScratchSize: VkDeviceSize,
    pub buildScratchSize: VkDeviceSize,
}
impl_default_zeroed_with_s_type!(VkAccelerationStructureBuildSizesInfoKHR : VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR);

from_into_transparent!(VkAccelerationStructureBuildTypeKHR: i32);
/// `VkAccelerationStructureBuildTypeKHR`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkAccelerationStructureBuildTypeKHR(pub i32);

/// `0`  
pub const VK_ACCELERATION_STRUCTURE_BUILD_TYPE_HOST_KHR: VkAccelerationStructureBuildTypeKHR = VkAccelerationStructureBuildTypeKHR(0);
/// `1`  
pub const VK_ACCELERATION_STRUCTURE_BUILD_TYPE_DEVICE_KHR: VkAccelerationStructureBuildTypeKHR = VkAccelerationStructureBuildTypeKHR(1);
/// `2`  
pub const VK_ACCELERATION_STRUCTURE_BUILD_TYPE_HOST_OR_DEVICE_KHR: VkAccelerationStructureBuildTypeKHR = VkAccelerationStructureBuildTypeKHR(2);

impl_enum_display!(VkAccelerationStructureBuildTypeKHR { VK_ACCELERATION_STRUCTURE_BUILD_TYPE_HOST_KHR, VK_ACCELERATION_STRUCTURE_BUILD_TYPE_DEVICE_KHR, VK_ACCELERATION_STRUCTURE_BUILD_TYPE_HOST_OR_DEVICE_KHR });

/// `VkAccelerationStructureCaptureDescriptorDataInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkAccelerationStructureCaptureDescriptorDataInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub accelerationStructure: VkAccelerationStructureKHR,
    pub accelerationStructureNV: VkAccelerationStructureNV,
}
impl_default_zeroed_with_s_type!(VkAccelerationStructureCaptureDescriptorDataInfoEXT : VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT);

from_into_transparent!(VkAccelerationStructureCompatibilityKHR: i32);
/// `VkAccelerationStructureCompatibilityKHR`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkAccelerationStructureCompatibilityKHR(pub i32);

/// `0`  
pub const VK_ACCELERATION_STRUCTURE_COMPATIBILITY_COMPATIBLE_KHR: VkAccelerationStructureCompatibilityKHR = VkAccelerationStructureCompatibilityKHR(0);
/// `1`  
pub const VK_ACCELERATION_STRUCTURE_COMPATIBILITY_INCOMPATIBLE_KHR: VkAccelerationStructureCompatibilityKHR = VkAccelerationStructureCompatibilityKHR(1);

impl_enum_display!(VkAccelerationStructureCompatibilityKHR { VK_ACCELERATION_STRUCTURE_COMPATIBILITY_COMPATIBLE_KHR, VK_ACCELERATION_STRUCTURE_COMPATIBILITY_INCOMPATIBLE_KHR });

flags!(VkAccelerationStructureCreateFlagsKHR);
from_into_transparent!(VkAccelerationStructureCreateFlagsKHR: i32);
/// `VkAccelerationStructureCreateFlagsKHR`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkAccelerationStructureCreateFlagsKHR(pub i32);

/// `1 << 0`  
pub const VK_ACCELERATION_STRUCTURE_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR: VkAccelerationStructureCreateFlagsKHR = VkAccelerationStructureCreateFlagsKHR(1 << 0);
/// `1 << 3`  
pub const VK_ACCELERATION_STRUCTURE_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT: VkAccelerationStructureCreateFlagsKHR = VkAccelerationStructureCreateFlagsKHR(1 << 3);
/// `1 << 2`  
pub const VK_ACCELERATION_STRUCTURE_CREATE_MOTION_BIT_NV: VkAccelerationStructureCreateFlagsKHR = VkAccelerationStructureCreateFlagsKHR(1 << 2);

impl_flags_display!(VkAccelerationStructureCreateFlagsKHR { VK_ACCELERATION_STRUCTURE_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR, VK_ACCELERATION_STRUCTURE_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT, VK_ACCELERATION_STRUCTURE_CREATE_MOTION_BIT_NV });

/// `VkAccelerationStructureCreateInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkAccelerationStructureCreateInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub createFlags: VkAccelerationStructureCreateFlagsKHR,
    pub buffer: VkBuffer,
    /// Specified in bytes
    pub offset: VkDeviceSize,
    pub size: VkDeviceSize,
    pub r#type: VkAccelerationStructureTypeKHR,
    pub deviceAddress: VkDeviceAddress,
}
impl_default_zeroed_with_s_type!(VkAccelerationStructureCreateInfoKHR : VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_KHR);

/// `VkAccelerationStructureCreateInfoNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkAccelerationStructureCreateInfoNV {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub compactedSize: VkDeviceSize,
    pub info: VkAccelerationStructureInfoNV,
}
impl_default_zeroed_with_s_type!(VkAccelerationStructureCreateInfoNV : VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_NV);

/// `VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub compressedData: VkDeviceOrHostAddressConstKHR,
    pub dataSize: VkDeviceSize,
    pub numTriangles: uint32_t,
    pub numVertices: uint32_t,
    pub maxPrimitiveIndex: uint32_t,
    pub maxGeometryIndex: uint32_t,
    pub format: VkCompressedTriangleFormatAMDX,
}
impl_default_zeroed_with_s_type!(VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX : VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DENSE_GEOMETRY_FORMAT_TRIANGLES_DATA_AMDX);
impl_extends!(VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX : VkAccelerationStructureGeometryKHR);

/// `VkAccelerationStructureDeviceAddressInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkAccelerationStructureDeviceAddressInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub accelerationStructure: VkAccelerationStructureKHR,
}
impl_default_zeroed_with_s_type!(VkAccelerationStructureDeviceAddressInfoKHR : VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR);

/// `VkAccelerationStructureGeometryAabbsDataKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkAccelerationStructureGeometryAabbsDataKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub data: VkDeviceOrHostAddressConstKHR,
    pub stride: VkDeviceSize,
}
impl_default_zeroed_with_s_type!(VkAccelerationStructureGeometryAabbsDataKHR : VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR);

/// `VkAccelerationStructureGeometryDataKHR`
#[repr(C)]
#[derive(Clone, Copy)]
pub union VkAccelerationStructureGeometryDataKHR {
    pub triangles: VkAccelerationStructureGeometryTrianglesDataKHR,
    pub aabbs: VkAccelerationStructureGeometryAabbsDataKHR,
    pub instances: VkAccelerationStructureGeometryInstancesDataKHR,
}
impl_debug_for_union!(VkAccelerationStructureGeometryDataKHR);
impl_default_zeroed!(VkAccelerationStructureGeometryDataKHR);

/// `VkAccelerationStructureGeometryInstancesDataKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkAccelerationStructureGeometryInstancesDataKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub arrayOfPointers: VkBool32,
    pub data: VkDeviceOrHostAddressConstKHR,
}
impl_default_zeroed_with_s_type!(VkAccelerationStructureGeometryInstancesDataKHR : VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR);

/// `VkAccelerationStructureGeometryKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkAccelerationStructureGeometryKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub geometryType: VkGeometryTypeKHR,
    pub geometry: VkAccelerationStructureGeometryDataKHR,
    pub flags: VkGeometryFlagsKHR,
}
impl_default_zeroed_with_s_type!(VkAccelerationStructureGeometryKHR : VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_KHR);

/// `VkAccelerationStructureGeometryLinearSweptSpheresDataNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkAccelerationStructureGeometryLinearSweptSpheresDataNV {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub vertexFormat: VkFormat,
    pub vertexData: VkDeviceOrHostAddressConstKHR,
    pub vertexStride: VkDeviceSize,
    pub radiusFormat: VkFormat,
    pub radiusData: VkDeviceOrHostAddressConstKHR,
    pub radiusStride: VkDeviceSize,
    pub indexType: VkIndexType,
    pub indexData: VkDeviceOrHostAddressConstKHR,
    pub indexStride: VkDeviceSize,
    pub indexingMode: VkRayTracingLssIndexingModeNV,
    pub endCapsMode: VkRayTracingLssPrimitiveEndCapsModeNV,
}
impl_default_zeroed_with_s_type!(VkAccelerationStructureGeometryLinearSweptSpheresDataNV : VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_LINEAR_SWEPT_SPHERES_DATA_NV);
impl_extends!(VkAccelerationStructureGeometryLinearSweptSpheresDataNV : VkAccelerationStructureGeometryKHR);

/// `VkAccelerationStructureGeometryMotionTrianglesDataNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkAccelerationStructureGeometryMotionTrianglesDataNV {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub vertexData: VkDeviceOrHostAddressConstKHR,
}
impl_default_zeroed_with_s_type!(VkAccelerationStructureGeometryMotionTrianglesDataNV : VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV);
impl_extends!(VkAccelerationStructureGeometryMotionTrianglesDataNV : VkAccelerationStructureGeometryTrianglesDataKHR);

/// `VkAccelerationStructureGeometrySpheresDataNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkAccelerationStructureGeometrySpheresDataNV {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub vertexFormat: VkFormat,
    pub vertexData: VkDeviceOrHostAddressConstKHR,
    pub vertexStride: VkDeviceSize,
    pub radiusFormat: VkFormat,
    pub radiusData: VkDeviceOrHostAddressConstKHR,
    pub radiusStride: VkDeviceSize,
    pub indexType: VkIndexType,
    pub indexData: VkDeviceOrHostAddressConstKHR,
    pub indexStride: VkDeviceSize,
}
impl_default_zeroed_with_s_type!(VkAccelerationStructureGeometrySpheresDataNV : VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_SPHERES_DATA_NV);
impl_extends!(VkAccelerationStructureGeometrySpheresDataNV : VkAccelerationStructureGeometryKHR);

/// `VkAccelerationStructureGeometryTrianglesDataKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkAccelerationStructureGeometryTrianglesDataKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub vertexFormat: VkFormat,
    pub vertexData: VkDeviceOrHostAddressConstKHR,
    pub vertexStride: VkDeviceSize,
    pub maxVertex: uint32_t,
    pub indexType: VkIndexType,
    pub indexData: VkDeviceOrHostAddressConstKHR,
    pub transformData: VkDeviceOrHostAddressConstKHR,
}
impl_default_zeroed_with_s_type!(VkAccelerationStructureGeometryTrianglesDataKHR : VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR);

/// `VkAccelerationStructureInfoNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkAccelerationStructureInfoNV {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub r#type: VkAccelerationStructureTypeNV,
    pub flags: VkBuildAccelerationStructureFlagsNV,
    pub instanceCount: uint32_t,
    pub geometryCount: uint32_t,
    pub pGeometries: *const VkGeometryNV,
}
impl_default_zeroed_with_s_type!(VkAccelerationStructureInfoNV : VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_INFO_NV);

/// `VkAccelerationStructureInstanceKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkAccelerationStructureInstanceKHR {
    pub transform: VkTransformMatrixKHR,
    pub instanceCustomIndex: uint32_t,
    pub mask: uint32_t,
    pub instanceShaderBindingTableRecordOffset: uint32_t,
    pub flags: VkGeometryInstanceFlagsKHR,
    pub accelerationStructureReference: uint64_t,
}
impl_default_zeroed!(VkAccelerationStructureInstanceKHR);

/// `VkAccelerationStructureInstanceKHR`
pub type VkAccelerationStructureInstanceNV = VkAccelerationStructureInstanceKHR;

/// `VkAccelerationStructureKHR` : `VkDevice`
#[repr(transparent)]
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkAccelerationStructureKHR(pub u64);
from_into_transparent!(VkAccelerationStructureKHR: u64);
impl_handle!(VkAccelerationStructureKHR: VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR; SubHandle = VkDevice);

/// `VkAccelerationStructureMatrixMotionInstanceNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkAccelerationStructureMatrixMotionInstanceNV {
    pub transformT0: VkTransformMatrixKHR,
    pub transformT1: VkTransformMatrixKHR,
    pub instanceCustomIndex: uint32_t,
    pub mask: uint32_t,
    pub instanceShaderBindingTableRecordOffset: uint32_t,
    pub flags: VkGeometryInstanceFlagsKHR,
    pub accelerationStructureReference: uint64_t,
}
impl_default_zeroed!(VkAccelerationStructureMatrixMotionInstanceNV);

/// `VkAccelerationStructureMemoryRequirementsInfoNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkAccelerationStructureMemoryRequirementsInfoNV {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub r#type: VkAccelerationStructureMemoryRequirementsTypeNV,
    pub accelerationStructure: VkAccelerationStructureNV,
}
impl_default_zeroed_with_s_type!(VkAccelerationStructureMemoryRequirementsInfoNV : VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV);

from_into_transparent!(VkAccelerationStructureMemoryRequirementsTypeNV: i32);
/// `VkAccelerationStructureMemoryRequirementsTypeNV`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkAccelerationStructureMemoryRequirementsTypeNV(pub i32);

/// `0`  
pub const VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_OBJECT_NV: VkAccelerationStructureMemoryRequirementsTypeNV = VkAccelerationStructureMemoryRequirementsTypeNV(0);
/// `1`  
pub const VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_BUILD_SCRATCH_NV: VkAccelerationStructureMemoryRequirementsTypeNV = VkAccelerationStructureMemoryRequirementsTypeNV(1);
/// `2`  
pub const VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_UPDATE_SCRATCH_NV: VkAccelerationStructureMemoryRequirementsTypeNV = VkAccelerationStructureMemoryRequirementsTypeNV(2);

impl_enum_display!(VkAccelerationStructureMemoryRequirementsTypeNV { VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_OBJECT_NV, VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_BUILD_SCRATCH_NV, VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_UPDATE_SCRATCH_NV });

flags!(VkAccelerationStructureMotionInfoFlagsNV);
from_into_transparent!(VkAccelerationStructureMotionInfoFlagsNV: i32);
/// `VkAccelerationStructureMotionInfoFlagsNV`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkAccelerationStructureMotionInfoFlagsNV(pub i32);

impl_flags_display!(VkAccelerationStructureMotionInfoFlagsNV {  });

/// `VkAccelerationStructureMotionInfoNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkAccelerationStructureMotionInfoNV {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub maxInstances: uint32_t,
    pub flags: VkAccelerationStructureMotionInfoFlagsNV,
}
impl_default_zeroed_with_s_type!(VkAccelerationStructureMotionInfoNV : VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV);
impl_extends!(VkAccelerationStructureMotionInfoNV : VkAccelerationStructureCreateInfoKHR);

/// `VkAccelerationStructureMotionInstanceDataNV`
#[repr(C)]
#[derive(Clone, Copy)]
pub union VkAccelerationStructureMotionInstanceDataNV {
    pub staticInstance: VkAccelerationStructureInstanceKHR,
    pub matrixMotionInstance: VkAccelerationStructureMatrixMotionInstanceNV,
    pub srtMotionInstance: VkAccelerationStructureSRTMotionInstanceNV,
}
impl_debug_for_union!(VkAccelerationStructureMotionInstanceDataNV);
impl_default_zeroed!(VkAccelerationStructureMotionInstanceDataNV);

flags!(VkAccelerationStructureMotionInstanceFlagsNV);
from_into_transparent!(VkAccelerationStructureMotionInstanceFlagsNV: i32);
/// `VkAccelerationStructureMotionInstanceFlagsNV`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkAccelerationStructureMotionInstanceFlagsNV(pub i32);

impl_flags_display!(VkAccelerationStructureMotionInstanceFlagsNV {  });

/// `VkAccelerationStructureMotionInstanceNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkAccelerationStructureMotionInstanceNV {
    pub r#type: VkAccelerationStructureMotionInstanceTypeNV,
    pub flags: VkAccelerationStructureMotionInstanceFlagsNV,
    pub data: VkAccelerationStructureMotionInstanceDataNV,
}
impl_default_zeroed!(VkAccelerationStructureMotionInstanceNV);

from_into_transparent!(VkAccelerationStructureMotionInstanceTypeNV: i32);
/// `VkAccelerationStructureMotionInstanceTypeNV`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkAccelerationStructureMotionInstanceTypeNV(pub i32);

/// `0`  
pub const VK_ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_STATIC_NV: VkAccelerationStructureMotionInstanceTypeNV = VkAccelerationStructureMotionInstanceTypeNV(0);
/// `1`  
pub const VK_ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_MATRIX_MOTION_NV: VkAccelerationStructureMotionInstanceTypeNV = VkAccelerationStructureMotionInstanceTypeNV(1);
/// `2`  
pub const VK_ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_SRT_MOTION_NV: VkAccelerationStructureMotionInstanceTypeNV = VkAccelerationStructureMotionInstanceTypeNV(2);

impl_enum_display!(VkAccelerationStructureMotionInstanceTypeNV { VK_ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_STATIC_NV, VK_ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_MATRIX_MOTION_NV, VK_ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_SRT_MOTION_NV });

/// `VkAccelerationStructureNV` : `VkDevice`
#[repr(transparent)]
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkAccelerationStructureNV(pub u64);
from_into_transparent!(VkAccelerationStructureNV: u64);
impl_handle!(VkAccelerationStructureNV: VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV; SubHandle = VkDevice);

/// `VkAccelerationStructureSRTMotionInstanceNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkAccelerationStructureSRTMotionInstanceNV {
    pub transformT0: VkSRTDataNV,
    pub transformT1: VkSRTDataNV,
    pub instanceCustomIndex: uint32_t,
    pub mask: uint32_t,
    pub instanceShaderBindingTableRecordOffset: uint32_t,
    pub flags: VkGeometryInstanceFlagsKHR,
    pub accelerationStructureReference: uint64_t,
}
impl_default_zeroed!(VkAccelerationStructureSRTMotionInstanceNV);

/// `VkAccelerationStructureTrianglesDisplacementMicromapNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkAccelerationStructureTrianglesDisplacementMicromapNV {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub displacementBiasAndScaleFormat: VkFormat,
    pub displacementVectorFormat: VkFormat,
    pub displacementBiasAndScaleBuffer: VkDeviceOrHostAddressConstKHR,
    pub displacementBiasAndScaleStride: VkDeviceSize,
    pub displacementVectorBuffer: VkDeviceOrHostAddressConstKHR,
    pub displacementVectorStride: VkDeviceSize,
    pub displacedMicromapPrimitiveFlags: VkDeviceOrHostAddressConstKHR,
    pub displacedMicromapPrimitiveFlagsStride: VkDeviceSize,
    pub indexType: VkIndexType,
    pub indexBuffer: VkDeviceOrHostAddressConstKHR,
    pub indexStride: VkDeviceSize,
    pub baseTriangle: uint32_t,
    pub usageCountsCount: uint32_t,
    pub pUsageCounts: *const VkMicromapUsageEXT,
    pub ppUsageCounts: *const *const VkMicromapUsageEXT,
    pub micromap: VkMicromapEXT,
}
impl_default_zeroed_with_s_type!(VkAccelerationStructureTrianglesDisplacementMicromapNV : VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_DISPLACEMENT_MICROMAP_NV);
impl_extends!(VkAccelerationStructureTrianglesDisplacementMicromapNV : VkAccelerationStructureGeometryTrianglesDataKHR);

/// `VkAccelerationStructureTrianglesOpacityMicromapEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkAccelerationStructureTrianglesOpacityMicromapEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub indexType: VkIndexType,
    pub indexBuffer: VkDeviceOrHostAddressConstKHR,
    pub indexStride: VkDeviceSize,
    pub baseTriangle: uint32_t,
    pub usageCountsCount: uint32_t,
    pub pUsageCounts: *const VkMicromapUsageEXT,
    pub ppUsageCounts: *const *const VkMicromapUsageEXT,
    pub micromap: VkMicromapEXT,
}
impl_default_zeroed_with_s_type!(VkAccelerationStructureTrianglesOpacityMicromapEXT : VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT);
impl_extends!(VkAccelerationStructureTrianglesOpacityMicromapEXT : VkAccelerationStructureGeometryTrianglesDataKHR, VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX);

from_into_transparent!(VkAccelerationStructureTypeKHR: i32);
/// `VkAccelerationStructureTypeKHR`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkAccelerationStructureTypeKHR(pub i32);

/// `0`  
pub const VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_KHR: VkAccelerationStructureTypeKHR = VkAccelerationStructureTypeKHR(0);
/// `1`  
pub const VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_KHR: VkAccelerationStructureTypeKHR = VkAccelerationStructureTypeKHR(1);
/// `2`  
pub const VK_ACCELERATION_STRUCTURE_TYPE_GENERIC_KHR: VkAccelerationStructureTypeKHR = VkAccelerationStructureTypeKHR(2);
/// `VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_KHR`  
pub const VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_NV: VkAccelerationStructureTypeKHR = VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_KHR;
/// `VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_KHR`  
pub const VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NV: VkAccelerationStructureTypeKHR = VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_KHR;

impl_enum_display!(VkAccelerationStructureTypeKHR { VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_KHR, VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_KHR, VK_ACCELERATION_STRUCTURE_TYPE_GENERIC_KHR, VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_NV, VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NV });

/// `VkAccelerationStructureTypeKHR`
pub type VkAccelerationStructureTypeNV = VkAccelerationStructureTypeKHR;

/// `VkAccelerationStructureVersionInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkAccelerationStructureVersionInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub pVersionData: *const uint8_t,
}
impl_default_zeroed_with_s_type!(VkAccelerationStructureVersionInfoKHR : VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_VERSION_INFO_KHR);

flags!(VkAccessFlags);
from_into_transparent!(VkAccessFlags: i32);
/// `VkAccessFlags`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkAccessFlags(pub i32);

/// `1 << 0`  
/// 
/// Controls coherency of indirect command reads
pub const VK_ACCESS_INDIRECT_COMMAND_READ_BIT: VkAccessFlags = VkAccessFlags(1 << 0);
/// `1 << 1`  
/// 
/// Controls coherency of index reads
pub const VK_ACCESS_INDEX_READ_BIT: VkAccessFlags = VkAccessFlags(1 << 1);
/// `1 << 2`  
/// 
/// Controls coherency of vertex attribute reads
pub const VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT: VkAccessFlags = VkAccessFlags(1 << 2);
/// `1 << 3`  
/// 
/// Controls coherency of uniform buffer reads
pub const VK_ACCESS_UNIFORM_READ_BIT: VkAccessFlags = VkAccessFlags(1 << 3);
/// `1 << 4`  
/// 
/// Controls coherency of input attachment reads
pub const VK_ACCESS_INPUT_ATTACHMENT_READ_BIT: VkAccessFlags = VkAccessFlags(1 << 4);
/// `1 << 5`  
/// 
/// Controls coherency of shader reads
pub const VK_ACCESS_SHADER_READ_BIT: VkAccessFlags = VkAccessFlags(1 << 5);
/// `1 << 6`  
/// 
/// Controls coherency of shader writes
pub const VK_ACCESS_SHADER_WRITE_BIT: VkAccessFlags = VkAccessFlags(1 << 6);
/// `1 << 7`  
/// 
/// Controls coherency of color attachment reads
pub const VK_ACCESS_COLOR_ATTACHMENT_READ_BIT: VkAccessFlags = VkAccessFlags(1 << 7);
/// `1 << 8`  
/// 
/// Controls coherency of color attachment writes
pub const VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT: VkAccessFlags = VkAccessFlags(1 << 8);
/// `1 << 9`  
/// 
/// Controls coherency of depth/stencil attachment reads
pub const VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT: VkAccessFlags = VkAccessFlags(1 << 9);
/// `1 << 10`  
/// 
/// Controls coherency of depth/stencil attachment writes
pub const VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT: VkAccessFlags = VkAccessFlags(1 << 10);
/// `1 << 11`  
/// 
/// Controls coherency of transfer reads
pub const VK_ACCESS_TRANSFER_READ_BIT: VkAccessFlags = VkAccessFlags(1 << 11);
/// `1 << 12`  
/// 
/// Controls coherency of transfer writes
pub const VK_ACCESS_TRANSFER_WRITE_BIT: VkAccessFlags = VkAccessFlags(1 << 12);
/// `1 << 13`  
/// 
/// Controls coherency of host reads
pub const VK_ACCESS_HOST_READ_BIT: VkAccessFlags = VkAccessFlags(1 << 13);
/// `1 << 14`  
/// 
/// Controls coherency of host writes
pub const VK_ACCESS_HOST_WRITE_BIT: VkAccessFlags = VkAccessFlags(1 << 14);
/// `1 << 15`  
/// 
/// Controls coherency of memory reads
pub const VK_ACCESS_MEMORY_READ_BIT: VkAccessFlags = VkAccessFlags(1 << 15);
/// `1 << 16`  
/// 
/// Controls coherency of memory writes
pub const VK_ACCESS_MEMORY_WRITE_BIT: VkAccessFlags = VkAccessFlags(1 << 16);
/// `0`  
pub const VK_ACCESS_NONE: VkAccessFlags = VkAccessFlags(0);
/// `1 << 25`  
pub const VK_ACCESS_TRANSFORM_FEEDBACK_WRITE_BIT_EXT: VkAccessFlags = VkAccessFlags(1 << 25);
/// `1 << 26`  
pub const VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT: VkAccessFlags = VkAccessFlags(1 << 26);
/// `1 << 27`  
pub const VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT: VkAccessFlags = VkAccessFlags(1 << 27);
/// `1 << 20`  
/// 
/// read access flag for reading conditional rendering predicate
pub const VK_ACCESS_CONDITIONAL_RENDERING_READ_BIT_EXT: VkAccessFlags = VkAccessFlags(1 << 20);
/// `1 << 19`  
pub const VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT: VkAccessFlags = VkAccessFlags(1 << 19);
/// `1 << 21`  
pub const VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_KHR: VkAccessFlags = VkAccessFlags(1 << 21);
/// `1 << 22`  
pub const VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_KHR: VkAccessFlags = VkAccessFlags(1 << 22);
/// `VK_ACCESS_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR`  
pub const VK_ACCESS_SHADING_RATE_IMAGE_READ_BIT_NV: VkAccessFlags = VK_ACCESS_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR;
/// `VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_KHR`  
pub const VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_NV: VkAccessFlags = VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_KHR;
/// `VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_KHR`  
pub const VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_NV: VkAccessFlags = VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_KHR;
/// `1 << 24`  
pub const VK_ACCESS_FRAGMENT_DENSITY_MAP_READ_BIT_EXT: VkAccessFlags = VkAccessFlags(1 << 24);
/// `1 << 23`  
pub const VK_ACCESS_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR: VkAccessFlags = VkAccessFlags(1 << 23);
/// `VK_ACCESS_COMMAND_PREPROCESS_READ_BIT_EXT`  
pub const VK_ACCESS_COMMAND_PREPROCESS_READ_BIT_NV: VkAccessFlags = VK_ACCESS_COMMAND_PREPROCESS_READ_BIT_EXT;
/// `VK_ACCESS_COMMAND_PREPROCESS_WRITE_BIT_EXT`  
pub const VK_ACCESS_COMMAND_PREPROCESS_WRITE_BIT_NV: VkAccessFlags = VK_ACCESS_COMMAND_PREPROCESS_WRITE_BIT_EXT;
/// `VK_ACCESS_NONE`  
pub const VK_ACCESS_NONE_KHR: VkAccessFlags = VK_ACCESS_NONE;
/// `1 << 17`  
pub const VK_ACCESS_COMMAND_PREPROCESS_READ_BIT_EXT: VkAccessFlags = VkAccessFlags(1 << 17);
/// `1 << 18`  
pub const VK_ACCESS_COMMAND_PREPROCESS_WRITE_BIT_EXT: VkAccessFlags = VkAccessFlags(1 << 18);

impl_flags_display!(VkAccessFlags { VK_ACCESS_INDIRECT_COMMAND_READ_BIT, VK_ACCESS_INDEX_READ_BIT, VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT, VK_ACCESS_UNIFORM_READ_BIT, VK_ACCESS_INPUT_ATTACHMENT_READ_BIT, VK_ACCESS_SHADER_READ_BIT, VK_ACCESS_SHADER_WRITE_BIT, VK_ACCESS_COLOR_ATTACHMENT_READ_BIT, VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT, VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT, VK_ACCESS_TRANSFER_READ_BIT, VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_HOST_READ_BIT, VK_ACCESS_HOST_WRITE_BIT, VK_ACCESS_MEMORY_READ_BIT, VK_ACCESS_MEMORY_WRITE_BIT, VK_ACCESS_NONE, VK_ACCESS_TRANSFORM_FEEDBACK_WRITE_BIT_EXT, VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT, VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT, VK_ACCESS_CONDITIONAL_RENDERING_READ_BIT_EXT, VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT, VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_KHR, VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_KHR, VK_ACCESS_SHADING_RATE_IMAGE_READ_BIT_NV, VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_NV, VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_NV, VK_ACCESS_FRAGMENT_DENSITY_MAP_READ_BIT_EXT, VK_ACCESS_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR, VK_ACCESS_COMMAND_PREPROCESS_READ_BIT_NV, VK_ACCESS_COMMAND_PREPROCESS_WRITE_BIT_NV, VK_ACCESS_NONE_KHR, VK_ACCESS_COMMAND_PREPROCESS_READ_BIT_EXT, VK_ACCESS_COMMAND_PREPROCESS_WRITE_BIT_EXT });

flags!(VkAccessFlags2);
from_into_transparent!(VkAccessFlags2: i64);
/// `VkAccessFlags2`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkAccessFlags2(pub i64);

/// `0`  
pub const VK_ACCESS_2_NONE: VkAccessFlags2 = VkAccessFlags2(0);
/// `1 << 0`  
pub const VK_ACCESS_2_INDIRECT_COMMAND_READ_BIT: VkAccessFlags2 = VkAccessFlags2(1 << 0);
/// `1 << 1`  
pub const VK_ACCESS_2_INDEX_READ_BIT: VkAccessFlags2 = VkAccessFlags2(1 << 1);
/// `1 << 2`  
pub const VK_ACCESS_2_VERTEX_ATTRIBUTE_READ_BIT: VkAccessFlags2 = VkAccessFlags2(1 << 2);
/// `1 << 3`  
pub const VK_ACCESS_2_UNIFORM_READ_BIT: VkAccessFlags2 = VkAccessFlags2(1 << 3);
/// `1 << 4`  
pub const VK_ACCESS_2_INPUT_ATTACHMENT_READ_BIT: VkAccessFlags2 = VkAccessFlags2(1 << 4);
/// `1 << 5`  
pub const VK_ACCESS_2_SHADER_READ_BIT: VkAccessFlags2 = VkAccessFlags2(1 << 5);
/// `1 << 6`  
pub const VK_ACCESS_2_SHADER_WRITE_BIT: VkAccessFlags2 = VkAccessFlags2(1 << 6);
/// `1 << 7`  
pub const VK_ACCESS_2_COLOR_ATTACHMENT_READ_BIT: VkAccessFlags2 = VkAccessFlags2(1 << 7);
/// `1 << 8`  
pub const VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT: VkAccessFlags2 = VkAccessFlags2(1 << 8);
/// `1 << 9`  
pub const VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_READ_BIT: VkAccessFlags2 = VkAccessFlags2(1 << 9);
/// `1 << 10`  
pub const VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT: VkAccessFlags2 = VkAccessFlags2(1 << 10);
/// `1 << 11`  
pub const VK_ACCESS_2_TRANSFER_READ_BIT: VkAccessFlags2 = VkAccessFlags2(1 << 11);
/// `1 << 12`  
pub const VK_ACCESS_2_TRANSFER_WRITE_BIT: VkAccessFlags2 = VkAccessFlags2(1 << 12);
/// `1 << 13`  
pub const VK_ACCESS_2_HOST_READ_BIT: VkAccessFlags2 = VkAccessFlags2(1 << 13);
/// `1 << 14`  
pub const VK_ACCESS_2_HOST_WRITE_BIT: VkAccessFlags2 = VkAccessFlags2(1 << 14);
/// `1 << 15`  
pub const VK_ACCESS_2_MEMORY_READ_BIT: VkAccessFlags2 = VkAccessFlags2(1 << 15);
/// `1 << 16`  
pub const VK_ACCESS_2_MEMORY_WRITE_BIT: VkAccessFlags2 = VkAccessFlags2(1 << 16);
/// `1 << 32`  
pub const VK_ACCESS_2_SHADER_SAMPLED_READ_BIT: VkAccessFlags2 = VkAccessFlags2(1 << 32);
/// `1 << 33`  
pub const VK_ACCESS_2_SHADER_STORAGE_READ_BIT: VkAccessFlags2 = VkAccessFlags2(1 << 33);
/// `1 << 34`  
pub const VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT: VkAccessFlags2 = VkAccessFlags2(1 << 34);
/// `1 << 35`  
pub const VK_ACCESS_2_VIDEO_DECODE_READ_BIT_KHR: VkAccessFlags2 = VkAccessFlags2(1 << 35);
/// `1 << 36`  
pub const VK_ACCESS_2_VIDEO_DECODE_WRITE_BIT_KHR: VkAccessFlags2 = VkAccessFlags2(1 << 36);
/// `1 << 57`  
pub const VK_ACCESS_2_SAMPLER_HEAP_READ_BIT_EXT: VkAccessFlags2 = VkAccessFlags2(1 << 57);
/// `1 << 58`  
pub const VK_ACCESS_2_RESOURCE_HEAP_READ_BIT_EXT: VkAccessFlags2 = VkAccessFlags2(1 << 58);
/// `1 << 46`  
pub const VK_ACCESS_2_RESERVED_46_BIT_INTEL: VkAccessFlags2 = VkAccessFlags2(1 << 46);
/// `1 << 37`  
pub const VK_ACCESS_2_VIDEO_ENCODE_READ_BIT_KHR: VkAccessFlags2 = VkAccessFlags2(1 << 37);
/// `1 << 38`  
pub const VK_ACCESS_2_VIDEO_ENCODE_WRITE_BIT_KHR: VkAccessFlags2 = VkAccessFlags2(1 << 38);
/// `1 << 51`  
pub const VK_ACCESS_2_SHADER_TILE_ATTACHMENT_READ_BIT_QCOM: VkAccessFlags2 = VkAccessFlags2(1 << 51);
/// `1 << 52`  
pub const VK_ACCESS_2_SHADER_TILE_ATTACHMENT_WRITE_BIT_QCOM: VkAccessFlags2 = VkAccessFlags2(1 << 52);
/// `VK_ACCESS_2_NONE`  
pub const VK_ACCESS_2_NONE_KHR: VkAccessFlags2 = VK_ACCESS_2_NONE;
/// `VK_ACCESS_2_INDIRECT_COMMAND_READ_BIT`  
pub const VK_ACCESS_2_INDIRECT_COMMAND_READ_BIT_KHR: VkAccessFlags2 = VK_ACCESS_2_INDIRECT_COMMAND_READ_BIT;
/// `VK_ACCESS_2_INDEX_READ_BIT`  
pub const VK_ACCESS_2_INDEX_READ_BIT_KHR: VkAccessFlags2 = VK_ACCESS_2_INDEX_READ_BIT;
/// `VK_ACCESS_2_VERTEX_ATTRIBUTE_READ_BIT`  
pub const VK_ACCESS_2_VERTEX_ATTRIBUTE_READ_BIT_KHR: VkAccessFlags2 = VK_ACCESS_2_VERTEX_ATTRIBUTE_READ_BIT;
/// `VK_ACCESS_2_UNIFORM_READ_BIT`  
pub const VK_ACCESS_2_UNIFORM_READ_BIT_KHR: VkAccessFlags2 = VK_ACCESS_2_UNIFORM_READ_BIT;
/// `VK_ACCESS_2_INPUT_ATTACHMENT_READ_BIT`  
pub const VK_ACCESS_2_INPUT_ATTACHMENT_READ_BIT_KHR: VkAccessFlags2 = VK_ACCESS_2_INPUT_ATTACHMENT_READ_BIT;
/// `VK_ACCESS_2_SHADER_READ_BIT`  
pub const VK_ACCESS_2_SHADER_READ_BIT_KHR: VkAccessFlags2 = VK_ACCESS_2_SHADER_READ_BIT;
/// `VK_ACCESS_2_SHADER_WRITE_BIT`  
pub const VK_ACCESS_2_SHADER_WRITE_BIT_KHR: VkAccessFlags2 = VK_ACCESS_2_SHADER_WRITE_BIT;
/// `VK_ACCESS_2_COLOR_ATTACHMENT_READ_BIT`  
pub const VK_ACCESS_2_COLOR_ATTACHMENT_READ_BIT_KHR: VkAccessFlags2 = VK_ACCESS_2_COLOR_ATTACHMENT_READ_BIT;
/// `VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT`  
pub const VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT_KHR: VkAccessFlags2 = VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT;
/// `VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_READ_BIT`  
pub const VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_READ_BIT_KHR: VkAccessFlags2 = VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_READ_BIT;
/// `VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT`  
pub const VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT_KHR: VkAccessFlags2 = VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
/// `VK_ACCESS_2_TRANSFER_READ_BIT`  
pub const VK_ACCESS_2_TRANSFER_READ_BIT_KHR: VkAccessFlags2 = VK_ACCESS_2_TRANSFER_READ_BIT;
/// `VK_ACCESS_2_TRANSFER_WRITE_BIT`  
pub const VK_ACCESS_2_TRANSFER_WRITE_BIT_KHR: VkAccessFlags2 = VK_ACCESS_2_TRANSFER_WRITE_BIT;
/// `VK_ACCESS_2_HOST_READ_BIT`  
pub const VK_ACCESS_2_HOST_READ_BIT_KHR: VkAccessFlags2 = VK_ACCESS_2_HOST_READ_BIT;
/// `VK_ACCESS_2_HOST_WRITE_BIT`  
pub const VK_ACCESS_2_HOST_WRITE_BIT_KHR: VkAccessFlags2 = VK_ACCESS_2_HOST_WRITE_BIT;
/// `VK_ACCESS_2_MEMORY_READ_BIT`  
pub const VK_ACCESS_2_MEMORY_READ_BIT_KHR: VkAccessFlags2 = VK_ACCESS_2_MEMORY_READ_BIT;
/// `VK_ACCESS_2_MEMORY_WRITE_BIT`  
pub const VK_ACCESS_2_MEMORY_WRITE_BIT_KHR: VkAccessFlags2 = VK_ACCESS_2_MEMORY_WRITE_BIT;
/// `VK_ACCESS_2_SHADER_SAMPLED_READ_BIT`  
pub const VK_ACCESS_2_SHADER_SAMPLED_READ_BIT_KHR: VkAccessFlags2 = VK_ACCESS_2_SHADER_SAMPLED_READ_BIT;
/// `VK_ACCESS_2_SHADER_STORAGE_READ_BIT`  
pub const VK_ACCESS_2_SHADER_STORAGE_READ_BIT_KHR: VkAccessFlags2 = VK_ACCESS_2_SHADER_STORAGE_READ_BIT;
/// `VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT`  
pub const VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT_KHR: VkAccessFlags2 = VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT;
/// `1 << 25`  
pub const VK_ACCESS_2_TRANSFORM_FEEDBACK_WRITE_BIT_EXT: VkAccessFlags2 = VkAccessFlags2(1 << 25);
/// `1 << 26`  
pub const VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT: VkAccessFlags2 = VkAccessFlags2(1 << 26);
/// `1 << 27`  
pub const VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT: VkAccessFlags2 = VkAccessFlags2(1 << 27);
/// `1 << 20`  
/// 
/// read access flag for reading conditional rendering predicate
pub const VK_ACCESS_2_CONDITIONAL_RENDERING_READ_BIT_EXT: VkAccessFlags2 = VkAccessFlags2(1 << 20);
/// `VK_ACCESS_2_COMMAND_PREPROCESS_READ_BIT_EXT`  
pub const VK_ACCESS_2_COMMAND_PREPROCESS_READ_BIT_NV: VkAccessFlags2 = VK_ACCESS_2_COMMAND_PREPROCESS_READ_BIT_EXT;
/// `VK_ACCESS_2_COMMAND_PREPROCESS_WRITE_BIT_EXT`  
pub const VK_ACCESS_2_COMMAND_PREPROCESS_WRITE_BIT_NV: VkAccessFlags2 = VK_ACCESS_2_COMMAND_PREPROCESS_WRITE_BIT_EXT;
/// `1 << 17`  
pub const VK_ACCESS_2_COMMAND_PREPROCESS_READ_BIT_EXT: VkAccessFlags2 = VkAccessFlags2(1 << 17);
/// `1 << 18`  
pub const VK_ACCESS_2_COMMAND_PREPROCESS_WRITE_BIT_EXT: VkAccessFlags2 = VkAccessFlags2(1 << 18);
/// `1 << 23`  
pub const VK_ACCESS_2_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR: VkAccessFlags2 = VkAccessFlags2(1 << 23);
/// `VK_ACCESS_2_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR`  
pub const VK_ACCESS_2_SHADING_RATE_IMAGE_READ_BIT_NV: VkAccessFlags2 = VK_ACCESS_2_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR;
/// `1 << 21`  
pub const VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_KHR: VkAccessFlags2 = VkAccessFlags2(1 << 21);
/// `1 << 22`  
pub const VK_ACCESS_2_ACCELERATION_STRUCTURE_WRITE_BIT_KHR: VkAccessFlags2 = VkAccessFlags2(1 << 22);
/// `VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_KHR`  
pub const VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_NV: VkAccessFlags2 = VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_KHR;
/// `VK_ACCESS_2_ACCELERATION_STRUCTURE_WRITE_BIT_KHR`  
pub const VK_ACCESS_2_ACCELERATION_STRUCTURE_WRITE_BIT_NV: VkAccessFlags2 = VK_ACCESS_2_ACCELERATION_STRUCTURE_WRITE_BIT_KHR;
/// `1 << 24`  
pub const VK_ACCESS_2_FRAGMENT_DENSITY_MAP_READ_BIT_EXT: VkAccessFlags2 = VkAccessFlags2(1 << 24);
/// `1 << 19`  
pub const VK_ACCESS_2_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT: VkAccessFlags2 = VkAccessFlags2(1 << 19);
/// `1 << 41`  
pub const VK_ACCESS_2_DESCRIPTOR_BUFFER_READ_BIT_EXT: VkAccessFlags2 = VkAccessFlags2(1 << 41);
/// `1 << 39`  
pub const VK_ACCESS_2_INVOCATION_MASK_READ_BIT_HUAWEI: VkAccessFlags2 = VkAccessFlags2(1 << 39);
/// `1 << 40`  
pub const VK_ACCESS_2_SHADER_BINDING_TABLE_READ_BIT_KHR: VkAccessFlags2 = VkAccessFlags2(1 << 40);
/// `1 << 44`  
pub const VK_ACCESS_2_MICROMAP_READ_BIT_EXT: VkAccessFlags2 = VkAccessFlags2(1 << 44);
/// `1 << 45`  
pub const VK_ACCESS_2_MICROMAP_WRITE_BIT_EXT: VkAccessFlags2 = VkAccessFlags2(1 << 45);
/// `1 << 42`  
pub const VK_ACCESS_2_OPTICAL_FLOW_READ_BIT_NV: VkAccessFlags2 = VkAccessFlags2(1 << 42);
/// `1 << 43`  
pub const VK_ACCESS_2_OPTICAL_FLOW_WRITE_BIT_NV: VkAccessFlags2 = VkAccessFlags2(1 << 43);
/// `1 << 47`  
pub const VK_ACCESS_2_DATA_GRAPH_READ_BIT_ARM: VkAccessFlags2 = VkAccessFlags2(1 << 47);
/// `1 << 48`  
pub const VK_ACCESS_2_DATA_GRAPH_WRITE_BIT_ARM: VkAccessFlags2 = VkAccessFlags2(1 << 48);
/// `1 << 55`  
pub const VK_ACCESS_2_MEMORY_DECOMPRESSION_READ_BIT_EXT: VkAccessFlags2 = VkAccessFlags2(1 << 55);
/// `1 << 56`  
pub const VK_ACCESS_2_MEMORY_DECOMPRESSION_WRITE_BIT_EXT: VkAccessFlags2 = VkAccessFlags2(1 << 56);
/// `1 << 62`  
pub const VK_ACCESS_2_RESERVED_62_BIT_EXT: VkAccessFlags2 = VkAccessFlags2(1 << 62);
/// `1 << 63`  
pub const VK_ACCESS_2_RESERVED_63_BIT_EXT: VkAccessFlags2 = VkAccessFlags2(1 << 63);
/// `1 << 60`  
pub const VK_ACCESS_2_RESERVED_60_BIT_KHR: VkAccessFlags2 = VkAccessFlags2(1 << 60);
/// `1 << 61`  
pub const VK_ACCESS_2_RESERVED_61_BIT_KHR: VkAccessFlags2 = VkAccessFlags2(1 << 61);
/// `1 << 49`  
pub const VK_ACCESS_2_RESERVED_49_BIT_ARM: VkAccessFlags2 = VkAccessFlags2(1 << 49);
/// `1 << 50`  
pub const VK_ACCESS_2_RESERVED_50_BIT_ARM: VkAccessFlags2 = VkAccessFlags2(1 << 50);

impl_flags_display!(VkAccessFlags2 { VK_ACCESS_2_NONE, VK_ACCESS_2_INDIRECT_COMMAND_READ_BIT, VK_ACCESS_2_INDEX_READ_BIT, VK_ACCESS_2_VERTEX_ATTRIBUTE_READ_BIT, VK_ACCESS_2_UNIFORM_READ_BIT, VK_ACCESS_2_INPUT_ATTACHMENT_READ_BIT, VK_ACCESS_2_SHADER_READ_BIT, VK_ACCESS_2_SHADER_WRITE_BIT, VK_ACCESS_2_COLOR_ATTACHMENT_READ_BIT, VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT, VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_READ_BIT, VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT, VK_ACCESS_2_TRANSFER_READ_BIT, VK_ACCESS_2_TRANSFER_WRITE_BIT, VK_ACCESS_2_HOST_READ_BIT, VK_ACCESS_2_HOST_WRITE_BIT, VK_ACCESS_2_MEMORY_READ_BIT, VK_ACCESS_2_MEMORY_WRITE_BIT, VK_ACCESS_2_SHADER_SAMPLED_READ_BIT, VK_ACCESS_2_SHADER_STORAGE_READ_BIT, VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT, VK_ACCESS_2_VIDEO_DECODE_READ_BIT_KHR, VK_ACCESS_2_VIDEO_DECODE_WRITE_BIT_KHR, VK_ACCESS_2_SAMPLER_HEAP_READ_BIT_EXT, VK_ACCESS_2_RESOURCE_HEAP_READ_BIT_EXT, VK_ACCESS_2_RESERVED_46_BIT_INTEL, VK_ACCESS_2_VIDEO_ENCODE_READ_BIT_KHR, VK_ACCESS_2_VIDEO_ENCODE_WRITE_BIT_KHR, VK_ACCESS_2_SHADER_TILE_ATTACHMENT_READ_BIT_QCOM, VK_ACCESS_2_SHADER_TILE_ATTACHMENT_WRITE_BIT_QCOM, VK_ACCESS_2_NONE_KHR, VK_ACCESS_2_INDIRECT_COMMAND_READ_BIT_KHR, VK_ACCESS_2_INDEX_READ_BIT_KHR, VK_ACCESS_2_VERTEX_ATTRIBUTE_READ_BIT_KHR, VK_ACCESS_2_UNIFORM_READ_BIT_KHR, VK_ACCESS_2_INPUT_ATTACHMENT_READ_BIT_KHR, VK_ACCESS_2_SHADER_READ_BIT_KHR, VK_ACCESS_2_SHADER_WRITE_BIT_KHR, VK_ACCESS_2_COLOR_ATTACHMENT_READ_BIT_KHR, VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT_KHR, VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_READ_BIT_KHR, VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT_KHR, VK_ACCESS_2_TRANSFER_READ_BIT_KHR, VK_ACCESS_2_TRANSFER_WRITE_BIT_KHR, VK_ACCESS_2_HOST_READ_BIT_KHR, VK_ACCESS_2_HOST_WRITE_BIT_KHR, VK_ACCESS_2_MEMORY_READ_BIT_KHR, VK_ACCESS_2_MEMORY_WRITE_BIT_KHR, VK_ACCESS_2_SHADER_SAMPLED_READ_BIT_KHR, VK_ACCESS_2_SHADER_STORAGE_READ_BIT_KHR, VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT_KHR, VK_ACCESS_2_TRANSFORM_FEEDBACK_WRITE_BIT_EXT, VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT, VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT, VK_ACCESS_2_CONDITIONAL_RENDERING_READ_BIT_EXT, VK_ACCESS_2_COMMAND_PREPROCESS_READ_BIT_NV, VK_ACCESS_2_COMMAND_PREPROCESS_WRITE_BIT_NV, VK_ACCESS_2_COMMAND_PREPROCESS_READ_BIT_EXT, VK_ACCESS_2_COMMAND_PREPROCESS_WRITE_BIT_EXT, VK_ACCESS_2_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR, VK_ACCESS_2_SHADING_RATE_IMAGE_READ_BIT_NV, VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_KHR, VK_ACCESS_2_ACCELERATION_STRUCTURE_WRITE_BIT_KHR, VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_NV, VK_ACCESS_2_ACCELERATION_STRUCTURE_WRITE_BIT_NV, VK_ACCESS_2_FRAGMENT_DENSITY_MAP_READ_BIT_EXT, VK_ACCESS_2_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT, VK_ACCESS_2_DESCRIPTOR_BUFFER_READ_BIT_EXT, VK_ACCESS_2_INVOCATION_MASK_READ_BIT_HUAWEI, VK_ACCESS_2_SHADER_BINDING_TABLE_READ_BIT_KHR, VK_ACCESS_2_MICROMAP_READ_BIT_EXT, VK_ACCESS_2_MICROMAP_WRITE_BIT_EXT, VK_ACCESS_2_OPTICAL_FLOW_READ_BIT_NV, VK_ACCESS_2_OPTICAL_FLOW_WRITE_BIT_NV, VK_ACCESS_2_DATA_GRAPH_READ_BIT_ARM, VK_ACCESS_2_DATA_GRAPH_WRITE_BIT_ARM, VK_ACCESS_2_MEMORY_DECOMPRESSION_READ_BIT_EXT, VK_ACCESS_2_MEMORY_DECOMPRESSION_WRITE_BIT_EXT, VK_ACCESS_2_RESERVED_62_BIT_EXT, VK_ACCESS_2_RESERVED_63_BIT_EXT, VK_ACCESS_2_RESERVED_60_BIT_KHR, VK_ACCESS_2_RESERVED_61_BIT_KHR, VK_ACCESS_2_RESERVED_49_BIT_ARM, VK_ACCESS_2_RESERVED_50_BIT_ARM });

/// `VkAccessFlags2`
pub type VkAccessFlags2KHR = VkAccessFlags2;

flags!(VkAccessFlags3KHR);
from_into_transparent!(VkAccessFlags3KHR: i64);
/// `VkAccessFlags3KHR`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkAccessFlags3KHR(pub i64);

/// `0`  
pub const VK_ACCESS_3_NONE_KHR: VkAccessFlags3KHR = VkAccessFlags3KHR(0);

impl_flags_display!(VkAccessFlags3KHR { VK_ACCESS_3_NONE_KHR });

/// `VkAcquireNextImageInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkAcquireNextImageInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub swapchain: VkSwapchainKHR,
    pub timeout: uint64_t,
    pub semaphore: VkSemaphore,
    pub fence: VkFence,
    pub deviceMask: uint32_t,
}
impl_default_zeroed_with_s_type!(VkAcquireNextImageInfoKHR : VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR);

flags!(VkAcquireProfilingLockFlagsKHR);
from_into_transparent!(VkAcquireProfilingLockFlagsKHR: i32);
/// `VkAcquireProfilingLockFlagsKHR`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkAcquireProfilingLockFlagsKHR(pub i32);

impl_flags_display!(VkAcquireProfilingLockFlagsKHR {  });

/// `VkAcquireProfilingLockInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkAcquireProfilingLockInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    /// Acquire profiling lock flags
    pub flags: VkAcquireProfilingLockFlagsKHR,
    pub timeout: uint64_t,
}
impl_default_zeroed_with_s_type!(VkAcquireProfilingLockInfoKHR : VK_STRUCTURE_TYPE_ACQUIRE_PROFILING_LOCK_INFO_KHR);

flags!(VkAddressCopyFlagsKHR);
from_into_transparent!(VkAddressCopyFlagsKHR: i32);
/// `VkAddressCopyFlagsKHR`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkAddressCopyFlagsKHR(pub i32);

/// `1 << 0`  
pub const VK_ADDRESS_COPY_DEVICE_LOCAL_BIT_KHR: VkAddressCopyFlagsKHR = VkAddressCopyFlagsKHR(1 << 0);
/// `1 << 1`  
pub const VK_ADDRESS_COPY_SPARSE_BIT_KHR: VkAddressCopyFlagsKHR = VkAddressCopyFlagsKHR(1 << 1);
/// `1 << 2`  
pub const VK_ADDRESS_COPY_PROTECTED_BIT_KHR: VkAddressCopyFlagsKHR = VkAddressCopyFlagsKHR(1 << 2);

impl_flags_display!(VkAddressCopyFlagsKHR { VK_ADDRESS_COPY_DEVICE_LOCAL_BIT_KHR, VK_ADDRESS_COPY_SPARSE_BIT_KHR, VK_ADDRESS_COPY_PROTECTED_BIT_KHR });

/// `VkAllocationCallbacks`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkAllocationCallbacks {
    pub pUserData: *mut void,
    pub pfnAllocation: PFN_vkAllocationFunction,
    pub pfnReallocation: PFN_vkReallocationFunction,
    pub pfnFree: PFN_vkFreeFunction,
    pub pfnInternalAllocation: PFN_vkInternalAllocationNotification,
    pub pfnInternalFree: PFN_vkInternalFreeNotification,
}
impl_default_zeroed!(VkAllocationCallbacks);

/// `VkAmigoProfilingSubmitInfoSEC`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkAmigoProfilingSubmitInfoSEC {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub firstDrawTimestamp: uint64_t,
    pub swapBufferTimestamp: uint64_t,
}
impl_default_zeroed_with_s_type!(VkAmigoProfilingSubmitInfoSEC : VK_STRUCTURE_TYPE_AMIGO_PROFILING_SUBMIT_INFO_SEC);
impl_extends!(VkAmigoProfilingSubmitInfoSEC : VkSubmitInfo);

/// `VkAndroidHardwareBufferFormatProperties2ANDROID`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkAndroidHardwareBufferFormatProperties2ANDROID {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub format: VkFormat,
    pub externalFormat: uint64_t,
    pub formatFeatures: VkFormatFeatureFlags2,
    pub samplerYcbcrConversionComponents: VkComponentMapping,
    pub suggestedYcbcrModel: VkSamplerYcbcrModelConversion,
    pub suggestedYcbcrRange: VkSamplerYcbcrRange,
    pub suggestedXChromaOffset: VkChromaLocation,
    pub suggestedYChromaOffset: VkChromaLocation,
}
impl_default_zeroed_with_s_type!(VkAndroidHardwareBufferFormatProperties2ANDROID : VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID);
impl_extends!(VkAndroidHardwareBufferFormatProperties2ANDROID : VkAndroidHardwareBufferPropertiesANDROID);

/// `VkAndroidHardwareBufferFormatPropertiesANDROID`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkAndroidHardwareBufferFormatPropertiesANDROID {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub format: VkFormat,
    pub externalFormat: uint64_t,
    pub formatFeatures: VkFormatFeatureFlags,
    pub samplerYcbcrConversionComponents: VkComponentMapping,
    pub suggestedYcbcrModel: VkSamplerYcbcrModelConversion,
    pub suggestedYcbcrRange: VkSamplerYcbcrRange,
    pub suggestedXChromaOffset: VkChromaLocation,
    pub suggestedYChromaOffset: VkChromaLocation,
}
impl_default_zeroed_with_s_type!(VkAndroidHardwareBufferFormatPropertiesANDROID : VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID);
impl_extends!(VkAndroidHardwareBufferFormatPropertiesANDROID : VkAndroidHardwareBufferPropertiesANDROID);

/// `VkAndroidHardwareBufferFormatResolvePropertiesANDROID`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkAndroidHardwareBufferFormatResolvePropertiesANDROID {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub colorAttachmentFormat: VkFormat,
}
impl_default_zeroed_with_s_type!(VkAndroidHardwareBufferFormatResolvePropertiesANDROID : VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_RESOLVE_PROPERTIES_ANDROID);
impl_extends!(VkAndroidHardwareBufferFormatResolvePropertiesANDROID : VkAndroidHardwareBufferPropertiesANDROID);

/// `VkAndroidHardwareBufferPropertiesANDROID`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkAndroidHardwareBufferPropertiesANDROID {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub allocationSize: VkDeviceSize,
    pub memoryTypeBits: uint32_t,
}
impl_default_zeroed_with_s_type!(VkAndroidHardwareBufferPropertiesANDROID : VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID);

/// `VkAndroidHardwareBufferUsageANDROID`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkAndroidHardwareBufferUsageANDROID {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub androidHardwareBufferUsage: uint64_t,
}
impl_default_zeroed_with_s_type!(VkAndroidHardwareBufferUsageANDROID : VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID);
impl_extends!(VkAndroidHardwareBufferUsageANDROID : VkImageFormatProperties2);

flags!(VkAndroidSurfaceCreateFlagsKHR);
from_into_transparent!(VkAndroidSurfaceCreateFlagsKHR: i32);
/// `VkAndroidSurfaceCreateFlagsKHR`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkAndroidSurfaceCreateFlagsKHR(pub i32);

impl_flags_display!(VkAndroidSurfaceCreateFlagsKHR {  });

/// `VkAndroidSurfaceCreateInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkAndroidSurfaceCreateInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub flags: VkAndroidSurfaceCreateFlagsKHR,
    pub window: *mut ANativeWindow,
}
impl_default_zeroed_with_s_type!(VkAndroidSurfaceCreateInfoKHR : VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR);

/// `VkAntiLagDataAMD`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkAntiLagDataAMD {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub mode: VkAntiLagModeAMD,
    pub maxFPS: uint32_t,
    pub pPresentationInfo: *const VkAntiLagPresentationInfoAMD,
}
impl_default_zeroed_with_s_type!(VkAntiLagDataAMD : VK_STRUCTURE_TYPE_ANTI_LAG_DATA_AMD);

from_into_transparent!(VkAntiLagModeAMD: i32);
/// `VkAntiLagModeAMD`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkAntiLagModeAMD(pub i32);

/// `0`  
pub const VK_ANTI_LAG_MODE_DRIVER_CONTROL_AMD: VkAntiLagModeAMD = VkAntiLagModeAMD(0);
/// `1`  
pub const VK_ANTI_LAG_MODE_ON_AMD: VkAntiLagModeAMD = VkAntiLagModeAMD(1);
/// `2`  
pub const VK_ANTI_LAG_MODE_OFF_AMD: VkAntiLagModeAMD = VkAntiLagModeAMD(2);

impl_enum_display!(VkAntiLagModeAMD { VK_ANTI_LAG_MODE_DRIVER_CONTROL_AMD, VK_ANTI_LAG_MODE_ON_AMD, VK_ANTI_LAG_MODE_OFF_AMD });

/// `VkAntiLagPresentationInfoAMD`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkAntiLagPresentationInfoAMD {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub stage: VkAntiLagStageAMD,
    pub frameIndex: uint64_t,
}
impl_default_zeroed_with_s_type!(VkAntiLagPresentationInfoAMD : VK_STRUCTURE_TYPE_ANTI_LAG_PRESENTATION_INFO_AMD);

from_into_transparent!(VkAntiLagStageAMD: i32);
/// `VkAntiLagStageAMD`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkAntiLagStageAMD(pub i32);

/// `0`  
pub const VK_ANTI_LAG_STAGE_INPUT_AMD: VkAntiLagStageAMD = VkAntiLagStageAMD(0);
/// `1`  
pub const VK_ANTI_LAG_STAGE_PRESENT_AMD: VkAntiLagStageAMD = VkAntiLagStageAMD(1);

impl_enum_display!(VkAntiLagStageAMD { VK_ANTI_LAG_STAGE_INPUT_AMD, VK_ANTI_LAG_STAGE_PRESENT_AMD });

/// `VkApplicationInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkApplicationInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub pApplicationName: *const c_char,
    pub applicationVersion: uint32_t,
    pub pEngineName: *const c_char,
    pub engineVersion: uint32_t,
    pub apiVersion: uint32_t,
}
impl_default_zeroed_with_s_type!(VkApplicationInfo : VK_STRUCTURE_TYPE_APPLICATION_INFO);

/// `VkApplicationParametersEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkApplicationParametersEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub vendorID: uint32_t,
    pub deviceID: uint32_t,
    pub key: uint32_t,
    pub value: uint64_t,
}
impl_default_zeroed_with_s_type!(VkApplicationParametersEXT : VK_STRUCTURE_TYPE_APPLICATION_PARAMETERS_EXT);
impl_extends!(VkApplicationParametersEXT : VkApplicationInfo, VkDeviceCreateInfo);

/// `VkAttachmentDescription`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkAttachmentDescription {
    pub flags: VkAttachmentDescriptionFlags,
    pub format: VkFormat,
    pub samples: VkSampleCountFlags,
    /// Load operation for color or depth data
    pub loadOp: VkAttachmentLoadOp,
    /// Store operation for color or depth data
    pub storeOp: VkAttachmentStoreOp,
    /// Load operation for stencil data
    pub stencilLoadOp: VkAttachmentLoadOp,
    /// Store operation for stencil data
    pub stencilStoreOp: VkAttachmentStoreOp,
    pub initialLayout: VkImageLayout,
    pub finalLayout: VkImageLayout,
}
impl_default_zeroed!(VkAttachmentDescription);

/// `VkAttachmentDescription2`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkAttachmentDescription2 {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub flags: VkAttachmentDescriptionFlags,
    pub format: VkFormat,
    pub samples: VkSampleCountFlags,
    /// Load operation for color or depth data
    pub loadOp: VkAttachmentLoadOp,
    /// Store operation for color or depth data
    pub storeOp: VkAttachmentStoreOp,
    /// Load operation for stencil data
    pub stencilLoadOp: VkAttachmentLoadOp,
    /// Store operation for stencil data
    pub stencilStoreOp: VkAttachmentStoreOp,
    pub initialLayout: VkImageLayout,
    pub finalLayout: VkImageLayout,
}
impl_default_zeroed_with_s_type!(VkAttachmentDescription2 : VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2);

/// `VkAttachmentDescription2`
pub type VkAttachmentDescription2KHR = VkAttachmentDescription2;

flags!(VkAttachmentDescriptionFlags);
from_into_transparent!(VkAttachmentDescriptionFlags: i32);
/// `VkAttachmentDescriptionFlags`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkAttachmentDescriptionFlags(pub i32);

/// `1 << 0`  
/// 
/// The attachment may alias physical memory of another attachment in the same render pass
pub const VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT: VkAttachmentDescriptionFlags = VkAttachmentDescriptionFlags(1 << 0);
/// `1 << 1`  
pub const VK_ATTACHMENT_DESCRIPTION_RESOLVE_SKIP_TRANSFER_FUNCTION_BIT_KHR: VkAttachmentDescriptionFlags = VkAttachmentDescriptionFlags(1 << 1);
/// `1 << 2`  
pub const VK_ATTACHMENT_DESCRIPTION_RESOLVE_ENABLE_TRANSFER_FUNCTION_BIT_KHR: VkAttachmentDescriptionFlags = VkAttachmentDescriptionFlags(1 << 2);

impl_flags_display!(VkAttachmentDescriptionFlags { VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT, VK_ATTACHMENT_DESCRIPTION_RESOLVE_SKIP_TRANSFER_FUNCTION_BIT_KHR, VK_ATTACHMENT_DESCRIPTION_RESOLVE_ENABLE_TRANSFER_FUNCTION_BIT_KHR });

/// `VkAttachmentDescriptionStencilLayout`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkAttachmentDescriptionStencilLayout {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub stencilInitialLayout: VkImageLayout,
    pub stencilFinalLayout: VkImageLayout,
}
impl_default_zeroed_with_s_type!(VkAttachmentDescriptionStencilLayout : VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT);
impl_extends!(VkAttachmentDescriptionStencilLayout : VkAttachmentDescription2);

/// `VkAttachmentDescriptionStencilLayout`
pub type VkAttachmentDescriptionStencilLayoutKHR = VkAttachmentDescriptionStencilLayout;

/// `VkAttachmentFeedbackLoopInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkAttachmentFeedbackLoopInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub feedbackLoopEnable: VkBool32,
}
impl_default_zeroed_with_s_type!(VkAttachmentFeedbackLoopInfoEXT : VK_STRUCTURE_TYPE_ATTACHMENT_FEEDBACK_LOOP_INFO_EXT);
impl_extends!(VkAttachmentFeedbackLoopInfoEXT : VkRenderingAttachmentInfo);

from_into_transparent!(VkAttachmentLoadOp: i32);
/// `VkAttachmentLoadOp`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkAttachmentLoadOp(pub i32);

/// `0`  
pub const VK_ATTACHMENT_LOAD_OP_LOAD: VkAttachmentLoadOp = VkAttachmentLoadOp(0);
/// `1`  
pub const VK_ATTACHMENT_LOAD_OP_CLEAR: VkAttachmentLoadOp = VkAttachmentLoadOp(1);
/// `2`  
pub const VK_ATTACHMENT_LOAD_OP_DONT_CARE: VkAttachmentLoadOp = VkAttachmentLoadOp(2);
/// `1000400000`  
pub const VK_ATTACHMENT_LOAD_OP_NONE: VkAttachmentLoadOp = VkAttachmentLoadOp(1000400000);
/// `VK_ATTACHMENT_LOAD_OP_NONE`  
pub const VK_ATTACHMENT_LOAD_OP_NONE_EXT: VkAttachmentLoadOp = VK_ATTACHMENT_LOAD_OP_NONE;
/// `VK_ATTACHMENT_LOAD_OP_NONE`  
pub const VK_ATTACHMENT_LOAD_OP_NONE_KHR: VkAttachmentLoadOp = VK_ATTACHMENT_LOAD_OP_NONE;

impl_enum_display!(VkAttachmentLoadOp { VK_ATTACHMENT_LOAD_OP_LOAD, VK_ATTACHMENT_LOAD_OP_CLEAR, VK_ATTACHMENT_LOAD_OP_DONT_CARE, VK_ATTACHMENT_LOAD_OP_NONE, VK_ATTACHMENT_LOAD_OP_NONE_EXT, VK_ATTACHMENT_LOAD_OP_NONE_KHR });

/// `VkAttachmentReference`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkAttachmentReference {
    pub attachment: uint32_t,
    pub layout: VkImageLayout,
}
impl_default_zeroed!(VkAttachmentReference);

/// `VkAttachmentReference2`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkAttachmentReference2 {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub attachment: uint32_t,
    pub layout: VkImageLayout,
    pub aspectMask: VkImageAspectFlags,
}
impl_default_zeroed_with_s_type!(VkAttachmentReference2 : VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2);

/// `VkAttachmentReference2`
pub type VkAttachmentReference2KHR = VkAttachmentReference2;

/// `VkAttachmentReferenceStencilLayout`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkAttachmentReferenceStencilLayout {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub stencilLayout: VkImageLayout,
}
impl_default_zeroed_with_s_type!(VkAttachmentReferenceStencilLayout : VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT);
impl_extends!(VkAttachmentReferenceStencilLayout : VkAttachmentReference2);

/// `VkAttachmentReferenceStencilLayout`
pub type VkAttachmentReferenceStencilLayoutKHR = VkAttachmentReferenceStencilLayout;

/// `VkAttachmentSampleCountInfoAMD`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkAttachmentSampleCountInfoAMD {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub colorAttachmentCount: uint32_t,
    pub pColorAttachmentSamples: *const VkSampleCountFlags,
    pub depthStencilAttachmentSamples: VkSampleCountFlags,
}
impl_default_zeroed_with_s_type!(VkAttachmentSampleCountInfoAMD : VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD);
impl_extends!(VkAttachmentSampleCountInfoAMD : VkCommandBufferInheritanceInfo, VkGraphicsPipelineCreateInfo);

/// `VkAttachmentSampleCountInfoAMD`
pub type VkAttachmentSampleCountInfoNV = VkAttachmentSampleCountInfoAMD;

/// `VkAttachmentSampleLocationsEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkAttachmentSampleLocationsEXT {
    pub attachmentIndex: uint32_t,
    pub sampleLocationsInfo: VkSampleLocationsInfoEXT,
}
impl_default_zeroed!(VkAttachmentSampleLocationsEXT);

from_into_transparent!(VkAttachmentStoreOp: i32);
/// `VkAttachmentStoreOp`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkAttachmentStoreOp(pub i32);

/// `0`  
pub const VK_ATTACHMENT_STORE_OP_STORE: VkAttachmentStoreOp = VkAttachmentStoreOp(0);
/// `1`  
pub const VK_ATTACHMENT_STORE_OP_DONT_CARE: VkAttachmentStoreOp = VkAttachmentStoreOp(1);
/// `1000301000`  
pub const VK_ATTACHMENT_STORE_OP_NONE: VkAttachmentStoreOp = VkAttachmentStoreOp(1000301000);
/// `VK_ATTACHMENT_STORE_OP_NONE`  
pub const VK_ATTACHMENT_STORE_OP_NONE_KHR: VkAttachmentStoreOp = VK_ATTACHMENT_STORE_OP_NONE;
/// `VK_ATTACHMENT_STORE_OP_NONE`  
pub const VK_ATTACHMENT_STORE_OP_NONE_QCOM: VkAttachmentStoreOp = VK_ATTACHMENT_STORE_OP_NONE;
/// `VK_ATTACHMENT_STORE_OP_NONE`  
pub const VK_ATTACHMENT_STORE_OP_NONE_EXT: VkAttachmentStoreOp = VK_ATTACHMENT_STORE_OP_NONE;

impl_enum_display!(VkAttachmentStoreOp { VK_ATTACHMENT_STORE_OP_STORE, VK_ATTACHMENT_STORE_OP_DONT_CARE, VK_ATTACHMENT_STORE_OP_NONE, VK_ATTACHMENT_STORE_OP_NONE_KHR, VK_ATTACHMENT_STORE_OP_NONE_QCOM, VK_ATTACHMENT_STORE_OP_NONE_EXT });

/// `VkBaseInStructure`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkBaseInStructure {
    pub sType: VkStructureType,
    pub pNext: *const VkBaseInStructure,
}
impl_default_zeroed!(VkBaseInStructure);

/// `VkBaseOutStructure`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkBaseOutStructure {
    pub sType: VkStructureType,
    pub pNext: *mut VkBaseOutStructure,
}
impl_default_zeroed!(VkBaseOutStructure);

/// `VkBeginCustomResolveInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkBeginCustomResolveInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
}
impl_default_zeroed_with_s_type!(VkBeginCustomResolveInfoEXT : VK_STRUCTURE_TYPE_BEGIN_CUSTOM_RESOLVE_INFO_EXT);

/// `VkBindAccelerationStructureMemoryInfoNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkBindAccelerationStructureMemoryInfoNV {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub accelerationStructure: VkAccelerationStructureNV,
    pub memory: VkDeviceMemory,
    pub memoryOffset: VkDeviceSize,
    pub deviceIndexCount: uint32_t,
    pub pDeviceIndices: *const uint32_t,
}
impl_default_zeroed_with_s_type!(VkBindAccelerationStructureMemoryInfoNV : VK_STRUCTURE_TYPE_BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV);

/// `VkBindBufferMemoryDeviceGroupInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkBindBufferMemoryDeviceGroupInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub deviceIndexCount: uint32_t,
    pub pDeviceIndices: *const uint32_t,
}
impl_default_zeroed_with_s_type!(VkBindBufferMemoryDeviceGroupInfo : VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO);
impl_extends!(VkBindBufferMemoryDeviceGroupInfo : VkBindBufferMemoryInfo);

/// `VkBindBufferMemoryDeviceGroupInfo`
pub type VkBindBufferMemoryDeviceGroupInfoKHR = VkBindBufferMemoryDeviceGroupInfo;

/// `VkBindBufferMemoryInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkBindBufferMemoryInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub buffer: VkBuffer,
    pub memory: VkDeviceMemory,
    pub memoryOffset: VkDeviceSize,
}
impl_default_zeroed_with_s_type!(VkBindBufferMemoryInfo : VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO);

/// `VkBindBufferMemoryInfo`
pub type VkBindBufferMemoryInfoKHR = VkBindBufferMemoryInfo;

/// `VkBindDataGraphPipelineSessionMemoryInfoARM`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkBindDataGraphPipelineSessionMemoryInfoARM {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub session: VkDataGraphPipelineSessionARM,
    pub bindPoint: VkDataGraphPipelineSessionBindPointARM,
    pub objectIndex: uint32_t,
    pub memory: VkDeviceMemory,
    pub memoryOffset: VkDeviceSize,
}
impl_default_zeroed_with_s_type!(VkBindDataGraphPipelineSessionMemoryInfoARM : VK_STRUCTURE_TYPE_BIND_DATA_GRAPH_PIPELINE_SESSION_MEMORY_INFO_ARM);

/// `VkBindDescriptorBufferEmbeddedSamplersInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkBindDescriptorBufferEmbeddedSamplersInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub stageFlags: VkShaderStageFlags,
    pub layout: VkPipelineLayout,
    pub set: uint32_t,
}
impl_default_zeroed_with_s_type!(VkBindDescriptorBufferEmbeddedSamplersInfoEXT : VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_BUFFER_EMBEDDED_SAMPLERS_INFO_EXT);

/// `VkBindDescriptorSetsInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkBindDescriptorSetsInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub stageFlags: VkShaderStageFlags,
    pub layout: VkPipelineLayout,
    pub firstSet: uint32_t,
    pub descriptorSetCount: uint32_t,
    pub pDescriptorSets: *const VkDescriptorSet,
    pub dynamicOffsetCount: uint32_t,
    pub pDynamicOffsets: *const uint32_t,
}
impl_default_zeroed_with_s_type!(VkBindDescriptorSetsInfo : VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_SETS_INFO);

/// `VkBindDescriptorSetsInfo`
pub type VkBindDescriptorSetsInfoKHR = VkBindDescriptorSetsInfo;

/// `VkBindHeapInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkBindHeapInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub heapRange: VkDeviceAddressRangeEXT,
    pub reservedRangeOffset: VkDeviceSize,
    pub reservedRangeSize: VkDeviceSize,
}
impl_default_zeroed_with_s_type!(VkBindHeapInfoEXT : VK_STRUCTURE_TYPE_BIND_HEAP_INFO_EXT);

/// `VkBindImageMemoryDeviceGroupInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkBindImageMemoryDeviceGroupInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub deviceIndexCount: uint32_t,
    pub pDeviceIndices: *const uint32_t,
    pub splitInstanceBindRegionCount: uint32_t,
    pub pSplitInstanceBindRegions: *const VkRect2D,
}
impl_default_zeroed_with_s_type!(VkBindImageMemoryDeviceGroupInfo : VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO);
impl_extends!(VkBindImageMemoryDeviceGroupInfo : VkBindImageMemoryInfo);

/// `VkBindImageMemoryDeviceGroupInfo`
pub type VkBindImageMemoryDeviceGroupInfoKHR = VkBindImageMemoryDeviceGroupInfo;

/// `VkBindImageMemoryInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkBindImageMemoryInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub image: VkImage,
    pub memory: VkDeviceMemory,
    pub memoryOffset: VkDeviceSize,
}
impl_default_zeroed_with_s_type!(VkBindImageMemoryInfo : VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO);

/// `VkBindImageMemoryInfo`
pub type VkBindImageMemoryInfoKHR = VkBindImageMemoryInfo;

/// `VkBindImageMemorySwapchainInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkBindImageMemorySwapchainInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub swapchain: VkSwapchainKHR,
    pub imageIndex: uint32_t,
}
impl_default_zeroed_with_s_type!(VkBindImageMemorySwapchainInfoKHR : VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR);
impl_extends!(VkBindImageMemorySwapchainInfoKHR : VkBindImageMemoryInfo);

/// `VkBindImagePlaneMemoryInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkBindImagePlaneMemoryInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub planeAspect: VkImageAspectFlags,
}
impl_default_zeroed_with_s_type!(VkBindImagePlaneMemoryInfo : VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO);
impl_extends!(VkBindImagePlaneMemoryInfo : VkBindImageMemoryInfo);

/// `VkBindImagePlaneMemoryInfo`
pub type VkBindImagePlaneMemoryInfoKHR = VkBindImagePlaneMemoryInfo;

/// `VkBindIndexBufferIndirectCommandEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkBindIndexBufferIndirectCommandEXT {
    pub bufferAddress: VkDeviceAddress,
    pub size: uint32_t,
    pub indexType: VkIndexType,
}
impl_default_zeroed!(VkBindIndexBufferIndirectCommandEXT);

/// `VkBindIndexBufferIndirectCommandNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkBindIndexBufferIndirectCommandNV {
    pub bufferAddress: VkDeviceAddress,
    pub size: uint32_t,
    pub indexType: VkIndexType,
}
impl_default_zeroed!(VkBindIndexBufferIndirectCommandNV);

/// `VkBindMemoryStatus`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkBindMemoryStatus {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub pResult: *mut VkResult,
}
impl_default_zeroed_with_s_type!(VkBindMemoryStatus : VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS);
impl_extends!(VkBindMemoryStatus : VkBindBufferMemoryInfo, VkBindImageMemoryInfo);

/// `VkBindMemoryStatus`
pub type VkBindMemoryStatusKHR = VkBindMemoryStatus;

/// `VkBindPipelineIndirectCommandNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkBindPipelineIndirectCommandNV {
    pub pipelineAddress: VkDeviceAddress,
}
impl_default_zeroed!(VkBindPipelineIndirectCommandNV);

/// `VkBindShaderGroupIndirectCommandNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkBindShaderGroupIndirectCommandNV {
    pub groupIndex: uint32_t,
}
impl_default_zeroed!(VkBindShaderGroupIndirectCommandNV);

/// `VkBindSparseInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkBindSparseInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub waitSemaphoreCount: uint32_t,
    pub pWaitSemaphores: *const VkSemaphore,
    pub bufferBindCount: uint32_t,
    pub pBufferBinds: *const VkSparseBufferMemoryBindInfo,
    pub imageOpaqueBindCount: uint32_t,
    pub pImageOpaqueBinds: *const VkSparseImageOpaqueMemoryBindInfo,
    pub imageBindCount: uint32_t,
    pub pImageBinds: *const VkSparseImageMemoryBindInfo,
    pub signalSemaphoreCount: uint32_t,
    pub pSignalSemaphores: *const VkSemaphore,
}
impl_default_zeroed_with_s_type!(VkBindSparseInfo : VK_STRUCTURE_TYPE_BIND_SPARSE_INFO);

/// `VkBindTensorMemoryInfoARM`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkBindTensorMemoryInfoARM {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub tensor: VkTensorARM,
    pub memory: VkDeviceMemory,
    pub memoryOffset: VkDeviceSize,
}
impl_default_zeroed_with_s_type!(VkBindTensorMemoryInfoARM : VK_STRUCTURE_TYPE_BIND_TENSOR_MEMORY_INFO_ARM);

/// `VkBindVertexBufferIndirectCommandEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkBindVertexBufferIndirectCommandEXT {
    pub bufferAddress: VkDeviceAddress,
    pub size: uint32_t,
    pub stride: uint32_t,
}
impl_default_zeroed!(VkBindVertexBufferIndirectCommandEXT);

/// `VkBindVertexBufferIndirectCommandNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkBindVertexBufferIndirectCommandNV {
    pub bufferAddress: VkDeviceAddress,
    pub size: uint32_t,
    pub stride: uint32_t,
}
impl_default_zeroed!(VkBindVertexBufferIndirectCommandNV);

/// `VkBindVideoSessionMemoryInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkBindVideoSessionMemoryInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub memoryBindIndex: uint32_t,
    pub memory: VkDeviceMemory,
    pub memoryOffset: VkDeviceSize,
    pub memorySize: VkDeviceSize,
}
impl_default_zeroed_with_s_type!(VkBindVideoSessionMemoryInfoKHR : VK_STRUCTURE_TYPE_BIND_VIDEO_SESSION_MEMORY_INFO_KHR);

from_into_transparent!(VkBlendFactor: i32);
/// `VkBlendFactor`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkBlendFactor(pub i32);

/// `0`  
pub const VK_BLEND_FACTOR_ZERO: VkBlendFactor = VkBlendFactor(0);
/// `1`  
pub const VK_BLEND_FACTOR_ONE: VkBlendFactor = VkBlendFactor(1);
/// `2`  
pub const VK_BLEND_FACTOR_SRC_COLOR: VkBlendFactor = VkBlendFactor(2);
/// `3`  
pub const VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR: VkBlendFactor = VkBlendFactor(3);
/// `4`  
pub const VK_BLEND_FACTOR_DST_COLOR: VkBlendFactor = VkBlendFactor(4);
/// `5`  
pub const VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR: VkBlendFactor = VkBlendFactor(5);
/// `6`  
pub const VK_BLEND_FACTOR_SRC_ALPHA: VkBlendFactor = VkBlendFactor(6);
/// `7`  
pub const VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA: VkBlendFactor = VkBlendFactor(7);
/// `8`  
pub const VK_BLEND_FACTOR_DST_ALPHA: VkBlendFactor = VkBlendFactor(8);
/// `9`  
pub const VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA: VkBlendFactor = VkBlendFactor(9);
/// `10`  
pub const VK_BLEND_FACTOR_CONSTANT_COLOR: VkBlendFactor = VkBlendFactor(10);
/// `11`  
pub const VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR: VkBlendFactor = VkBlendFactor(11);
/// `12`  
pub const VK_BLEND_FACTOR_CONSTANT_ALPHA: VkBlendFactor = VkBlendFactor(12);
/// `13`  
pub const VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA: VkBlendFactor = VkBlendFactor(13);
/// `14`  
pub const VK_BLEND_FACTOR_SRC_ALPHA_SATURATE: VkBlendFactor = VkBlendFactor(14);
/// `15`  
pub const VK_BLEND_FACTOR_SRC1_COLOR: VkBlendFactor = VkBlendFactor(15);
/// `16`  
pub const VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR: VkBlendFactor = VkBlendFactor(16);
/// `17`  
pub const VK_BLEND_FACTOR_SRC1_ALPHA: VkBlendFactor = VkBlendFactor(17);
/// `18`  
pub const VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA: VkBlendFactor = VkBlendFactor(18);

impl_enum_display!(VkBlendFactor { VK_BLEND_FACTOR_ZERO, VK_BLEND_FACTOR_ONE, VK_BLEND_FACTOR_SRC_COLOR, VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR, VK_BLEND_FACTOR_DST_COLOR, VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR, VK_BLEND_FACTOR_SRC_ALPHA, VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA, VK_BLEND_FACTOR_DST_ALPHA, VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA, VK_BLEND_FACTOR_CONSTANT_COLOR, VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR, VK_BLEND_FACTOR_CONSTANT_ALPHA, VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA, VK_BLEND_FACTOR_SRC_ALPHA_SATURATE, VK_BLEND_FACTOR_SRC1_COLOR, VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR, VK_BLEND_FACTOR_SRC1_ALPHA, VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA });

from_into_transparent!(VkBlendOp: i32);
/// `VkBlendOp`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkBlendOp(pub i32);

/// `0`  
pub const VK_BLEND_OP_ADD: VkBlendOp = VkBlendOp(0);
/// `1`  
pub const VK_BLEND_OP_SUBTRACT: VkBlendOp = VkBlendOp(1);
/// `2`  
pub const VK_BLEND_OP_REVERSE_SUBTRACT: VkBlendOp = VkBlendOp(2);
/// `3`  
pub const VK_BLEND_OP_MIN: VkBlendOp = VkBlendOp(3);
/// `4`  
pub const VK_BLEND_OP_MAX: VkBlendOp = VkBlendOp(4);
/// `1000148000`  
pub const VK_BLEND_OP_ZERO_EXT: VkBlendOp = VkBlendOp(1000148000);
/// `1000148001`  
pub const VK_BLEND_OP_SRC_EXT: VkBlendOp = VkBlendOp(1000148001);
/// `1000148002`  
pub const VK_BLEND_OP_DST_EXT: VkBlendOp = VkBlendOp(1000148002);
/// `1000148003`  
pub const VK_BLEND_OP_SRC_OVER_EXT: VkBlendOp = VkBlendOp(1000148003);
/// `1000148004`  
pub const VK_BLEND_OP_DST_OVER_EXT: VkBlendOp = VkBlendOp(1000148004);
/// `1000148005`  
pub const VK_BLEND_OP_SRC_IN_EXT: VkBlendOp = VkBlendOp(1000148005);
/// `1000148006`  
pub const VK_BLEND_OP_DST_IN_EXT: VkBlendOp = VkBlendOp(1000148006);
/// `1000148007`  
pub const VK_BLEND_OP_SRC_OUT_EXT: VkBlendOp = VkBlendOp(1000148007);
/// `1000148008`  
pub const VK_BLEND_OP_DST_OUT_EXT: VkBlendOp = VkBlendOp(1000148008);
/// `1000148009`  
pub const VK_BLEND_OP_SRC_ATOP_EXT: VkBlendOp = VkBlendOp(1000148009);
/// `1000148010`  
pub const VK_BLEND_OP_DST_ATOP_EXT: VkBlendOp = VkBlendOp(1000148010);
/// `1000148011`  
pub const VK_BLEND_OP_XOR_EXT: VkBlendOp = VkBlendOp(1000148011);
/// `1000148012`  
pub const VK_BLEND_OP_MULTIPLY_EXT: VkBlendOp = VkBlendOp(1000148012);
/// `1000148013`  
pub const VK_BLEND_OP_SCREEN_EXT: VkBlendOp = VkBlendOp(1000148013);
/// `1000148014`  
pub const VK_BLEND_OP_OVERLAY_EXT: VkBlendOp = VkBlendOp(1000148014);
/// `1000148015`  
pub const VK_BLEND_OP_DARKEN_EXT: VkBlendOp = VkBlendOp(1000148015);
/// `1000148016`  
pub const VK_BLEND_OP_LIGHTEN_EXT: VkBlendOp = VkBlendOp(1000148016);
/// `1000148017`  
pub const VK_BLEND_OP_COLORDODGE_EXT: VkBlendOp = VkBlendOp(1000148017);
/// `1000148018`  
pub const VK_BLEND_OP_COLORBURN_EXT: VkBlendOp = VkBlendOp(1000148018);
/// `1000148019`  
pub const VK_BLEND_OP_HARDLIGHT_EXT: VkBlendOp = VkBlendOp(1000148019);
/// `1000148020`  
pub const VK_BLEND_OP_SOFTLIGHT_EXT: VkBlendOp = VkBlendOp(1000148020);
/// `1000148021`  
pub const VK_BLEND_OP_DIFFERENCE_EXT: VkBlendOp = VkBlendOp(1000148021);
/// `1000148022`  
pub const VK_BLEND_OP_EXCLUSION_EXT: VkBlendOp = VkBlendOp(1000148022);
/// `1000148023`  
pub const VK_BLEND_OP_INVERT_EXT: VkBlendOp = VkBlendOp(1000148023);
/// `1000148024`  
pub const VK_BLEND_OP_INVERT_RGB_EXT: VkBlendOp = VkBlendOp(1000148024);
/// `1000148025`  
pub const VK_BLEND_OP_LINEARDODGE_EXT: VkBlendOp = VkBlendOp(1000148025);
/// `1000148026`  
pub const VK_BLEND_OP_LINEARBURN_EXT: VkBlendOp = VkBlendOp(1000148026);
/// `1000148027`  
pub const VK_BLEND_OP_VIVIDLIGHT_EXT: VkBlendOp = VkBlendOp(1000148027);
/// `1000148028`  
pub const VK_BLEND_OP_LINEARLIGHT_EXT: VkBlendOp = VkBlendOp(1000148028);
/// `1000148029`  
pub const VK_BLEND_OP_PINLIGHT_EXT: VkBlendOp = VkBlendOp(1000148029);
/// `1000148030`  
pub const VK_BLEND_OP_HARDMIX_EXT: VkBlendOp = VkBlendOp(1000148030);
/// `1000148031`  
pub const VK_BLEND_OP_HSL_HUE_EXT: VkBlendOp = VkBlendOp(1000148031);
/// `1000148032`  
pub const VK_BLEND_OP_HSL_SATURATION_EXT: VkBlendOp = VkBlendOp(1000148032);
/// `1000148033`  
pub const VK_BLEND_OP_HSL_COLOR_EXT: VkBlendOp = VkBlendOp(1000148033);
/// `1000148034`  
pub const VK_BLEND_OP_HSL_LUMINOSITY_EXT: VkBlendOp = VkBlendOp(1000148034);
/// `1000148035`  
pub const VK_BLEND_OP_PLUS_EXT: VkBlendOp = VkBlendOp(1000148035);
/// `1000148036`  
pub const VK_BLEND_OP_PLUS_CLAMPED_EXT: VkBlendOp = VkBlendOp(1000148036);
/// `1000148037`  
pub const VK_BLEND_OP_PLUS_CLAMPED_ALPHA_EXT: VkBlendOp = VkBlendOp(1000148037);
/// `1000148038`  
pub const VK_BLEND_OP_PLUS_DARKER_EXT: VkBlendOp = VkBlendOp(1000148038);
/// `1000148039`  
pub const VK_BLEND_OP_MINUS_EXT: VkBlendOp = VkBlendOp(1000148039);
/// `1000148040`  
pub const VK_BLEND_OP_MINUS_CLAMPED_EXT: VkBlendOp = VkBlendOp(1000148040);
/// `1000148041`  
pub const VK_BLEND_OP_CONTRAST_EXT: VkBlendOp = VkBlendOp(1000148041);
/// `1000148042`  
pub const VK_BLEND_OP_INVERT_OVG_EXT: VkBlendOp = VkBlendOp(1000148042);
/// `1000148043`  
pub const VK_BLEND_OP_RED_EXT: VkBlendOp = VkBlendOp(1000148043);
/// `1000148044`  
pub const VK_BLEND_OP_GREEN_EXT: VkBlendOp = VkBlendOp(1000148044);
/// `1000148045`  
pub const VK_BLEND_OP_BLUE_EXT: VkBlendOp = VkBlendOp(1000148045);

impl_enum_display!(VkBlendOp { VK_BLEND_OP_ADD, VK_BLEND_OP_SUBTRACT, VK_BLEND_OP_REVERSE_SUBTRACT, VK_BLEND_OP_MIN, VK_BLEND_OP_MAX, VK_BLEND_OP_ZERO_EXT, VK_BLEND_OP_SRC_EXT, VK_BLEND_OP_DST_EXT, VK_BLEND_OP_SRC_OVER_EXT, VK_BLEND_OP_DST_OVER_EXT, VK_BLEND_OP_SRC_IN_EXT, VK_BLEND_OP_DST_IN_EXT, VK_BLEND_OP_SRC_OUT_EXT, VK_BLEND_OP_DST_OUT_EXT, VK_BLEND_OP_SRC_ATOP_EXT, VK_BLEND_OP_DST_ATOP_EXT, VK_BLEND_OP_XOR_EXT, VK_BLEND_OP_MULTIPLY_EXT, VK_BLEND_OP_SCREEN_EXT, VK_BLEND_OP_OVERLAY_EXT, VK_BLEND_OP_DARKEN_EXT, VK_BLEND_OP_LIGHTEN_EXT, VK_BLEND_OP_COLORDODGE_EXT, VK_BLEND_OP_COLORBURN_EXT, VK_BLEND_OP_HARDLIGHT_EXT, VK_BLEND_OP_SOFTLIGHT_EXT, VK_BLEND_OP_DIFFERENCE_EXT, VK_BLEND_OP_EXCLUSION_EXT, VK_BLEND_OP_INVERT_EXT, VK_BLEND_OP_INVERT_RGB_EXT, VK_BLEND_OP_LINEARDODGE_EXT, VK_BLEND_OP_LINEARBURN_EXT, VK_BLEND_OP_VIVIDLIGHT_EXT, VK_BLEND_OP_LINEARLIGHT_EXT, VK_BLEND_OP_PINLIGHT_EXT, VK_BLEND_OP_HARDMIX_EXT, VK_BLEND_OP_HSL_HUE_EXT, VK_BLEND_OP_HSL_SATURATION_EXT, VK_BLEND_OP_HSL_COLOR_EXT, VK_BLEND_OP_HSL_LUMINOSITY_EXT, VK_BLEND_OP_PLUS_EXT, VK_BLEND_OP_PLUS_CLAMPED_EXT, VK_BLEND_OP_PLUS_CLAMPED_ALPHA_EXT, VK_BLEND_OP_PLUS_DARKER_EXT, VK_BLEND_OP_MINUS_EXT, VK_BLEND_OP_MINUS_CLAMPED_EXT, VK_BLEND_OP_CONTRAST_EXT, VK_BLEND_OP_INVERT_OVG_EXT, VK_BLEND_OP_RED_EXT, VK_BLEND_OP_GREEN_EXT, VK_BLEND_OP_BLUE_EXT });

from_into_transparent!(VkBlendOverlapEXT: i32);
/// `VkBlendOverlapEXT`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkBlendOverlapEXT(pub i32);

/// `0`  
pub const VK_BLEND_OVERLAP_UNCORRELATED_EXT: VkBlendOverlapEXT = VkBlendOverlapEXT(0);
/// `1`  
pub const VK_BLEND_OVERLAP_DISJOINT_EXT: VkBlendOverlapEXT = VkBlendOverlapEXT(1);
/// `2`  
pub const VK_BLEND_OVERLAP_CONJOINT_EXT: VkBlendOverlapEXT = VkBlendOverlapEXT(2);

impl_enum_display!(VkBlendOverlapEXT { VK_BLEND_OVERLAP_UNCORRELATED_EXT, VK_BLEND_OVERLAP_DISJOINT_EXT, VK_BLEND_OVERLAP_CONJOINT_EXT });

/// `VkBlitImageCubicWeightsInfoQCOM`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkBlitImageCubicWeightsInfoQCOM {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub cubicWeights: VkCubicFilterWeightsQCOM,
}
impl_default_zeroed_with_s_type!(VkBlitImageCubicWeightsInfoQCOM : VK_STRUCTURE_TYPE_BLIT_IMAGE_CUBIC_WEIGHTS_INFO_QCOM);
impl_extends!(VkBlitImageCubicWeightsInfoQCOM : VkBlitImageInfo2);

/// `VkBlitImageInfo2`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkBlitImageInfo2 {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub srcImage: VkImage,
    pub srcImageLayout: VkImageLayout,
    pub dstImage: VkImage,
    pub dstImageLayout: VkImageLayout,
    pub regionCount: uint32_t,
    pub pRegions: *const VkImageBlit2,
    pub filter: VkFilter,
}
impl_default_zeroed_with_s_type!(VkBlitImageInfo2 : VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2);

/// `VkBlitImageInfo2`
pub type VkBlitImageInfo2KHR = VkBlitImageInfo2;

from_into_transparent!(VkBlockMatchWindowCompareModeQCOM: i32);
/// `VkBlockMatchWindowCompareModeQCOM`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkBlockMatchWindowCompareModeQCOM(pub i32);

/// `0`  
pub const VK_BLOCK_MATCH_WINDOW_COMPARE_MODE_MIN_QCOM: VkBlockMatchWindowCompareModeQCOM = VkBlockMatchWindowCompareModeQCOM(0);
/// `1`  
pub const VK_BLOCK_MATCH_WINDOW_COMPARE_MODE_MAX_QCOM: VkBlockMatchWindowCompareModeQCOM = VkBlockMatchWindowCompareModeQCOM(1);

impl_enum_display!(VkBlockMatchWindowCompareModeQCOM { VK_BLOCK_MATCH_WINDOW_COMPARE_MODE_MIN_QCOM, VK_BLOCK_MATCH_WINDOW_COMPARE_MODE_MAX_QCOM });

from_into_transparent!(VkBorderColor: i32);
/// `VkBorderColor`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkBorderColor(pub i32);

/// `0`  
pub const VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK: VkBorderColor = VkBorderColor(0);
/// `1`  
pub const VK_BORDER_COLOR_INT_TRANSPARENT_BLACK: VkBorderColor = VkBorderColor(1);
/// `2`  
pub const VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK: VkBorderColor = VkBorderColor(2);
/// `3`  
pub const VK_BORDER_COLOR_INT_OPAQUE_BLACK: VkBorderColor = VkBorderColor(3);
/// `4`  
pub const VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE: VkBorderColor = VkBorderColor(4);
/// `5`  
pub const VK_BORDER_COLOR_INT_OPAQUE_WHITE: VkBorderColor = VkBorderColor(5);
/// `1000287003`  
pub const VK_BORDER_COLOR_FLOAT_CUSTOM_EXT: VkBorderColor = VkBorderColor(1000287003);
/// `1000287004`  
pub const VK_BORDER_COLOR_INT_CUSTOM_EXT: VkBorderColor = VkBorderColor(1000287004);

impl_enum_display!(VkBorderColor { VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK, VK_BORDER_COLOR_INT_TRANSPARENT_BLACK, VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK, VK_BORDER_COLOR_INT_OPAQUE_BLACK, VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE, VK_BORDER_COLOR_INT_OPAQUE_WHITE, VK_BORDER_COLOR_FLOAT_CUSTOM_EXT, VK_BORDER_COLOR_INT_CUSTOM_EXT });

/// `VkBuffer` : `VkDevice`
#[repr(transparent)]
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkBuffer(pub u64);
from_into_transparent!(VkBuffer: u64);
impl_handle!(VkBuffer: VK_OBJECT_TYPE_BUFFER; SubHandle = VkDevice);

/// `VkBufferCaptureDescriptorDataInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkBufferCaptureDescriptorDataInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub buffer: VkBuffer,
}
impl_default_zeroed_with_s_type!(VkBufferCaptureDescriptorDataInfoEXT : VK_STRUCTURE_TYPE_BUFFER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT);

/// `VkBufferCollectionBufferCreateInfoFUCHSIA`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkBufferCollectionBufferCreateInfoFUCHSIA {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub collection: VkBufferCollectionFUCHSIA,
    pub index: uint32_t,
}
impl_default_zeroed_with_s_type!(VkBufferCollectionBufferCreateInfoFUCHSIA : VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA);
impl_extends!(VkBufferCollectionBufferCreateInfoFUCHSIA : VkBufferCreateInfo);

/// `VkBufferCollectionConstraintsInfoFUCHSIA`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkBufferCollectionConstraintsInfoFUCHSIA {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub minBufferCount: uint32_t,
    pub maxBufferCount: uint32_t,
    pub minBufferCountForCamping: uint32_t,
    pub minBufferCountForDedicatedSlack: uint32_t,
    pub minBufferCountForSharedSlack: uint32_t,
}
impl_default_zeroed_with_s_type!(VkBufferCollectionConstraintsInfoFUCHSIA : VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CONSTRAINTS_INFO_FUCHSIA);

/// `VkBufferCollectionCreateInfoFUCHSIA`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkBufferCollectionCreateInfoFUCHSIA {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub collectionToken: zx_handle_t,
}
impl_default_zeroed_with_s_type!(VkBufferCollectionCreateInfoFUCHSIA : VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CREATE_INFO_FUCHSIA);

/// `VkBufferCollectionFUCHSIA` : `VkDevice`
#[repr(transparent)]
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkBufferCollectionFUCHSIA(pub u64);
from_into_transparent!(VkBufferCollectionFUCHSIA: u64);
impl_handle!(VkBufferCollectionFUCHSIA: VK_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIA; SubHandle = VkDevice);

/// `VkBufferCollectionImageCreateInfoFUCHSIA`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkBufferCollectionImageCreateInfoFUCHSIA {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub collection: VkBufferCollectionFUCHSIA,
    pub index: uint32_t,
}
impl_default_zeroed_with_s_type!(VkBufferCollectionImageCreateInfoFUCHSIA : VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA);
impl_extends!(VkBufferCollectionImageCreateInfoFUCHSIA : VkImageCreateInfo);

/// `VkBufferCollectionPropertiesFUCHSIA`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkBufferCollectionPropertiesFUCHSIA {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub memoryTypeBits: uint32_t,
    pub bufferCount: uint32_t,
    pub createInfoIndex: uint32_t,
    pub sysmemPixelFormat: uint64_t,
    pub formatFeatures: VkFormatFeatureFlags,
    pub sysmemColorSpaceIndex: VkSysmemColorSpaceFUCHSIA,
    pub samplerYcbcrConversionComponents: VkComponentMapping,
    pub suggestedYcbcrModel: VkSamplerYcbcrModelConversion,
    pub suggestedYcbcrRange: VkSamplerYcbcrRange,
    pub suggestedXChromaOffset: VkChromaLocation,
    pub suggestedYChromaOffset: VkChromaLocation,
}
impl_default_zeroed_with_s_type!(VkBufferCollectionPropertiesFUCHSIA : VK_STRUCTURE_TYPE_BUFFER_COLLECTION_PROPERTIES_FUCHSIA);

/// `VkBufferConstraintsInfoFUCHSIA`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkBufferConstraintsInfoFUCHSIA {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub createInfo: VkBufferCreateInfo,
    pub requiredFormatFeatures: VkFormatFeatureFlags,
    pub bufferCollectionConstraints: VkBufferCollectionConstraintsInfoFUCHSIA,
}
impl_default_zeroed_with_s_type!(VkBufferConstraintsInfoFUCHSIA : VK_STRUCTURE_TYPE_BUFFER_CONSTRAINTS_INFO_FUCHSIA);

/// `VkBufferCopy`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkBufferCopy {
    /// Specified in bytes
    pub srcOffset: VkDeviceSize,
    /// Specified in bytes
    pub dstOffset: VkDeviceSize,
    /// Specified in bytes
    pub size: VkDeviceSize,
}
impl_default_zeroed!(VkBufferCopy);

/// `VkBufferCopy2`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkBufferCopy2 {
    pub sType: VkStructureType,
    pub pNext: *const void,
    /// Specified in bytes
    pub srcOffset: VkDeviceSize,
    /// Specified in bytes
    pub dstOffset: VkDeviceSize,
    /// Specified in bytes
    pub size: VkDeviceSize,
}
impl_default_zeroed_with_s_type!(VkBufferCopy2 : VK_STRUCTURE_TYPE_BUFFER_COPY_2);

/// `VkBufferCopy2`
pub type VkBufferCopy2KHR = VkBufferCopy2;

flags!(VkBufferCreateFlags);
from_into_transparent!(VkBufferCreateFlags: i32);
/// `VkBufferCreateFlags`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkBufferCreateFlags(pub i32);

/// `1 << 0`  
/// 
/// Buffer should support sparse backing
pub const VK_BUFFER_CREATE_SPARSE_BINDING_BIT: VkBufferCreateFlags = VkBufferCreateFlags(1 << 0);
/// `1 << 1`  
/// 
/// Buffer should support sparse backing with partial residency
pub const VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT: VkBufferCreateFlags = VkBufferCreateFlags(1 << 1);
/// `1 << 2`  
/// 
/// Buffer should support constant data access to physical memory ranges mapped into multiple locations of sparse buffers
pub const VK_BUFFER_CREATE_SPARSE_ALIASED_BIT: VkBufferCreateFlags = VkBufferCreateFlags(1 << 2);
/// `1 << 3`  
/// 
/// Buffer requires protected memory
pub const VK_BUFFER_CREATE_PROTECTED_BIT: VkBufferCreateFlags = VkBufferCreateFlags(1 << 3);
/// `1 << 4`  
pub const VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT: VkBufferCreateFlags = VkBufferCreateFlags(1 << 4);
/// `1 << 7`  
pub const VK_BUFFER_CREATE_RESERVED_7_BIT_IMG: VkBufferCreateFlags = VkBufferCreateFlags(1 << 7);
/// `VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT`  
pub const VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_EXT: VkBufferCreateFlags = VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT;
/// `VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT`  
pub const VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR: VkBufferCreateFlags = VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT;
/// `1 << 5`  
pub const VK_BUFFER_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT: VkBufferCreateFlags = VkBufferCreateFlags(1 << 5);
/// `1 << 6`  
pub const VK_BUFFER_CREATE_VIDEO_PROFILE_INDEPENDENT_BIT_KHR: VkBufferCreateFlags = VkBufferCreateFlags(1 << 6);

impl_flags_display!(VkBufferCreateFlags { VK_BUFFER_CREATE_SPARSE_BINDING_BIT, VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT, VK_BUFFER_CREATE_SPARSE_ALIASED_BIT, VK_BUFFER_CREATE_PROTECTED_BIT, VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT, VK_BUFFER_CREATE_RESERVED_7_BIT_IMG, VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_EXT, VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR, VK_BUFFER_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT, VK_BUFFER_CREATE_VIDEO_PROFILE_INDEPENDENT_BIT_KHR });

/// `VkBufferCreateInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkBufferCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    /// Buffer creation flags
    pub flags: VkBufferCreateFlags,
    /// Specified in bytes
    pub size: VkDeviceSize,
    /// Buffer usage flags
    pub usage: VkBufferUsageFlags,
    pub sharingMode: VkSharingMode,
    pub queueFamilyIndexCount: uint32_t,
    pub pQueueFamilyIndices: *const uint32_t,
}
impl_default_zeroed_with_s_type!(VkBufferCreateInfo : VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO);

/// `VkBufferDeviceAddressCreateInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkBufferDeviceAddressCreateInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub deviceAddress: VkDeviceAddress,
}
impl_default_zeroed_with_s_type!(VkBufferDeviceAddressCreateInfoEXT : VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT);
impl_extends!(VkBufferDeviceAddressCreateInfoEXT : VkBufferCreateInfo);

/// `VkBufferDeviceAddressInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkBufferDeviceAddressInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub buffer: VkBuffer,
}
impl_default_zeroed_with_s_type!(VkBufferDeviceAddressInfo : VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO);

/// `VkBufferDeviceAddressInfo`
pub type VkBufferDeviceAddressInfoEXT = VkBufferDeviceAddressInfo;

/// `VkBufferDeviceAddressInfo`
pub type VkBufferDeviceAddressInfoKHR = VkBufferDeviceAddressInfo;

/// `VkBufferImageCopy`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkBufferImageCopy {
    /// Specified in bytes
    pub bufferOffset: VkDeviceSize,
    /// Specified in texels
    pub bufferRowLength: uint32_t,
    pub bufferImageHeight: uint32_t,
    pub imageSubresource: VkImageSubresourceLayers,
    /// Specified in pixels for both compressed and uncompressed images
    pub imageOffset: VkOffset3D,
    /// Specified in pixels for both compressed and uncompressed images
    pub imageExtent: VkExtent3D,
}
impl_default_zeroed!(VkBufferImageCopy);

/// `VkBufferImageCopy2`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkBufferImageCopy2 {
    pub sType: VkStructureType,
    pub pNext: *const void,
    /// Specified in bytes
    pub bufferOffset: VkDeviceSize,
    /// Specified in texels
    pub bufferRowLength: uint32_t,
    pub bufferImageHeight: uint32_t,
    pub imageSubresource: VkImageSubresourceLayers,
    /// Specified in pixels for both compressed and uncompressed images
    pub imageOffset: VkOffset3D,
    /// Specified in pixels for both compressed and uncompressed images
    pub imageExtent: VkExtent3D,
}
impl_default_zeroed_with_s_type!(VkBufferImageCopy2 : VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2);

/// `VkBufferImageCopy2`
pub type VkBufferImageCopy2KHR = VkBufferImageCopy2;

/// `VkBufferMemoryBarrier`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkBufferMemoryBarrier {
    pub sType: VkStructureType,
    pub pNext: *const void,
    /// Memory accesses from the source of the dependency to synchronize
    pub srcAccessMask: VkAccessFlags,
    /// Memory accesses from the destination of the dependency to synchronize
    pub dstAccessMask: VkAccessFlags,
    /// Queue family to transition ownership from
    pub srcQueueFamilyIndex: uint32_t,
    /// Queue family to transition ownership to
    pub dstQueueFamilyIndex: uint32_t,
    /// Buffer to sync
    pub buffer: VkBuffer,
    /// Offset within the buffer to sync
    pub offset: VkDeviceSize,
    /// Amount of bytes to sync
    pub size: VkDeviceSize,
}
impl_default_zeroed_with_s_type!(VkBufferMemoryBarrier : VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER);

/// `VkBufferMemoryBarrier2`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkBufferMemoryBarrier2 {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub srcStageMask: VkPipelineStageFlags2,
    pub srcAccessMask: VkAccessFlags2,
    pub dstStageMask: VkPipelineStageFlags2,
    pub dstAccessMask: VkAccessFlags2,
    pub srcQueueFamilyIndex: uint32_t,
    pub dstQueueFamilyIndex: uint32_t,
    pub buffer: VkBuffer,
    pub offset: VkDeviceSize,
    pub size: VkDeviceSize,
}
impl_default_zeroed_with_s_type!(VkBufferMemoryBarrier2 : VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2);

/// `VkBufferMemoryBarrier2`
pub type VkBufferMemoryBarrier2KHR = VkBufferMemoryBarrier2;

/// `VkBufferMemoryRequirementsInfo2`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkBufferMemoryRequirementsInfo2 {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub buffer: VkBuffer,
}
impl_default_zeroed_with_s_type!(VkBufferMemoryRequirementsInfo2 : VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2);

/// `VkBufferMemoryRequirementsInfo2`
pub type VkBufferMemoryRequirementsInfo2KHR = VkBufferMemoryRequirementsInfo2;

/// `VkBufferOpaqueCaptureAddressCreateInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkBufferOpaqueCaptureAddressCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub opaqueCaptureAddress: uint64_t,
}
impl_default_zeroed_with_s_type!(VkBufferOpaqueCaptureAddressCreateInfo : VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO);
impl_extends!(VkBufferOpaqueCaptureAddressCreateInfo : VkBufferCreateInfo);

/// `VkBufferOpaqueCaptureAddressCreateInfo`
pub type VkBufferOpaqueCaptureAddressCreateInfoKHR = VkBufferOpaqueCaptureAddressCreateInfo;

flags!(VkBufferUsageFlags);
from_into_transparent!(VkBufferUsageFlags: i32);
/// `VkBufferUsageFlags`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkBufferUsageFlags(pub i32);

/// `1 << 0`  
/// 
/// Can be used as a source of transfer operations
pub const VK_BUFFER_USAGE_TRANSFER_SRC_BIT: VkBufferUsageFlags = VkBufferUsageFlags(1 << 0);
/// `1 << 1`  
/// 
/// Can be used as a destination of transfer operations
pub const VK_BUFFER_USAGE_TRANSFER_DST_BIT: VkBufferUsageFlags = VkBufferUsageFlags(1 << 1);
/// `1 << 2`  
/// 
/// Can be used as TBO
pub const VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT: VkBufferUsageFlags = VkBufferUsageFlags(1 << 2);
/// `1 << 3`  
/// 
/// Can be used as IBO
pub const VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT: VkBufferUsageFlags = VkBufferUsageFlags(1 << 3);
/// `1 << 4`  
/// 
/// Can be used as UBO
pub const VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT: VkBufferUsageFlags = VkBufferUsageFlags(1 << 4);
/// `1 << 5`  
/// 
/// Can be used as SSBO
pub const VK_BUFFER_USAGE_STORAGE_BUFFER_BIT: VkBufferUsageFlags = VkBufferUsageFlags(1 << 5);
/// `1 << 6`  
/// 
/// Can be used as source of fixed-function index fetch (index buffer)
pub const VK_BUFFER_USAGE_INDEX_BUFFER_BIT: VkBufferUsageFlags = VkBufferUsageFlags(1 << 6);
/// `1 << 7`  
/// 
/// Can be used as source of fixed-function vertex fetch (VBO)
pub const VK_BUFFER_USAGE_VERTEX_BUFFER_BIT: VkBufferUsageFlags = VkBufferUsageFlags(1 << 7);
/// `1 << 8`  
/// 
/// Can be the source of indirect parameters (e.g. indirect buffer, parameter buffer)
pub const VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT: VkBufferUsageFlags = VkBufferUsageFlags(1 << 8);
/// `1 << 17`  
pub const VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT: VkBufferUsageFlags = VkBufferUsageFlags(1 << 17);
/// `1 << 13`  
pub const VK_BUFFER_USAGE_VIDEO_DECODE_SRC_BIT_KHR: VkBufferUsageFlags = VkBufferUsageFlags(1 << 13);
/// `1 << 14`  
pub const VK_BUFFER_USAGE_VIDEO_DECODE_DST_BIT_KHR: VkBufferUsageFlags = VkBufferUsageFlags(1 << 14);
/// `1 << 11`  
pub const VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT: VkBufferUsageFlags = VkBufferUsageFlags(1 << 11);
/// `1 << 12`  
pub const VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT: VkBufferUsageFlags = VkBufferUsageFlags(1 << 12);
/// `1 << 9`  
/// 
/// Specifies the buffer can be used as predicate in conditional rendering
pub const VK_BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT: VkBufferUsageFlags = VkBufferUsageFlags(1 << 9);
/// `1 << 25`  
pub const VK_BUFFER_USAGE_EXECUTION_GRAPH_SCRATCH_BIT_AMDX: VkBufferUsageFlags = VkBufferUsageFlags(1 << 25);
/// `1 << 28`  
pub const VK_BUFFER_USAGE_DESCRIPTOR_HEAP_BIT_EXT: VkBufferUsageFlags = VkBufferUsageFlags(1 << 28);
/// `1 << 19`  
pub const VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR: VkBufferUsageFlags = VkBufferUsageFlags(1 << 19);
/// `1 << 20`  
pub const VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR: VkBufferUsageFlags = VkBufferUsageFlags(1 << 20);
/// `1 << 10`  
pub const VK_BUFFER_USAGE_SHADER_BINDING_TABLE_BIT_KHR: VkBufferUsageFlags = VkBufferUsageFlags(1 << 10);
/// `VK_BUFFER_USAGE_SHADER_BINDING_TABLE_BIT_KHR`  
pub const VK_BUFFER_USAGE_RAY_TRACING_BIT_NV: VkBufferUsageFlags = VK_BUFFER_USAGE_SHADER_BINDING_TABLE_BIT_KHR;
/// `VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT`  
pub const VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_EXT: VkBufferUsageFlags = VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT;
/// `VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT`  
pub const VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_KHR: VkBufferUsageFlags = VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT;
/// `1 << 15`  
pub const VK_BUFFER_USAGE_VIDEO_ENCODE_DST_BIT_KHR: VkBufferUsageFlags = VkBufferUsageFlags(1 << 15);
/// `1 << 16`  
pub const VK_BUFFER_USAGE_VIDEO_ENCODE_SRC_BIT_KHR: VkBufferUsageFlags = VkBufferUsageFlags(1 << 16);
/// `1 << 21`  
pub const VK_BUFFER_USAGE_SAMPLER_DESCRIPTOR_BUFFER_BIT_EXT: VkBufferUsageFlags = VkBufferUsageFlags(1 << 21);
/// `1 << 22`  
pub const VK_BUFFER_USAGE_RESOURCE_DESCRIPTOR_BUFFER_BIT_EXT: VkBufferUsageFlags = VkBufferUsageFlags(1 << 22);
/// `1 << 26`  
pub const VK_BUFFER_USAGE_PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_BIT_EXT: VkBufferUsageFlags = VkBufferUsageFlags(1 << 26);
/// `1 << 23`  
pub const VK_BUFFER_USAGE_MICROMAP_BUILD_INPUT_READ_ONLY_BIT_EXT: VkBufferUsageFlags = VkBufferUsageFlags(1 << 23);
/// `1 << 24`  
pub const VK_BUFFER_USAGE_MICROMAP_STORAGE_BIT_EXT: VkBufferUsageFlags = VkBufferUsageFlags(1 << 24);
/// `1 << 27`  
pub const VK_BUFFER_USAGE_TILE_MEMORY_BIT_QCOM: VkBufferUsageFlags = VkBufferUsageFlags(1 << 27);

impl_flags_display!(VkBufferUsageFlags { VK_BUFFER_USAGE_TRANSFER_SRC_BIT, VK_BUFFER_USAGE_TRANSFER_DST_BIT, VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT, VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT, VK_BUFFER_USAGE_INDEX_BUFFER_BIT, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT, VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT, VK_BUFFER_USAGE_VIDEO_DECODE_SRC_BIT_KHR, VK_BUFFER_USAGE_VIDEO_DECODE_DST_BIT_KHR, VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT, VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT, VK_BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT, VK_BUFFER_USAGE_EXECUTION_GRAPH_SCRATCH_BIT_AMDX, VK_BUFFER_USAGE_DESCRIPTOR_HEAP_BIT_EXT, VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR, VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR, VK_BUFFER_USAGE_SHADER_BINDING_TABLE_BIT_KHR, VK_BUFFER_USAGE_RAY_TRACING_BIT_NV, VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_EXT, VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_KHR, VK_BUFFER_USAGE_VIDEO_ENCODE_DST_BIT_KHR, VK_BUFFER_USAGE_VIDEO_ENCODE_SRC_BIT_KHR, VK_BUFFER_USAGE_SAMPLER_DESCRIPTOR_BUFFER_BIT_EXT, VK_BUFFER_USAGE_RESOURCE_DESCRIPTOR_BUFFER_BIT_EXT, VK_BUFFER_USAGE_PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_BIT_EXT, VK_BUFFER_USAGE_MICROMAP_BUILD_INPUT_READ_ONLY_BIT_EXT, VK_BUFFER_USAGE_MICROMAP_STORAGE_BIT_EXT, VK_BUFFER_USAGE_TILE_MEMORY_BIT_QCOM });

flags!(VkBufferUsageFlags2);
from_into_transparent!(VkBufferUsageFlags2: i64);
/// `VkBufferUsageFlags2`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkBufferUsageFlags2(pub i64);

/// `1 << 0`  
pub const VK_BUFFER_USAGE_2_TRANSFER_SRC_BIT: VkBufferUsageFlags2 = VkBufferUsageFlags2(1 << 0);
/// `1 << 1`  
pub const VK_BUFFER_USAGE_2_TRANSFER_DST_BIT: VkBufferUsageFlags2 = VkBufferUsageFlags2(1 << 1);
/// `1 << 2`  
pub const VK_BUFFER_USAGE_2_UNIFORM_TEXEL_BUFFER_BIT: VkBufferUsageFlags2 = VkBufferUsageFlags2(1 << 2);
/// `1 << 3`  
pub const VK_BUFFER_USAGE_2_STORAGE_TEXEL_BUFFER_BIT: VkBufferUsageFlags2 = VkBufferUsageFlags2(1 << 3);
/// `1 << 4`  
pub const VK_BUFFER_USAGE_2_UNIFORM_BUFFER_BIT: VkBufferUsageFlags2 = VkBufferUsageFlags2(1 << 4);
/// `1 << 5`  
pub const VK_BUFFER_USAGE_2_STORAGE_BUFFER_BIT: VkBufferUsageFlags2 = VkBufferUsageFlags2(1 << 5);
/// `1 << 6`  
pub const VK_BUFFER_USAGE_2_INDEX_BUFFER_BIT: VkBufferUsageFlags2 = VkBufferUsageFlags2(1 << 6);
/// `1 << 7`  
pub const VK_BUFFER_USAGE_2_VERTEX_BUFFER_BIT: VkBufferUsageFlags2 = VkBufferUsageFlags2(1 << 7);
/// `1 << 8`  
pub const VK_BUFFER_USAGE_2_INDIRECT_BUFFER_BIT: VkBufferUsageFlags2 = VkBufferUsageFlags2(1 << 8);
/// `1 << 17`  
pub const VK_BUFFER_USAGE_2_SHADER_DEVICE_ADDRESS_BIT: VkBufferUsageFlags2 = VkBufferUsageFlags2(1 << 17);
/// `1 << 25`  
pub const VK_BUFFER_USAGE_2_EXECUTION_GRAPH_SCRATCH_BIT_AMDX: VkBufferUsageFlags2 = VkBufferUsageFlags2(1 << 25);
/// `1 << 28`  
pub const VK_BUFFER_USAGE_2_DESCRIPTOR_HEAP_BIT_EXT: VkBufferUsageFlags2 = VkBufferUsageFlags2(1 << 28);
/// `VK_BUFFER_USAGE_2_TRANSFER_SRC_BIT`  
pub const VK_BUFFER_USAGE_2_TRANSFER_SRC_BIT_KHR: VkBufferUsageFlags2 = VK_BUFFER_USAGE_2_TRANSFER_SRC_BIT;
/// `VK_BUFFER_USAGE_2_TRANSFER_DST_BIT`  
pub const VK_BUFFER_USAGE_2_TRANSFER_DST_BIT_KHR: VkBufferUsageFlags2 = VK_BUFFER_USAGE_2_TRANSFER_DST_BIT;
/// `VK_BUFFER_USAGE_2_UNIFORM_TEXEL_BUFFER_BIT`  
pub const VK_BUFFER_USAGE_2_UNIFORM_TEXEL_BUFFER_BIT_KHR: VkBufferUsageFlags2 = VK_BUFFER_USAGE_2_UNIFORM_TEXEL_BUFFER_BIT;
/// `VK_BUFFER_USAGE_2_STORAGE_TEXEL_BUFFER_BIT`  
pub const VK_BUFFER_USAGE_2_STORAGE_TEXEL_BUFFER_BIT_KHR: VkBufferUsageFlags2 = VK_BUFFER_USAGE_2_STORAGE_TEXEL_BUFFER_BIT;
/// `VK_BUFFER_USAGE_2_UNIFORM_BUFFER_BIT`  
pub const VK_BUFFER_USAGE_2_UNIFORM_BUFFER_BIT_KHR: VkBufferUsageFlags2 = VK_BUFFER_USAGE_2_UNIFORM_BUFFER_BIT;
/// `VK_BUFFER_USAGE_2_STORAGE_BUFFER_BIT`  
pub const VK_BUFFER_USAGE_2_STORAGE_BUFFER_BIT_KHR: VkBufferUsageFlags2 = VK_BUFFER_USAGE_2_STORAGE_BUFFER_BIT;
/// `VK_BUFFER_USAGE_2_INDEX_BUFFER_BIT`  
pub const VK_BUFFER_USAGE_2_INDEX_BUFFER_BIT_KHR: VkBufferUsageFlags2 = VK_BUFFER_USAGE_2_INDEX_BUFFER_BIT;
/// `VK_BUFFER_USAGE_2_VERTEX_BUFFER_BIT`  
pub const VK_BUFFER_USAGE_2_VERTEX_BUFFER_BIT_KHR: VkBufferUsageFlags2 = VK_BUFFER_USAGE_2_VERTEX_BUFFER_BIT;
/// `VK_BUFFER_USAGE_2_INDIRECT_BUFFER_BIT`  
pub const VK_BUFFER_USAGE_2_INDIRECT_BUFFER_BIT_KHR: VkBufferUsageFlags2 = VK_BUFFER_USAGE_2_INDIRECT_BUFFER_BIT;
/// `1 << 9`  
pub const VK_BUFFER_USAGE_2_CONDITIONAL_RENDERING_BIT_EXT: VkBufferUsageFlags2 = VkBufferUsageFlags2(1 << 9);
/// `1 << 10`  
pub const VK_BUFFER_USAGE_2_SHADER_BINDING_TABLE_BIT_KHR: VkBufferUsageFlags2 = VkBufferUsageFlags2(1 << 10);
/// `VK_BUFFER_USAGE_2_SHADER_BINDING_TABLE_BIT_KHR`  
pub const VK_BUFFER_USAGE_2_RAY_TRACING_BIT_NV: VkBufferUsageFlags2 = VK_BUFFER_USAGE_2_SHADER_BINDING_TABLE_BIT_KHR;
/// `1 << 11`  
pub const VK_BUFFER_USAGE_2_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT: VkBufferUsageFlags2 = VkBufferUsageFlags2(1 << 11);
/// `1 << 12`  
pub const VK_BUFFER_USAGE_2_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT: VkBufferUsageFlags2 = VkBufferUsageFlags2(1 << 12);
/// `1 << 13`  
pub const VK_BUFFER_USAGE_2_VIDEO_DECODE_SRC_BIT_KHR: VkBufferUsageFlags2 = VkBufferUsageFlags2(1 << 13);
/// `1 << 14`  
pub const VK_BUFFER_USAGE_2_VIDEO_DECODE_DST_BIT_KHR: VkBufferUsageFlags2 = VkBufferUsageFlags2(1 << 14);
/// `1 << 15`  
pub const VK_BUFFER_USAGE_2_VIDEO_ENCODE_DST_BIT_KHR: VkBufferUsageFlags2 = VkBufferUsageFlags2(1 << 15);
/// `1 << 16`  
pub const VK_BUFFER_USAGE_2_VIDEO_ENCODE_SRC_BIT_KHR: VkBufferUsageFlags2 = VkBufferUsageFlags2(1 << 16);
/// `VK_BUFFER_USAGE_2_SHADER_DEVICE_ADDRESS_BIT`  
pub const VK_BUFFER_USAGE_2_SHADER_DEVICE_ADDRESS_BIT_KHR: VkBufferUsageFlags2 = VK_BUFFER_USAGE_2_SHADER_DEVICE_ADDRESS_BIT;
/// `1 << 19`  
pub const VK_BUFFER_USAGE_2_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR: VkBufferUsageFlags2 = VkBufferUsageFlags2(1 << 19);
/// `1 << 20`  
pub const VK_BUFFER_USAGE_2_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR: VkBufferUsageFlags2 = VkBufferUsageFlags2(1 << 20);
/// `1 << 21`  
pub const VK_BUFFER_USAGE_2_SAMPLER_DESCRIPTOR_BUFFER_BIT_EXT: VkBufferUsageFlags2 = VkBufferUsageFlags2(1 << 21);
/// `1 << 22`  
pub const VK_BUFFER_USAGE_2_RESOURCE_DESCRIPTOR_BUFFER_BIT_EXT: VkBufferUsageFlags2 = VkBufferUsageFlags2(1 << 22);
/// `1 << 26`  
pub const VK_BUFFER_USAGE_2_PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_BIT_EXT: VkBufferUsageFlags2 = VkBufferUsageFlags2(1 << 26);
/// `1 << 23`  
pub const VK_BUFFER_USAGE_2_MICROMAP_BUILD_INPUT_READ_ONLY_BIT_EXT: VkBufferUsageFlags2 = VkBufferUsageFlags2(1 << 23);
/// `1 << 24`  
pub const VK_BUFFER_USAGE_2_MICROMAP_STORAGE_BIT_EXT: VkBufferUsageFlags2 = VkBufferUsageFlags2(1 << 24);
/// `1 << 33`  
pub const VK_BUFFER_USAGE_2_COMPRESSED_DATA_DGF1_BIT_AMDX: VkBufferUsageFlags2 = VkBufferUsageFlags2(1 << 33);
/// `1 << 29`  
pub const VK_BUFFER_USAGE_2_DATA_GRAPH_FOREIGN_DESCRIPTOR_BIT_ARM: VkBufferUsageFlags2 = VkBufferUsageFlags2(1 << 29);
/// `1 << 34`  
pub const VK_BUFFER_USAGE_2_RESERVED_34_BIT_EXT: VkBufferUsageFlags2 = VkBufferUsageFlags2(1 << 34);
/// `1 << 27`  
pub const VK_BUFFER_USAGE_2_TILE_MEMORY_BIT_QCOM: VkBufferUsageFlags2 = VkBufferUsageFlags2(1 << 27);
/// `1 << 32`  
pub const VK_BUFFER_USAGE_2_MEMORY_DECOMPRESSION_BIT_EXT: VkBufferUsageFlags2 = VkBufferUsageFlags2(1 << 32);
/// `1 << 31`  
pub const VK_BUFFER_USAGE_2_PREPROCESS_BUFFER_BIT_EXT: VkBufferUsageFlags2 = VkBufferUsageFlags2(1 << 31);
/// `1 << 35`  
pub const VK_BUFFER_USAGE_2_RESERVED_35_BIT_KHR: VkBufferUsageFlags2 = VkBufferUsageFlags2(1 << 35);
/// `1 << 36`  
pub const VK_BUFFER_USAGE_2_RESERVED_36_BIT_KHR: VkBufferUsageFlags2 = VkBufferUsageFlags2(1 << 36);
/// `1 << 37`  
pub const VK_BUFFER_USAGE_2_RESERVED_37_BIT_HUAWEI: VkBufferUsageFlags2 = VkBufferUsageFlags2(1 << 37);

impl_flags_display!(VkBufferUsageFlags2 { VK_BUFFER_USAGE_2_TRANSFER_SRC_BIT, VK_BUFFER_USAGE_2_TRANSFER_DST_BIT, VK_BUFFER_USAGE_2_UNIFORM_TEXEL_BUFFER_BIT, VK_BUFFER_USAGE_2_STORAGE_TEXEL_BUFFER_BIT, VK_BUFFER_USAGE_2_UNIFORM_BUFFER_BIT, VK_BUFFER_USAGE_2_STORAGE_BUFFER_BIT, VK_BUFFER_USAGE_2_INDEX_BUFFER_BIT, VK_BUFFER_USAGE_2_VERTEX_BUFFER_BIT, VK_BUFFER_USAGE_2_INDIRECT_BUFFER_BIT, VK_BUFFER_USAGE_2_SHADER_DEVICE_ADDRESS_BIT, VK_BUFFER_USAGE_2_EXECUTION_GRAPH_SCRATCH_BIT_AMDX, VK_BUFFER_USAGE_2_DESCRIPTOR_HEAP_BIT_EXT, VK_BUFFER_USAGE_2_TRANSFER_SRC_BIT_KHR, VK_BUFFER_USAGE_2_TRANSFER_DST_BIT_KHR, VK_BUFFER_USAGE_2_UNIFORM_TEXEL_BUFFER_BIT_KHR, VK_BUFFER_USAGE_2_STORAGE_TEXEL_BUFFER_BIT_KHR, VK_BUFFER_USAGE_2_UNIFORM_BUFFER_BIT_KHR, VK_BUFFER_USAGE_2_STORAGE_BUFFER_BIT_KHR, VK_BUFFER_USAGE_2_INDEX_BUFFER_BIT_KHR, VK_BUFFER_USAGE_2_VERTEX_BUFFER_BIT_KHR, VK_BUFFER_USAGE_2_INDIRECT_BUFFER_BIT_KHR, VK_BUFFER_USAGE_2_CONDITIONAL_RENDERING_BIT_EXT, VK_BUFFER_USAGE_2_SHADER_BINDING_TABLE_BIT_KHR, VK_BUFFER_USAGE_2_RAY_TRACING_BIT_NV, VK_BUFFER_USAGE_2_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT, VK_BUFFER_USAGE_2_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT, VK_BUFFER_USAGE_2_VIDEO_DECODE_SRC_BIT_KHR, VK_BUFFER_USAGE_2_VIDEO_DECODE_DST_BIT_KHR, VK_BUFFER_USAGE_2_VIDEO_ENCODE_DST_BIT_KHR, VK_BUFFER_USAGE_2_VIDEO_ENCODE_SRC_BIT_KHR, VK_BUFFER_USAGE_2_SHADER_DEVICE_ADDRESS_BIT_KHR, VK_BUFFER_USAGE_2_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR, VK_BUFFER_USAGE_2_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR, VK_BUFFER_USAGE_2_SAMPLER_DESCRIPTOR_BUFFER_BIT_EXT, VK_BUFFER_USAGE_2_RESOURCE_DESCRIPTOR_BUFFER_BIT_EXT, VK_BUFFER_USAGE_2_PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_BIT_EXT, VK_BUFFER_USAGE_2_MICROMAP_BUILD_INPUT_READ_ONLY_BIT_EXT, VK_BUFFER_USAGE_2_MICROMAP_STORAGE_BIT_EXT, VK_BUFFER_USAGE_2_COMPRESSED_DATA_DGF1_BIT_AMDX, VK_BUFFER_USAGE_2_DATA_GRAPH_FOREIGN_DESCRIPTOR_BIT_ARM, VK_BUFFER_USAGE_2_RESERVED_34_BIT_EXT, VK_BUFFER_USAGE_2_TILE_MEMORY_BIT_QCOM, VK_BUFFER_USAGE_2_MEMORY_DECOMPRESSION_BIT_EXT, VK_BUFFER_USAGE_2_PREPROCESS_BUFFER_BIT_EXT, VK_BUFFER_USAGE_2_RESERVED_35_BIT_KHR, VK_BUFFER_USAGE_2_RESERVED_36_BIT_KHR, VK_BUFFER_USAGE_2_RESERVED_37_BIT_HUAWEI });

/// `VkBufferUsageFlags2CreateInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkBufferUsageFlags2CreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub usage: VkBufferUsageFlags2,
}
impl_default_zeroed_with_s_type!(VkBufferUsageFlags2CreateInfo : VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO);
impl_extends!(VkBufferUsageFlags2CreateInfo : VkBufferViewCreateInfo, VkBufferCreateInfo, VkPhysicalDeviceExternalBufferInfo, VkDescriptorBufferBindingInfoEXT);

/// `VkBufferUsageFlags2CreateInfo`
pub type VkBufferUsageFlags2CreateInfoKHR = VkBufferUsageFlags2CreateInfo;

/// `VkBufferUsageFlags2`
pub type VkBufferUsageFlags2KHR = VkBufferUsageFlags2;

/// `VkBufferView` : `VkDevice`
#[repr(transparent)]
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkBufferView(pub u64);
from_into_transparent!(VkBufferView: u64);
impl_handle!(VkBufferView: VK_OBJECT_TYPE_BUFFER_VIEW; SubHandle = VkDevice);

flags!(VkBufferViewCreateFlags);
from_into_transparent!(VkBufferViewCreateFlags: i32);
/// `VkBufferViewCreateFlags`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkBufferViewCreateFlags(pub i32);

impl_flags_display!(VkBufferViewCreateFlags {  });

/// `VkBufferViewCreateInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkBufferViewCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub flags: VkBufferViewCreateFlags,
    pub buffer: VkBuffer,
    /// Optionally specifies format of elements
    pub format: VkFormat,
    /// Specified in bytes
    pub offset: VkDeviceSize,
    /// View size specified in bytes
    pub range: VkDeviceSize,
}
impl_default_zeroed_with_s_type!(VkBufferViewCreateInfo : VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO);

flags!(VkBuildAccelerationStructureFlagsKHR);
from_into_transparent!(VkBuildAccelerationStructureFlagsKHR: i32);
/// `VkBuildAccelerationStructureFlagsKHR`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkBuildAccelerationStructureFlagsKHR(pub i32);

/// `1 << 0`  
pub const VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_KHR: VkBuildAccelerationStructureFlagsKHR = VkBuildAccelerationStructureFlagsKHR(1 << 0);
/// `1 << 1`  
pub const VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_KHR: VkBuildAccelerationStructureFlagsKHR = VkBuildAccelerationStructureFlagsKHR(1 << 1);
/// `1 << 2`  
pub const VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_KHR: VkBuildAccelerationStructureFlagsKHR = VkBuildAccelerationStructureFlagsKHR(1 << 2);
/// `1 << 3`  
pub const VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_KHR: VkBuildAccelerationStructureFlagsKHR = VkBuildAccelerationStructureFlagsKHR(1 << 3);
/// `1 << 4`  
pub const VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_KHR: VkBuildAccelerationStructureFlagsKHR = VkBuildAccelerationStructureFlagsKHR(1 << 4);
/// `VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_KHR`  
pub const VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_NV: VkBuildAccelerationStructureFlagsKHR = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_KHR;
/// `VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_KHR`  
pub const VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_NV: VkBuildAccelerationStructureFlagsKHR = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_KHR;
/// `VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_KHR`  
pub const VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_NV: VkBuildAccelerationStructureFlagsKHR = VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_KHR;
/// `VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_KHR`  
pub const VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_NV: VkBuildAccelerationStructureFlagsKHR = VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_KHR;
/// `VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_KHR`  
pub const VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_NV: VkBuildAccelerationStructureFlagsKHR = VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_KHR;
/// `1 << 5`  
pub const VK_BUILD_ACCELERATION_STRUCTURE_MOTION_BIT_NV: VkBuildAccelerationStructureFlagsKHR = VkBuildAccelerationStructureFlagsKHR(1 << 5);
/// `1 << 6`  
pub const VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_UPDATE_BIT_EXT: VkBuildAccelerationStructureFlagsKHR = VkBuildAccelerationStructureFlagsKHR(1 << 6);
/// `VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_UPDATE_BIT_EXT`  
pub const VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_UPDATE_EXT: VkBuildAccelerationStructureFlagsKHR = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_UPDATE_BIT_EXT;
/// `1 << 7`  
pub const VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISABLE_OPACITY_MICROMAPS_BIT_EXT: VkBuildAccelerationStructureFlagsKHR = VkBuildAccelerationStructureFlagsKHR(1 << 7);
/// `VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISABLE_OPACITY_MICROMAPS_BIT_EXT`  
pub const VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISABLE_OPACITY_MICROMAPS_EXT: VkBuildAccelerationStructureFlagsKHR = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISABLE_OPACITY_MICROMAPS_BIT_EXT;
/// `1 << 8`  
pub const VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_DATA_UPDATE_BIT_EXT: VkBuildAccelerationStructureFlagsKHR = VkBuildAccelerationStructureFlagsKHR(1 << 8);
/// `VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_DATA_UPDATE_BIT_EXT`  
pub const VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_DATA_UPDATE_EXT: VkBuildAccelerationStructureFlagsKHR = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_DATA_UPDATE_BIT_EXT;
/// `1 << 9`  
pub const VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISPLACEMENT_MICROMAP_UPDATE_BIT_NV: VkBuildAccelerationStructureFlagsKHR = VkBuildAccelerationStructureFlagsKHR(1 << 9);
/// `VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISPLACEMENT_MICROMAP_UPDATE_BIT_NV`  
pub const VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISPLACEMENT_MICROMAP_UPDATE_NV: VkBuildAccelerationStructureFlagsKHR = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISPLACEMENT_MICROMAP_UPDATE_BIT_NV;
/// `1 << 11`  
pub const VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DATA_ACCESS_BIT_KHR: VkBuildAccelerationStructureFlagsKHR = VkBuildAccelerationStructureFlagsKHR(1 << 11);
/// `VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DATA_ACCESS_BIT_KHR`  
pub const VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DATA_ACCESS_KHR: VkBuildAccelerationStructureFlagsKHR = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DATA_ACCESS_BIT_KHR;
/// `1 << 12`  
pub const VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_CLUSTER_OPACITY_MICROMAPS_BIT_NV: VkBuildAccelerationStructureFlagsKHR = VkBuildAccelerationStructureFlagsKHR(1 << 12);
/// `1 << 10`  
pub const VK_BUILD_ACCELERATION_STRUCTURE_RESERVED_10_BIT_KHR: VkBuildAccelerationStructureFlagsKHR = VkBuildAccelerationStructureFlagsKHR(1 << 10);

impl_flags_display!(VkBuildAccelerationStructureFlagsKHR { VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_KHR, VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_KHR, VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_KHR, VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_KHR, VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_KHR, VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_NV, VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_NV, VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_NV, VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_NV, VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_NV, VK_BUILD_ACCELERATION_STRUCTURE_MOTION_BIT_NV, VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_UPDATE_BIT_EXT, VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_UPDATE_EXT, VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISABLE_OPACITY_MICROMAPS_BIT_EXT, VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISABLE_OPACITY_MICROMAPS_EXT, VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_DATA_UPDATE_BIT_EXT, VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_DATA_UPDATE_EXT, VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISPLACEMENT_MICROMAP_UPDATE_BIT_NV, VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISPLACEMENT_MICROMAP_UPDATE_NV, VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DATA_ACCESS_BIT_KHR, VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DATA_ACCESS_KHR, VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_CLUSTER_OPACITY_MICROMAPS_BIT_NV, VK_BUILD_ACCELERATION_STRUCTURE_RESERVED_10_BIT_KHR });

/// `VkBuildAccelerationStructureFlagsKHR`
pub type VkBuildAccelerationStructureFlagsNV = VkBuildAccelerationStructureFlagsKHR;

from_into_transparent!(VkBuildAccelerationStructureModeKHR: i32);
/// `VkBuildAccelerationStructureModeKHR`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkBuildAccelerationStructureModeKHR(pub i32);

/// `0`  
pub const VK_BUILD_ACCELERATION_STRUCTURE_MODE_BUILD_KHR: VkBuildAccelerationStructureModeKHR = VkBuildAccelerationStructureModeKHR(0);
/// `1`  
pub const VK_BUILD_ACCELERATION_STRUCTURE_MODE_UPDATE_KHR: VkBuildAccelerationStructureModeKHR = VkBuildAccelerationStructureModeKHR(1);

impl_enum_display!(VkBuildAccelerationStructureModeKHR { VK_BUILD_ACCELERATION_STRUCTURE_MODE_BUILD_KHR, VK_BUILD_ACCELERATION_STRUCTURE_MODE_UPDATE_KHR });

flags!(VkBuildMicromapFlagsEXT);
from_into_transparent!(VkBuildMicromapFlagsEXT: i32);
/// `VkBuildMicromapFlagsEXT`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkBuildMicromapFlagsEXT(pub i32);

/// `1 << 0`  
pub const VK_BUILD_MICROMAP_PREFER_FAST_TRACE_BIT_EXT: VkBuildMicromapFlagsEXT = VkBuildMicromapFlagsEXT(1 << 0);
/// `1 << 1`  
pub const VK_BUILD_MICROMAP_PREFER_FAST_BUILD_BIT_EXT: VkBuildMicromapFlagsEXT = VkBuildMicromapFlagsEXT(1 << 1);
/// `1 << 2`  
pub const VK_BUILD_MICROMAP_ALLOW_COMPACTION_BIT_EXT: VkBuildMicromapFlagsEXT = VkBuildMicromapFlagsEXT(1 << 2);

impl_flags_display!(VkBuildMicromapFlagsEXT { VK_BUILD_MICROMAP_PREFER_FAST_TRACE_BIT_EXT, VK_BUILD_MICROMAP_PREFER_FAST_BUILD_BIT_EXT, VK_BUILD_MICROMAP_ALLOW_COMPACTION_BIT_EXT });

from_into_transparent!(VkBuildMicromapModeEXT: i32);
/// `VkBuildMicromapModeEXT`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkBuildMicromapModeEXT(pub i32);

/// `0`  
pub const VK_BUILD_MICROMAP_MODE_BUILD_EXT: VkBuildMicromapModeEXT = VkBuildMicromapModeEXT(0);

impl_enum_display!(VkBuildMicromapModeEXT { VK_BUILD_MICROMAP_MODE_BUILD_EXT });

/// `VkBuildPartitionedAccelerationStructureIndirectCommandNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkBuildPartitionedAccelerationStructureIndirectCommandNV {
    pub opType: VkPartitionedAccelerationStructureOpTypeNV,
    pub argCount: uint32_t,
    pub argData: VkStridedDeviceAddressNV,
}
impl_default_zeroed!(VkBuildPartitionedAccelerationStructureIndirectCommandNV);

/// `VkBuildPartitionedAccelerationStructureInfoNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkBuildPartitionedAccelerationStructureInfoNV {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub input: VkPartitionedAccelerationStructureInstancesInputNV,
    pub srcAccelerationStructureData: VkDeviceAddress,
    pub dstAccelerationStructureData: VkDeviceAddress,
    pub scratchData: VkDeviceAddress,
    pub srcInfos: VkDeviceAddress,
    pub srcInfosCount: VkDeviceAddress,
}
impl_default_zeroed_with_s_type!(VkBuildPartitionedAccelerationStructureInfoNV : VK_STRUCTURE_TYPE_BUILD_PARTITIONED_ACCELERATION_STRUCTURE_INFO_NV);

/// `VkCalibratedTimestampInfoKHR`
pub type VkCalibratedTimestampInfoEXT = VkCalibratedTimestampInfoKHR;

/// `VkCalibratedTimestampInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkCalibratedTimestampInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub timeDomain: VkTimeDomainKHR,
}
impl_default_zeroed_with_s_type!(VkCalibratedTimestampInfoKHR : VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_KHR);

/// `VkCheckpointData2NV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkCheckpointData2NV {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub stage: VkPipelineStageFlags2,
    pub pCheckpointMarker: *mut void,
}
impl_default_zeroed_with_s_type!(VkCheckpointData2NV : VK_STRUCTURE_TYPE_CHECKPOINT_DATA_2_NV);

/// `VkCheckpointDataNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkCheckpointDataNV {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub stage: VkPipelineStageFlags,
    pub pCheckpointMarker: *mut void,
}
impl_default_zeroed_with_s_type!(VkCheckpointDataNV : VK_STRUCTURE_TYPE_CHECKPOINT_DATA_NV);

from_into_transparent!(VkChromaLocation: i32);
/// `VkChromaLocation`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkChromaLocation(pub i32);

/// `0`  
pub const VK_CHROMA_LOCATION_COSITED_EVEN: VkChromaLocation = VkChromaLocation(0);
/// `1`  
pub const VK_CHROMA_LOCATION_MIDPOINT: VkChromaLocation = VkChromaLocation(1);
/// `VK_CHROMA_LOCATION_COSITED_EVEN`  
pub const VK_CHROMA_LOCATION_COSITED_EVEN_KHR: VkChromaLocation = VK_CHROMA_LOCATION_COSITED_EVEN;
/// `VK_CHROMA_LOCATION_MIDPOINT`  
pub const VK_CHROMA_LOCATION_MIDPOINT_KHR: VkChromaLocation = VK_CHROMA_LOCATION_MIDPOINT;

impl_enum_display!(VkChromaLocation { VK_CHROMA_LOCATION_COSITED_EVEN, VK_CHROMA_LOCATION_MIDPOINT, VK_CHROMA_LOCATION_COSITED_EVEN_KHR, VK_CHROMA_LOCATION_MIDPOINT_KHR });

/// `VkChromaLocation`
pub type VkChromaLocationKHR = VkChromaLocation;

/// `VkClearAttachment`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkClearAttachment {
    pub aspectMask: VkImageAspectFlags,
    pub colorAttachment: uint32_t,
    pub clearValue: VkClearValue,
}
impl_default_zeroed!(VkClearAttachment);

/// `VkClearColorValue`
/// 
/// // Union allowing specification of floating-point, integer, or unsigned integer color data. Actual value selected is based on image/attachment being cleared.
#[repr(C)]
#[derive(Clone, Copy)]
pub union VkClearColorValue {
    pub float32: [float; 4 as usize],
    pub int32: [int32_t; 4 as usize],
    pub uint32: [uint32_t; 4 as usize],
}
impl_debug_for_union!(VkClearColorValue);
impl_default_zeroed!(VkClearColorValue);

/// `VkClearDepthStencilValue`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkClearDepthStencilValue {
    pub depth: float,
    pub stencil: uint32_t,
}
impl_default_zeroed!(VkClearDepthStencilValue);

/// `VkClearRect`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkClearRect {
    pub rect: VkRect2D,
    pub baseArrayLayer: uint32_t,
    pub layerCount: uint32_t,
}
impl_default_zeroed!(VkClearRect);

/// `VkClearValue`
/// 
/// // Union allowing specification of color or depth and stencil values. Actual value selected is based on attachment being cleared.
#[repr(C)]
#[derive(Clone, Copy)]
pub union VkClearValue {
    pub color: VkClearColorValue,
    pub depthStencil: VkClearDepthStencilValue,
}
impl_debug_for_union!(VkClearValue);
impl_default_zeroed!(VkClearValue);

flags!(VkClusterAccelerationStructureAddressResolutionFlagsNV);
from_into_transparent!(VkClusterAccelerationStructureAddressResolutionFlagsNV: i32);
/// `VkClusterAccelerationStructureAddressResolutionFlagsNV`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkClusterAccelerationStructureAddressResolutionFlagsNV(pub i32);

/// `0`  
pub const VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_NONE_NV: VkClusterAccelerationStructureAddressResolutionFlagsNV = VkClusterAccelerationStructureAddressResolutionFlagsNV(0);
/// `1 << 0`  
pub const VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_DST_IMPLICIT_DATA_BIT_NV: VkClusterAccelerationStructureAddressResolutionFlagsNV = VkClusterAccelerationStructureAddressResolutionFlagsNV(1 << 0);
/// `1 << 1`  
pub const VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_SCRATCH_DATA_BIT_NV: VkClusterAccelerationStructureAddressResolutionFlagsNV = VkClusterAccelerationStructureAddressResolutionFlagsNV(1 << 1);
/// `1 << 2`  
pub const VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_DST_ADDRESS_ARRAY_BIT_NV: VkClusterAccelerationStructureAddressResolutionFlagsNV = VkClusterAccelerationStructureAddressResolutionFlagsNV(1 << 2);
/// `1 << 3`  
pub const VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_DST_SIZES_ARRAY_BIT_NV: VkClusterAccelerationStructureAddressResolutionFlagsNV = VkClusterAccelerationStructureAddressResolutionFlagsNV(1 << 3);
/// `1 << 4`  
pub const VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_SRC_INFOS_ARRAY_BIT_NV: VkClusterAccelerationStructureAddressResolutionFlagsNV = VkClusterAccelerationStructureAddressResolutionFlagsNV(1 << 4);
/// `1 << 5`  
pub const VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_SRC_INFOS_COUNT_BIT_NV: VkClusterAccelerationStructureAddressResolutionFlagsNV = VkClusterAccelerationStructureAddressResolutionFlagsNV(1 << 5);

impl_flags_display!(VkClusterAccelerationStructureAddressResolutionFlagsNV { VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_NONE_NV, VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_DST_IMPLICIT_DATA_BIT_NV, VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_SCRATCH_DATA_BIT_NV, VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_DST_ADDRESS_ARRAY_BIT_NV, VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_DST_SIZES_ARRAY_BIT_NV, VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_SRC_INFOS_ARRAY_BIT_NV, VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_SRC_INFOS_COUNT_BIT_NV });

/// `VkClusterAccelerationStructureBuildClustersBottomLevelInfoNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkClusterAccelerationStructureBuildClustersBottomLevelInfoNV {
    pub clusterReferencesCount: uint32_t,
    pub clusterReferencesStride: uint32_t,
    pub clusterReferences: VkDeviceAddress,
}
impl_default_zeroed!(VkClusterAccelerationStructureBuildClustersBottomLevelInfoNV);

/// `VkClusterAccelerationStructureBuildTriangleClusterInfoNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkClusterAccelerationStructureBuildTriangleClusterInfoNV {
    pub clusterID: uint32_t,
    pub clusterFlags: VkClusterAccelerationStructureClusterFlagsNV,
    pub triangleCount: uint32_t,
    pub vertexCount: uint32_t,
    pub positionTruncateBitCount: uint32_t,
    pub indexType: uint32_t,
    pub opacityMicromapIndexType: uint32_t,
    pub baseGeometryIndexAndGeometryFlags: VkClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV,
    pub indexBufferStride: uint16_t,
    pub vertexBufferStride: uint16_t,
    pub geometryIndexAndFlagsBufferStride: uint16_t,
    pub opacityMicromapIndexBufferStride: uint16_t,
    pub indexBuffer: VkDeviceAddress,
    pub vertexBuffer: VkDeviceAddress,
    pub geometryIndexAndFlagsBuffer: VkDeviceAddress,
    pub opacityMicromapArray: VkDeviceAddress,
    pub opacityMicromapIndexBuffer: VkDeviceAddress,
}
impl_default_zeroed!(VkClusterAccelerationStructureBuildTriangleClusterInfoNV);

/// `VkClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV {
    pub clusterID: uint32_t,
    pub clusterFlags: VkClusterAccelerationStructureClusterFlagsNV,
    pub triangleCount: uint32_t,
    pub vertexCount: uint32_t,
    pub positionTruncateBitCount: uint32_t,
    pub indexType: uint32_t,
    pub opacityMicromapIndexType: uint32_t,
    pub baseGeometryIndexAndGeometryFlags: VkClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV,
    pub indexBufferStride: uint16_t,
    pub vertexBufferStride: uint16_t,
    pub geometryIndexAndFlagsBufferStride: uint16_t,
    pub opacityMicromapIndexBufferStride: uint16_t,
    pub indexBuffer: VkDeviceAddress,
    pub vertexBuffer: VkDeviceAddress,
    pub geometryIndexAndFlagsBuffer: VkDeviceAddress,
    pub opacityMicromapArray: VkDeviceAddress,
    pub opacityMicromapIndexBuffer: VkDeviceAddress,
    pub instantiationBoundingBoxLimit: VkDeviceAddress,
}
impl_default_zeroed!(VkClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV);

flags!(VkClusterAccelerationStructureClusterFlagsNV);
from_into_transparent!(VkClusterAccelerationStructureClusterFlagsNV: i32);
/// `VkClusterAccelerationStructureClusterFlagsNV`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkClusterAccelerationStructureClusterFlagsNV(pub i32);

/// `1 << 0`  
pub const VK_CLUSTER_ACCELERATION_STRUCTURE_CLUSTER_ALLOW_DISABLE_OPACITY_MICROMAPS_NV: VkClusterAccelerationStructureClusterFlagsNV = VkClusterAccelerationStructureClusterFlagsNV(1 << 0);

impl_flags_display!(VkClusterAccelerationStructureClusterFlagsNV { VK_CLUSTER_ACCELERATION_STRUCTURE_CLUSTER_ALLOW_DISABLE_OPACITY_MICROMAPS_NV });

/// `VkClusterAccelerationStructureClustersBottomLevelInputNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkClusterAccelerationStructureClustersBottomLevelInputNV {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub maxTotalClusterCount: uint32_t,
    pub maxClusterCountPerAccelerationStructure: uint32_t,
}
impl_default_zeroed_with_s_type!(VkClusterAccelerationStructureClustersBottomLevelInputNV : VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_CLUSTERS_BOTTOM_LEVEL_INPUT_NV);

/// `VkClusterAccelerationStructureCommandsInfoNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkClusterAccelerationStructureCommandsInfoNV {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub input: VkClusterAccelerationStructureInputInfoNV,
    pub dstImplicitData: VkDeviceAddress,
    pub scratchData: VkDeviceAddress,
    pub dstAddressesArray: VkStridedDeviceAddressRegionKHR,
    pub dstSizesArray: VkStridedDeviceAddressRegionKHR,
    pub srcInfosArray: VkStridedDeviceAddressRegionKHR,
    pub srcInfosCount: VkDeviceAddress,
    pub addressResolutionFlags: VkClusterAccelerationStructureAddressResolutionFlagsNV,
}
impl_default_zeroed_with_s_type!(VkClusterAccelerationStructureCommandsInfoNV : VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_COMMANDS_INFO_NV);

flags!(VkClusterAccelerationStructureGeometryFlagsNV);
from_into_transparent!(VkClusterAccelerationStructureGeometryFlagsNV: i32);
/// `VkClusterAccelerationStructureGeometryFlagsNV`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkClusterAccelerationStructureGeometryFlagsNV(pub i32);

/// `1 << 0`  
pub const VK_CLUSTER_ACCELERATION_STRUCTURE_GEOMETRY_CULL_DISABLE_BIT_NV: VkClusterAccelerationStructureGeometryFlagsNV = VkClusterAccelerationStructureGeometryFlagsNV(1 << 0);
/// `1 << 1`  
pub const VK_CLUSTER_ACCELERATION_STRUCTURE_GEOMETRY_NO_DUPLICATE_ANYHIT_INVOCATION_BIT_NV: VkClusterAccelerationStructureGeometryFlagsNV = VkClusterAccelerationStructureGeometryFlagsNV(1 << 1);
/// `1 << 2`  
pub const VK_CLUSTER_ACCELERATION_STRUCTURE_GEOMETRY_OPAQUE_BIT_NV: VkClusterAccelerationStructureGeometryFlagsNV = VkClusterAccelerationStructureGeometryFlagsNV(1 << 2);

impl_flags_display!(VkClusterAccelerationStructureGeometryFlagsNV { VK_CLUSTER_ACCELERATION_STRUCTURE_GEOMETRY_CULL_DISABLE_BIT_NV, VK_CLUSTER_ACCELERATION_STRUCTURE_GEOMETRY_NO_DUPLICATE_ANYHIT_INVOCATION_BIT_NV, VK_CLUSTER_ACCELERATION_STRUCTURE_GEOMETRY_OPAQUE_BIT_NV });

/// `VkClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV {
    pub geometryIndex: uint32_t,
    pub reserved: uint32_t,
    pub geometryFlags: uint32_t,
}
impl_default_zeroed!(VkClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV);

/// `VkClusterAccelerationStructureGetTemplateIndicesInfoNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkClusterAccelerationStructureGetTemplateIndicesInfoNV {
    pub clusterTemplateAddress: VkDeviceAddress,
}
impl_default_zeroed!(VkClusterAccelerationStructureGetTemplateIndicesInfoNV);

flags!(VkClusterAccelerationStructureIndexFormatFlagsNV);
from_into_transparent!(VkClusterAccelerationStructureIndexFormatFlagsNV: i32);
/// `VkClusterAccelerationStructureIndexFormatFlagsNV`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkClusterAccelerationStructureIndexFormatFlagsNV(pub i32);

/// `1 << 0`  
pub const VK_CLUSTER_ACCELERATION_STRUCTURE_INDEX_FORMAT_8BIT_NV: VkClusterAccelerationStructureIndexFormatFlagsNV = VkClusterAccelerationStructureIndexFormatFlagsNV(1 << 0);
/// `1 << 1`  
pub const VK_CLUSTER_ACCELERATION_STRUCTURE_INDEX_FORMAT_16BIT_NV: VkClusterAccelerationStructureIndexFormatFlagsNV = VkClusterAccelerationStructureIndexFormatFlagsNV(1 << 1);
/// `1 << 2`  
pub const VK_CLUSTER_ACCELERATION_STRUCTURE_INDEX_FORMAT_32BIT_NV: VkClusterAccelerationStructureIndexFormatFlagsNV = VkClusterAccelerationStructureIndexFormatFlagsNV(1 << 2);

impl_flags_display!(VkClusterAccelerationStructureIndexFormatFlagsNV { VK_CLUSTER_ACCELERATION_STRUCTURE_INDEX_FORMAT_8BIT_NV, VK_CLUSTER_ACCELERATION_STRUCTURE_INDEX_FORMAT_16BIT_NV, VK_CLUSTER_ACCELERATION_STRUCTURE_INDEX_FORMAT_32BIT_NV });

/// `VkClusterAccelerationStructureInputInfoNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkClusterAccelerationStructureInputInfoNV {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub maxAccelerationStructureCount: uint32_t,
    pub flags: VkBuildAccelerationStructureFlagsKHR,
    pub opType: VkClusterAccelerationStructureOpTypeNV,
    pub opMode: VkClusterAccelerationStructureOpModeNV,
    pub opInput: VkClusterAccelerationStructureOpInputNV,
}
impl_default_zeroed_with_s_type!(VkClusterAccelerationStructureInputInfoNV : VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_INPUT_INFO_NV);

/// `VkClusterAccelerationStructureInstantiateClusterInfoNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkClusterAccelerationStructureInstantiateClusterInfoNV {
    pub clusterIdOffset: uint32_t,
    pub geometryIndexOffset: uint32_t,
    pub reserved: uint32_t,
    pub clusterTemplateAddress: VkDeviceAddress,
    pub vertexBuffer: VkStridedDeviceAddressNV,
}
impl_default_zeroed!(VkClusterAccelerationStructureInstantiateClusterInfoNV);

/// `VkClusterAccelerationStructureMoveObjectsInfoNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkClusterAccelerationStructureMoveObjectsInfoNV {
    pub srcAccelerationStructure: VkDeviceAddress,
}
impl_default_zeroed!(VkClusterAccelerationStructureMoveObjectsInfoNV);

/// `VkClusterAccelerationStructureMoveObjectsInputNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkClusterAccelerationStructureMoveObjectsInputNV {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub r#type: VkClusterAccelerationStructureTypeNV,
    pub noMoveOverlap: VkBool32,
    pub maxMovedBytes: VkDeviceSize,
}
impl_default_zeroed_with_s_type!(VkClusterAccelerationStructureMoveObjectsInputNV : VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_MOVE_OBJECTS_INPUT_NV);

/// `VkClusterAccelerationStructureOpInputNV`
#[repr(C)]
#[derive(Clone, Copy)]
pub union VkClusterAccelerationStructureOpInputNV {
    pub pClustersBottomLevel: *mut VkClusterAccelerationStructureClustersBottomLevelInputNV,
    pub pTriangleClusters: *mut VkClusterAccelerationStructureTriangleClusterInputNV,
    pub pMoveObjects: *mut VkClusterAccelerationStructureMoveObjectsInputNV,
}
impl_debug_for_union!(VkClusterAccelerationStructureOpInputNV);
impl_default_zeroed!(VkClusterAccelerationStructureOpInputNV);

from_into_transparent!(VkClusterAccelerationStructureOpModeNV: i32);
/// `VkClusterAccelerationStructureOpModeNV`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkClusterAccelerationStructureOpModeNV(pub i32);

/// `0`  
pub const VK_CLUSTER_ACCELERATION_STRUCTURE_OP_MODE_IMPLICIT_DESTINATIONS_NV: VkClusterAccelerationStructureOpModeNV = VkClusterAccelerationStructureOpModeNV(0);
/// `1`  
pub const VK_CLUSTER_ACCELERATION_STRUCTURE_OP_MODE_EXPLICIT_DESTINATIONS_NV: VkClusterAccelerationStructureOpModeNV = VkClusterAccelerationStructureOpModeNV(1);
/// `2`  
pub const VK_CLUSTER_ACCELERATION_STRUCTURE_OP_MODE_COMPUTE_SIZES_NV: VkClusterAccelerationStructureOpModeNV = VkClusterAccelerationStructureOpModeNV(2);

impl_enum_display!(VkClusterAccelerationStructureOpModeNV { VK_CLUSTER_ACCELERATION_STRUCTURE_OP_MODE_IMPLICIT_DESTINATIONS_NV, VK_CLUSTER_ACCELERATION_STRUCTURE_OP_MODE_EXPLICIT_DESTINATIONS_NV, VK_CLUSTER_ACCELERATION_STRUCTURE_OP_MODE_COMPUTE_SIZES_NV });

from_into_transparent!(VkClusterAccelerationStructureOpTypeNV: i32);
/// `VkClusterAccelerationStructureOpTypeNV`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkClusterAccelerationStructureOpTypeNV(pub i32);

/// `0`  
pub const VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_MOVE_OBJECTS_NV: VkClusterAccelerationStructureOpTypeNV = VkClusterAccelerationStructureOpTypeNV(0);
/// `1`  
pub const VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_BUILD_CLUSTERS_BOTTOM_LEVEL_NV: VkClusterAccelerationStructureOpTypeNV = VkClusterAccelerationStructureOpTypeNV(1);
/// `2`  
pub const VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_BUILD_TRIANGLE_CLUSTER_NV: VkClusterAccelerationStructureOpTypeNV = VkClusterAccelerationStructureOpTypeNV(2);
/// `3`  
pub const VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_BUILD_TRIANGLE_CLUSTER_TEMPLATE_NV: VkClusterAccelerationStructureOpTypeNV = VkClusterAccelerationStructureOpTypeNV(3);
/// `4`  
pub const VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_INSTANTIATE_TRIANGLE_CLUSTER_NV: VkClusterAccelerationStructureOpTypeNV = VkClusterAccelerationStructureOpTypeNV(4);
/// `5`  
pub const VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_GET_CLUSTER_TEMPLATE_INDICES_NV: VkClusterAccelerationStructureOpTypeNV = VkClusterAccelerationStructureOpTypeNV(5);

impl_enum_display!(VkClusterAccelerationStructureOpTypeNV { VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_MOVE_OBJECTS_NV, VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_BUILD_CLUSTERS_BOTTOM_LEVEL_NV, VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_BUILD_TRIANGLE_CLUSTER_NV, VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_BUILD_TRIANGLE_CLUSTER_TEMPLATE_NV, VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_INSTANTIATE_TRIANGLE_CLUSTER_NV, VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_GET_CLUSTER_TEMPLATE_INDICES_NV });

/// `VkClusterAccelerationStructureTriangleClusterInputNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkClusterAccelerationStructureTriangleClusterInputNV {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub vertexFormat: VkFormat,
    pub maxGeometryIndexValue: uint32_t,
    pub maxClusterUniqueGeometryCount: uint32_t,
    pub maxClusterTriangleCount: uint32_t,
    pub maxClusterVertexCount: uint32_t,
    pub maxTotalTriangleCount: uint32_t,
    pub maxTotalVertexCount: uint32_t,
    pub minPositionTruncateBitCount: uint32_t,
}
impl_default_zeroed_with_s_type!(VkClusterAccelerationStructureTriangleClusterInputNV : VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_TRIANGLE_CLUSTER_INPUT_NV);

from_into_transparent!(VkClusterAccelerationStructureTypeNV: i32);
/// `VkClusterAccelerationStructureTypeNV`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkClusterAccelerationStructureTypeNV(pub i32);

/// `0`  
pub const VK_CLUSTER_ACCELERATION_STRUCTURE_TYPE_CLUSTERS_BOTTOM_LEVEL_NV: VkClusterAccelerationStructureTypeNV = VkClusterAccelerationStructureTypeNV(0);
/// `1`  
pub const VK_CLUSTER_ACCELERATION_STRUCTURE_TYPE_TRIANGLE_CLUSTER_NV: VkClusterAccelerationStructureTypeNV = VkClusterAccelerationStructureTypeNV(1);
/// `2`  
pub const VK_CLUSTER_ACCELERATION_STRUCTURE_TYPE_TRIANGLE_CLUSTER_TEMPLATE_NV: VkClusterAccelerationStructureTypeNV = VkClusterAccelerationStructureTypeNV(2);

impl_enum_display!(VkClusterAccelerationStructureTypeNV { VK_CLUSTER_ACCELERATION_STRUCTURE_TYPE_CLUSTERS_BOTTOM_LEVEL_NV, VK_CLUSTER_ACCELERATION_STRUCTURE_TYPE_TRIANGLE_CLUSTER_NV, VK_CLUSTER_ACCELERATION_STRUCTURE_TYPE_TRIANGLE_CLUSTER_TEMPLATE_NV });

/// `VkCoarseSampleLocationNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkCoarseSampleLocationNV {
    pub pixelX: uint32_t,
    pub pixelY: uint32_t,
    pub sample: uint32_t,
}
impl_default_zeroed!(VkCoarseSampleLocationNV);

/// `VkCoarseSampleOrderCustomNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkCoarseSampleOrderCustomNV {
    pub shadingRate: VkShadingRatePaletteEntryNV,
    pub sampleCount: uint32_t,
    pub sampleLocationCount: uint32_t,
    pub pSampleLocations: *const VkCoarseSampleLocationNV,
}
impl_default_zeroed!(VkCoarseSampleOrderCustomNV);

from_into_transparent!(VkCoarseSampleOrderTypeNV: i32);
/// `VkCoarseSampleOrderTypeNV`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkCoarseSampleOrderTypeNV(pub i32);

/// `0`  
pub const VK_COARSE_SAMPLE_ORDER_TYPE_DEFAULT_NV: VkCoarseSampleOrderTypeNV = VkCoarseSampleOrderTypeNV(0);
/// `1`  
pub const VK_COARSE_SAMPLE_ORDER_TYPE_CUSTOM_NV: VkCoarseSampleOrderTypeNV = VkCoarseSampleOrderTypeNV(1);
/// `2`  
pub const VK_COARSE_SAMPLE_ORDER_TYPE_PIXEL_MAJOR_NV: VkCoarseSampleOrderTypeNV = VkCoarseSampleOrderTypeNV(2);
/// `3`  
pub const VK_COARSE_SAMPLE_ORDER_TYPE_SAMPLE_MAJOR_NV: VkCoarseSampleOrderTypeNV = VkCoarseSampleOrderTypeNV(3);

impl_enum_display!(VkCoarseSampleOrderTypeNV { VK_COARSE_SAMPLE_ORDER_TYPE_DEFAULT_NV, VK_COARSE_SAMPLE_ORDER_TYPE_CUSTOM_NV, VK_COARSE_SAMPLE_ORDER_TYPE_PIXEL_MAJOR_NV, VK_COARSE_SAMPLE_ORDER_TYPE_SAMPLE_MAJOR_NV });

/// `VkColorBlendAdvancedEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkColorBlendAdvancedEXT {
    pub advancedBlendOp: VkBlendOp,
    pub srcPremultiplied: VkBool32,
    pub dstPremultiplied: VkBool32,
    pub blendOverlap: VkBlendOverlapEXT,
    pub clampResults: VkBool32,
}
impl_default_zeroed!(VkColorBlendAdvancedEXT);

/// `VkColorBlendEquationEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkColorBlendEquationEXT {
    pub srcColorBlendFactor: VkBlendFactor,
    pub dstColorBlendFactor: VkBlendFactor,
    pub colorBlendOp: VkBlendOp,
    pub srcAlphaBlendFactor: VkBlendFactor,
    pub dstAlphaBlendFactor: VkBlendFactor,
    pub alphaBlendOp: VkBlendOp,
}
impl_default_zeroed!(VkColorBlendEquationEXT);

flags!(VkColorComponentFlags);
from_into_transparent!(VkColorComponentFlags: i32);
/// `VkColorComponentFlags`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkColorComponentFlags(pub i32);

/// `1 << 0`  
pub const VK_COLOR_COMPONENT_R_BIT: VkColorComponentFlags = VkColorComponentFlags(1 << 0);
/// `1 << 1`  
pub const VK_COLOR_COMPONENT_G_BIT: VkColorComponentFlags = VkColorComponentFlags(1 << 1);
/// `1 << 2`  
pub const VK_COLOR_COMPONENT_B_BIT: VkColorComponentFlags = VkColorComponentFlags(1 << 2);
/// `1 << 3`  
pub const VK_COLOR_COMPONENT_A_BIT: VkColorComponentFlags = VkColorComponentFlags(1 << 3);

impl_flags_display!(VkColorComponentFlags { VK_COLOR_COMPONENT_R_BIT, VK_COLOR_COMPONENT_G_BIT, VK_COLOR_COMPONENT_B_BIT, VK_COLOR_COMPONENT_A_BIT });

from_into_transparent!(VkColorSpaceKHR: i32);
/// `VkColorSpaceKHR`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkColorSpaceKHR(pub i32);

/// `0`  
pub const VK_COLOR_SPACE_SRGB_NONLINEAR_KHR: VkColorSpaceKHR = VkColorSpaceKHR(0);
/// `VK_COLOR_SPACE_SRGB_NONLINEAR_KHR`  
pub const VK_COLORSPACE_SRGB_NONLINEAR_KHR: VkColorSpaceKHR = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR;
/// `1000104001`  
pub const VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT: VkColorSpaceKHR = VkColorSpaceKHR(1000104001);
/// `1000104002`  
pub const VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT: VkColorSpaceKHR = VkColorSpaceKHR(1000104002);
/// `1000104003`  
pub const VK_COLOR_SPACE_DISPLAY_P3_LINEAR_EXT: VkColorSpaceKHR = VkColorSpaceKHR(1000104003);
/// `1000104004`  
pub const VK_COLOR_SPACE_DCI_P3_NONLINEAR_EXT: VkColorSpaceKHR = VkColorSpaceKHR(1000104004);
/// `1000104005`  
pub const VK_COLOR_SPACE_BT709_LINEAR_EXT: VkColorSpaceKHR = VkColorSpaceKHR(1000104005);
/// `1000104006`  
pub const VK_COLOR_SPACE_BT709_NONLINEAR_EXT: VkColorSpaceKHR = VkColorSpaceKHR(1000104006);
/// `1000104007`  
pub const VK_COLOR_SPACE_BT2020_LINEAR_EXT: VkColorSpaceKHR = VkColorSpaceKHR(1000104007);
/// `1000104008`  
pub const VK_COLOR_SPACE_HDR10_ST2084_EXT: VkColorSpaceKHR = VkColorSpaceKHR(1000104008);
/// `1000104009`  
pub const VK_COLOR_SPACE_DOLBYVISION_EXT: VkColorSpaceKHR = VkColorSpaceKHR(1000104009);
/// `1000104010`  
pub const VK_COLOR_SPACE_HDR10_HLG_EXT: VkColorSpaceKHR = VkColorSpaceKHR(1000104010);
/// `1000104011`  
pub const VK_COLOR_SPACE_ADOBERGB_LINEAR_EXT: VkColorSpaceKHR = VkColorSpaceKHR(1000104011);
/// `1000104012`  
pub const VK_COLOR_SPACE_ADOBERGB_NONLINEAR_EXT: VkColorSpaceKHR = VkColorSpaceKHR(1000104012);
/// `1000104013`  
pub const VK_COLOR_SPACE_PASS_THROUGH_EXT: VkColorSpaceKHR = VkColorSpaceKHR(1000104013);
/// `1000104014`  
pub const VK_COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT: VkColorSpaceKHR = VkColorSpaceKHR(1000104014);
/// `VK_COLOR_SPACE_DISPLAY_P3_LINEAR_EXT`  
pub const VK_COLOR_SPACE_DCI_P3_LINEAR_EXT: VkColorSpaceKHR = VK_COLOR_SPACE_DISPLAY_P3_LINEAR_EXT;
/// `1000213000`  
pub const VK_COLOR_SPACE_DISPLAY_NATIVE_AMD: VkColorSpaceKHR = VkColorSpaceKHR(1000213000);

impl_enum_display!(VkColorSpaceKHR { VK_COLOR_SPACE_SRGB_NONLINEAR_KHR, VK_COLORSPACE_SRGB_NONLINEAR_KHR, VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT, VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT, VK_COLOR_SPACE_DISPLAY_P3_LINEAR_EXT, VK_COLOR_SPACE_DCI_P3_NONLINEAR_EXT, VK_COLOR_SPACE_BT709_LINEAR_EXT, VK_COLOR_SPACE_BT709_NONLINEAR_EXT, VK_COLOR_SPACE_BT2020_LINEAR_EXT, VK_COLOR_SPACE_HDR10_ST2084_EXT, VK_COLOR_SPACE_DOLBYVISION_EXT, VK_COLOR_SPACE_HDR10_HLG_EXT, VK_COLOR_SPACE_ADOBERGB_LINEAR_EXT, VK_COLOR_SPACE_ADOBERGB_NONLINEAR_EXT, VK_COLOR_SPACE_PASS_THROUGH_EXT, VK_COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT, VK_COLOR_SPACE_DCI_P3_LINEAR_EXT, VK_COLOR_SPACE_DISPLAY_NATIVE_AMD });

/// `VkCommandBuffer` : `VkCommandPool`
#[repr(transparent)]
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkCommandBuffer(pub *mut void);
from_into_transparent!(VkCommandBuffer: *mut void);
from_into_transparent!(VkCommandBuffer: u64);
impl_handle!(VkCommandBuffer: VK_OBJECT_TYPE_COMMAND_BUFFER; SubHandle = VkCommandPool);

/// `VkCommandBufferAllocateInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkCommandBufferAllocateInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub commandPool: VkCommandPool,
    pub level: VkCommandBufferLevel,
    pub commandBufferCount: uint32_t,
}
impl_default_zeroed_with_s_type!(VkCommandBufferAllocateInfo : VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO);

/// `VkCommandBufferBeginInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkCommandBufferBeginInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    /// Command buffer usage flags
    pub flags: VkCommandBufferUsageFlags,
    /// Pointer to inheritance info for secondary command buffers
    pub pInheritanceInfo: *const VkCommandBufferInheritanceInfo,
}
impl_default_zeroed_with_s_type!(VkCommandBufferBeginInfo : VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO);

/// `VkCommandBufferInheritanceConditionalRenderingInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkCommandBufferInheritanceConditionalRenderingInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    /// Whether this secondary command buffer may be executed during an active conditional rendering
    pub conditionalRenderingEnable: VkBool32,
}
impl_default_zeroed_with_s_type!(VkCommandBufferInheritanceConditionalRenderingInfoEXT : VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT);
impl_extends!(VkCommandBufferInheritanceConditionalRenderingInfoEXT : VkCommandBufferInheritanceInfo);

/// `VkCommandBufferInheritanceDescriptorHeapInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkCommandBufferInheritanceDescriptorHeapInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub pSamplerHeapBindInfo: *const VkBindHeapInfoEXT,
    pub pResourceHeapBindInfo: *const VkBindHeapInfoEXT,
}
impl_default_zeroed_with_s_type!(VkCommandBufferInheritanceDescriptorHeapInfoEXT : VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_DESCRIPTOR_HEAP_INFO_EXT);
impl_extends!(VkCommandBufferInheritanceDescriptorHeapInfoEXT : VkCommandBufferInheritanceInfo);

/// `VkCommandBufferInheritanceInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkCommandBufferInheritanceInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    /// Render pass for secondary command buffers
    pub renderPass: VkRenderPass,
    pub subpass: uint32_t,
    /// Framebuffer for secondary command buffers
    pub framebuffer: VkFramebuffer,
    /// Whether this secondary command buffer may be executed during an occlusion query
    pub occlusionQueryEnable: VkBool32,
    /// Query flags used by this secondary command buffer, if executed during an occlusion query
    pub queryFlags: VkQueryControlFlags,
    /// Pipeline statistics that may be counted for this secondary command buffer
    pub pipelineStatistics: VkQueryPipelineStatisticFlags,
}
impl_default_zeroed_with_s_type!(VkCommandBufferInheritanceInfo : VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO);

/// `VkCommandBufferInheritanceRenderPassTransformInfoQCOM`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkCommandBufferInheritanceRenderPassTransformInfoQCOM {
    pub sType: VkStructureType,
    /// Pointer to next structure
    pub pNext: *const void,
    pub transform: VkSurfaceTransformFlagsKHR,
    pub renderArea: VkRect2D,
}
impl_default_zeroed_with_s_type!(VkCommandBufferInheritanceRenderPassTransformInfoQCOM : VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM);
impl_extends!(VkCommandBufferInheritanceRenderPassTransformInfoQCOM : VkCommandBufferInheritanceInfo);

/// `VkCommandBufferInheritanceRenderingInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkCommandBufferInheritanceRenderingInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub flags: VkRenderingFlags,
    pub viewMask: uint32_t,
    pub colorAttachmentCount: uint32_t,
    pub pColorAttachmentFormats: *const VkFormat,
    pub depthAttachmentFormat: VkFormat,
    pub stencilAttachmentFormat: VkFormat,
    pub rasterizationSamples: VkSampleCountFlags,
}
impl_default_zeroed_with_s_type!(VkCommandBufferInheritanceRenderingInfo : VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO);
impl_extends!(VkCommandBufferInheritanceRenderingInfo : VkCommandBufferInheritanceInfo);

/// `VkCommandBufferInheritanceRenderingInfo`
pub type VkCommandBufferInheritanceRenderingInfoKHR = VkCommandBufferInheritanceRenderingInfo;

/// `VkCommandBufferInheritanceViewportScissorInfoNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkCommandBufferInheritanceViewportScissorInfoNV {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub viewportScissor2D: VkBool32,
    pub viewportDepthCount: uint32_t,
    pub pViewportDepths: *const VkViewport,
}
impl_default_zeroed_with_s_type!(VkCommandBufferInheritanceViewportScissorInfoNV : VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV);
impl_extends!(VkCommandBufferInheritanceViewportScissorInfoNV : VkCommandBufferInheritanceInfo);

from_into_transparent!(VkCommandBufferLevel: i32);
/// `VkCommandBufferLevel`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkCommandBufferLevel(pub i32);

/// `0`  
pub const VK_COMMAND_BUFFER_LEVEL_PRIMARY: VkCommandBufferLevel = VkCommandBufferLevel(0);
/// `1`  
pub const VK_COMMAND_BUFFER_LEVEL_SECONDARY: VkCommandBufferLevel = VkCommandBufferLevel(1);

impl_enum_display!(VkCommandBufferLevel { VK_COMMAND_BUFFER_LEVEL_PRIMARY, VK_COMMAND_BUFFER_LEVEL_SECONDARY });

flags!(VkCommandBufferResetFlags);
from_into_transparent!(VkCommandBufferResetFlags: i32);
/// `VkCommandBufferResetFlags`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkCommandBufferResetFlags(pub i32);

/// `1 << 0`  
/// 
/// Release resources owned by the buffer
pub const VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT: VkCommandBufferResetFlags = VkCommandBufferResetFlags(1 << 0);

impl_flags_display!(VkCommandBufferResetFlags { VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT });

/// `VkCommandBufferSubmitInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkCommandBufferSubmitInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub commandBuffer: VkCommandBuffer,
    pub deviceMask: uint32_t,
}
impl_default_zeroed_with_s_type!(VkCommandBufferSubmitInfo : VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO);

/// `VkCommandBufferSubmitInfo`
pub type VkCommandBufferSubmitInfoKHR = VkCommandBufferSubmitInfo;

flags!(VkCommandBufferUsageFlags);
from_into_transparent!(VkCommandBufferUsageFlags: i32);
/// `VkCommandBufferUsageFlags`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkCommandBufferUsageFlags(pub i32);

/// `1 << 0`  
pub const VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT: VkCommandBufferUsageFlags = VkCommandBufferUsageFlags(1 << 0);
/// `1 << 1`  
pub const VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT: VkCommandBufferUsageFlags = VkCommandBufferUsageFlags(1 << 1);
/// `1 << 2`  
/// 
/// Command buffer may be submitted/executed more than once simultaneously
pub const VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT: VkCommandBufferUsageFlags = VkCommandBufferUsageFlags(1 << 2);
/// `1 << 3`  
pub const VK_COMMAND_BUFFER_USAGE_RESERVED_3_BIT_HUAWEI: VkCommandBufferUsageFlags = VkCommandBufferUsageFlags(1 << 3);
/// `1 << 4`  
pub const VK_COMMAND_BUFFER_USAGE_RESERVED_4_BIT_HUAWEI: VkCommandBufferUsageFlags = VkCommandBufferUsageFlags(1 << 4);

impl_flags_display!(VkCommandBufferUsageFlags { VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT, VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT, VK_COMMAND_BUFFER_USAGE_RESERVED_3_BIT_HUAWEI, VK_COMMAND_BUFFER_USAGE_RESERVED_4_BIT_HUAWEI });

/// `VkCommandPool` : `VkDevice`
#[repr(transparent)]
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkCommandPool(pub u64);
from_into_transparent!(VkCommandPool: u64);
impl_handle!(VkCommandPool: VK_OBJECT_TYPE_COMMAND_POOL; SubHandle = VkDevice);

flags!(VkCommandPoolCreateFlags);
from_into_transparent!(VkCommandPoolCreateFlags: i32);
/// `VkCommandPoolCreateFlags`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkCommandPoolCreateFlags(pub i32);

/// `1 << 0`  
/// 
/// Command buffers have a short lifetime
pub const VK_COMMAND_POOL_CREATE_TRANSIENT_BIT: VkCommandPoolCreateFlags = VkCommandPoolCreateFlags(1 << 0);
/// `1 << 1`  
/// 
/// Command buffers may release their memory individually
pub const VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT: VkCommandPoolCreateFlags = VkCommandPoolCreateFlags(1 << 1);
/// `1 << 2`  
/// 
/// Command buffers allocated from pool are protected command buffers
pub const VK_COMMAND_POOL_CREATE_PROTECTED_BIT: VkCommandPoolCreateFlags = VkCommandPoolCreateFlags(1 << 2);

impl_flags_display!(VkCommandPoolCreateFlags { VK_COMMAND_POOL_CREATE_TRANSIENT_BIT, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT, VK_COMMAND_POOL_CREATE_PROTECTED_BIT });

/// `VkCommandPoolCreateInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkCommandPoolCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    /// Command pool creation flags
    pub flags: VkCommandPoolCreateFlags,
    pub queueFamilyIndex: uint32_t,
}
impl_default_zeroed_with_s_type!(VkCommandPoolCreateInfo : VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO);

/// `VkCommandPoolMemoryConsumption`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkCommandPoolMemoryConsumption {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub commandPoolAllocated: VkDeviceSize,
    pub commandPoolReservedSize: VkDeviceSize,
    pub commandBufferAllocated: VkDeviceSize,
}
impl_default_zeroed_with_s_type!(VkCommandPoolMemoryConsumption : VK_STRUCTURE_TYPE_COMMAND_POOL_MEMORY_CONSUMPTION);

/// `VkCommandPoolMemoryReservationCreateInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkCommandPoolMemoryReservationCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub commandPoolReservedSize: VkDeviceSize,
    pub commandPoolMaxCommandBuffers: uint32_t,
}
impl_default_zeroed_with_s_type!(VkCommandPoolMemoryReservationCreateInfo : VK_STRUCTURE_TYPE_COMMAND_POOL_MEMORY_RESERVATION_CREATE_INFO);
impl_extends!(VkCommandPoolMemoryReservationCreateInfo : VkCommandPoolCreateInfo);

flags!(VkCommandPoolResetFlags);
from_into_transparent!(VkCommandPoolResetFlags: i32);
/// `VkCommandPoolResetFlags`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkCommandPoolResetFlags(pub i32);

/// `1 << 0`  
/// 
/// Release resources owned by the pool
pub const VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT: VkCommandPoolResetFlags = VkCommandPoolResetFlags(1 << 0);
/// `1 << 1`  
pub const VK_COMMAND_POOL_RESET_RESERVED_1_BIT_COREAVI: VkCommandPoolResetFlags = VkCommandPoolResetFlags(1 << 1);

impl_flags_display!(VkCommandPoolResetFlags { VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT, VK_COMMAND_POOL_RESET_RESERVED_1_BIT_COREAVI });

flags!(VkCommandPoolTrimFlags);
from_into_transparent!(VkCommandPoolTrimFlags: i32);
/// `VkCommandPoolTrimFlags`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkCommandPoolTrimFlags(pub i32);

impl_flags_display!(VkCommandPoolTrimFlags {  });

/// `VkCommandPoolTrimFlags`
pub type VkCommandPoolTrimFlagsKHR = VkCommandPoolTrimFlags;

from_into_transparent!(VkCompareOp: i32);
/// `VkCompareOp`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkCompareOp(pub i32);

/// `0`  
pub const VK_COMPARE_OP_NEVER: VkCompareOp = VkCompareOp(0);
/// `1`  
pub const VK_COMPARE_OP_LESS: VkCompareOp = VkCompareOp(1);
/// `2`  
pub const VK_COMPARE_OP_EQUAL: VkCompareOp = VkCompareOp(2);
/// `3`  
pub const VK_COMPARE_OP_LESS_OR_EQUAL: VkCompareOp = VkCompareOp(3);
/// `4`  
pub const VK_COMPARE_OP_GREATER: VkCompareOp = VkCompareOp(4);
/// `5`  
pub const VK_COMPARE_OP_NOT_EQUAL: VkCompareOp = VkCompareOp(5);
/// `6`  
pub const VK_COMPARE_OP_GREATER_OR_EQUAL: VkCompareOp = VkCompareOp(6);
/// `7`  
pub const VK_COMPARE_OP_ALWAYS: VkCompareOp = VkCompareOp(7);

impl_enum_display!(VkCompareOp { VK_COMPARE_OP_NEVER, VK_COMPARE_OP_LESS, VK_COMPARE_OP_EQUAL, VK_COMPARE_OP_LESS_OR_EQUAL, VK_COMPARE_OP_GREATER, VK_COMPARE_OP_NOT_EQUAL, VK_COMPARE_OP_GREATER_OR_EQUAL, VK_COMPARE_OP_ALWAYS });

/// `VkComponentMapping`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkComponentMapping {
    pub r: VkComponentSwizzle,
    pub g: VkComponentSwizzle,
    pub b: VkComponentSwizzle,
    pub a: VkComponentSwizzle,
}
impl_default_zeroed!(VkComponentMapping);

from_into_transparent!(VkComponentSwizzle: i32);
/// `VkComponentSwizzle`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkComponentSwizzle(pub i32);

/// `0`  
pub const VK_COMPONENT_SWIZZLE_IDENTITY: VkComponentSwizzle = VkComponentSwizzle(0);
/// `1`  
pub const VK_COMPONENT_SWIZZLE_ZERO: VkComponentSwizzle = VkComponentSwizzle(1);
/// `2`  
pub const VK_COMPONENT_SWIZZLE_ONE: VkComponentSwizzle = VkComponentSwizzle(2);
/// `3`  
pub const VK_COMPONENT_SWIZZLE_R: VkComponentSwizzle = VkComponentSwizzle(3);
/// `4`  
pub const VK_COMPONENT_SWIZZLE_G: VkComponentSwizzle = VkComponentSwizzle(4);
/// `5`  
pub const VK_COMPONENT_SWIZZLE_B: VkComponentSwizzle = VkComponentSwizzle(5);
/// `6`  
pub const VK_COMPONENT_SWIZZLE_A: VkComponentSwizzle = VkComponentSwizzle(6);

impl_enum_display!(VkComponentSwizzle { VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_ZERO, VK_COMPONENT_SWIZZLE_ONE, VK_COMPONENT_SWIZZLE_R, VK_COMPONENT_SWIZZLE_G, VK_COMPONENT_SWIZZLE_B, VK_COMPONENT_SWIZZLE_A });

from_into_transparent!(VkComponentTypeKHR: i32);
/// `VkComponentTypeKHR`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkComponentTypeKHR(pub i32);

/// `0`  
pub const VK_COMPONENT_TYPE_FLOAT16_KHR: VkComponentTypeKHR = VkComponentTypeKHR(0);
/// `1`  
pub const VK_COMPONENT_TYPE_FLOAT32_KHR: VkComponentTypeKHR = VkComponentTypeKHR(1);
/// `2`  
pub const VK_COMPONENT_TYPE_FLOAT64_KHR: VkComponentTypeKHR = VkComponentTypeKHR(2);
/// `3`  
pub const VK_COMPONENT_TYPE_SINT8_KHR: VkComponentTypeKHR = VkComponentTypeKHR(3);
/// `4`  
pub const VK_COMPONENT_TYPE_SINT16_KHR: VkComponentTypeKHR = VkComponentTypeKHR(4);
/// `5`  
pub const VK_COMPONENT_TYPE_SINT32_KHR: VkComponentTypeKHR = VkComponentTypeKHR(5);
/// `6`  
pub const VK_COMPONENT_TYPE_SINT64_KHR: VkComponentTypeKHR = VkComponentTypeKHR(6);
/// `7`  
pub const VK_COMPONENT_TYPE_UINT8_KHR: VkComponentTypeKHR = VkComponentTypeKHR(7);
/// `8`  
pub const VK_COMPONENT_TYPE_UINT16_KHR: VkComponentTypeKHR = VkComponentTypeKHR(8);
/// `9`  
pub const VK_COMPONENT_TYPE_UINT32_KHR: VkComponentTypeKHR = VkComponentTypeKHR(9);
/// `10`  
pub const VK_COMPONENT_TYPE_UINT64_KHR: VkComponentTypeKHR = VkComponentTypeKHR(10);
/// `1000141000`  
pub const VK_COMPONENT_TYPE_BFLOAT16_KHR: VkComponentTypeKHR = VkComponentTypeKHR(1000141000);
/// `VK_COMPONENT_TYPE_FLOAT16_KHR`  
pub const VK_COMPONENT_TYPE_FLOAT16_NV: VkComponentTypeKHR = VK_COMPONENT_TYPE_FLOAT16_KHR;
/// `VK_COMPONENT_TYPE_FLOAT32_KHR`  
pub const VK_COMPONENT_TYPE_FLOAT32_NV: VkComponentTypeKHR = VK_COMPONENT_TYPE_FLOAT32_KHR;
/// `VK_COMPONENT_TYPE_FLOAT64_KHR`  
pub const VK_COMPONENT_TYPE_FLOAT64_NV: VkComponentTypeKHR = VK_COMPONENT_TYPE_FLOAT64_KHR;
/// `VK_COMPONENT_TYPE_SINT8_KHR`  
pub const VK_COMPONENT_TYPE_SINT8_NV: VkComponentTypeKHR = VK_COMPONENT_TYPE_SINT8_KHR;
/// `VK_COMPONENT_TYPE_SINT16_KHR`  
pub const VK_COMPONENT_TYPE_SINT16_NV: VkComponentTypeKHR = VK_COMPONENT_TYPE_SINT16_KHR;
/// `VK_COMPONENT_TYPE_SINT32_KHR`  
pub const VK_COMPONENT_TYPE_SINT32_NV: VkComponentTypeKHR = VK_COMPONENT_TYPE_SINT32_KHR;
/// `VK_COMPONENT_TYPE_SINT64_KHR`  
pub const VK_COMPONENT_TYPE_SINT64_NV: VkComponentTypeKHR = VK_COMPONENT_TYPE_SINT64_KHR;
/// `VK_COMPONENT_TYPE_UINT8_KHR`  
pub const VK_COMPONENT_TYPE_UINT8_NV: VkComponentTypeKHR = VK_COMPONENT_TYPE_UINT8_KHR;
/// `VK_COMPONENT_TYPE_UINT16_KHR`  
pub const VK_COMPONENT_TYPE_UINT16_NV: VkComponentTypeKHR = VK_COMPONENT_TYPE_UINT16_KHR;
/// `VK_COMPONENT_TYPE_UINT32_KHR`  
pub const VK_COMPONENT_TYPE_UINT32_NV: VkComponentTypeKHR = VK_COMPONENT_TYPE_UINT32_KHR;
/// `VK_COMPONENT_TYPE_UINT64_KHR`  
pub const VK_COMPONENT_TYPE_UINT64_NV: VkComponentTypeKHR = VK_COMPONENT_TYPE_UINT64_KHR;
/// `1000491000`  
pub const VK_COMPONENT_TYPE_SINT8_PACKED_NV: VkComponentTypeKHR = VkComponentTypeKHR(1000491000);
/// `1000491001`  
pub const VK_COMPONENT_TYPE_UINT8_PACKED_NV: VkComponentTypeKHR = VkComponentTypeKHR(1000491001);
/// `VK_COMPONENT_TYPE_FLOAT8_E4M3_EXT`  
pub const VK_COMPONENT_TYPE_FLOAT_E4M3_NV: VkComponentTypeKHR = VK_COMPONENT_TYPE_FLOAT8_E4M3_EXT;
/// `VK_COMPONENT_TYPE_FLOAT8_E5M2_EXT`  
pub const VK_COMPONENT_TYPE_FLOAT_E5M2_NV: VkComponentTypeKHR = VK_COMPONENT_TYPE_FLOAT8_E5M2_EXT;
/// `1000491002`  
pub const VK_COMPONENT_TYPE_FLOAT8_E4M3_EXT: VkComponentTypeKHR = VkComponentTypeKHR(1000491002);
/// `1000491003`  
pub const VK_COMPONENT_TYPE_FLOAT8_E5M2_EXT: VkComponentTypeKHR = VkComponentTypeKHR(1000491003);

impl_enum_display!(VkComponentTypeKHR { VK_COMPONENT_TYPE_FLOAT16_KHR, VK_COMPONENT_TYPE_FLOAT32_KHR, VK_COMPONENT_TYPE_FLOAT64_KHR, VK_COMPONENT_TYPE_SINT8_KHR, VK_COMPONENT_TYPE_SINT16_KHR, VK_COMPONENT_TYPE_SINT32_KHR, VK_COMPONENT_TYPE_SINT64_KHR, VK_COMPONENT_TYPE_UINT8_KHR, VK_COMPONENT_TYPE_UINT16_KHR, VK_COMPONENT_TYPE_UINT32_KHR, VK_COMPONENT_TYPE_UINT64_KHR, VK_COMPONENT_TYPE_BFLOAT16_KHR, VK_COMPONENT_TYPE_FLOAT16_NV, VK_COMPONENT_TYPE_FLOAT32_NV, VK_COMPONENT_TYPE_FLOAT64_NV, VK_COMPONENT_TYPE_SINT8_NV, VK_COMPONENT_TYPE_SINT16_NV, VK_COMPONENT_TYPE_SINT32_NV, VK_COMPONENT_TYPE_SINT64_NV, VK_COMPONENT_TYPE_UINT8_NV, VK_COMPONENT_TYPE_UINT16_NV, VK_COMPONENT_TYPE_UINT32_NV, VK_COMPONENT_TYPE_UINT64_NV, VK_COMPONENT_TYPE_SINT8_PACKED_NV, VK_COMPONENT_TYPE_UINT8_PACKED_NV, VK_COMPONENT_TYPE_FLOAT_E4M3_NV, VK_COMPONENT_TYPE_FLOAT_E5M2_NV, VK_COMPONENT_TYPE_FLOAT8_E4M3_EXT, VK_COMPONENT_TYPE_FLOAT8_E5M2_EXT });

/// `VkComponentTypeKHR`
pub type VkComponentTypeNV = VkComponentTypeKHR;

flags!(VkCompositeAlphaFlagsKHR);
from_into_transparent!(VkCompositeAlphaFlagsKHR: i32);
/// `VkCompositeAlphaFlagsKHR`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkCompositeAlphaFlagsKHR(pub i32);

/// `1 << 0`  
pub const VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR: VkCompositeAlphaFlagsKHR = VkCompositeAlphaFlagsKHR(1 << 0);
/// `1 << 1`  
pub const VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR: VkCompositeAlphaFlagsKHR = VkCompositeAlphaFlagsKHR(1 << 1);
/// `1 << 2`  
pub const VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR: VkCompositeAlphaFlagsKHR = VkCompositeAlphaFlagsKHR(1 << 2);
/// `1 << 3`  
pub const VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR: VkCompositeAlphaFlagsKHR = VkCompositeAlphaFlagsKHR(1 << 3);

impl_flags_display!(VkCompositeAlphaFlagsKHR { VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR, VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR, VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR, VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR });

from_into_transparent!(VkCompressedTriangleFormatAMDX: i32);
/// `VkCompressedTriangleFormatAMDX`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkCompressedTriangleFormatAMDX(pub i32);

/// `0`  
pub const VK_COMPRESSED_TRIANGLE_FORMAT_DGF1_AMDX: VkCompressedTriangleFormatAMDX = VkCompressedTriangleFormatAMDX(0);

impl_enum_display!(VkCompressedTriangleFormatAMDX { VK_COMPRESSED_TRIANGLE_FORMAT_DGF1_AMDX });

/// `VkComputeOccupancyPriorityParametersNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkComputeOccupancyPriorityParametersNV {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub occupancyPriority: float,
    pub occupancyThrottling: float,
}
impl_default_zeroed_with_s_type!(VkComputeOccupancyPriorityParametersNV : VK_STRUCTURE_TYPE_COMPUTE_OCCUPANCY_PRIORITY_PARAMETERS_NV);

/// `VkComputePipelineCreateInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkComputePipelineCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    /// Pipeline creation flags
    pub flags: VkPipelineCreateFlags,
    pub stage: VkPipelineShaderStageCreateInfo,
    /// Interface layout of the pipeline
    pub layout: VkPipelineLayout,
    /// 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 basePipelineHandle: VkPipeline,
    /// 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 basePipelineIndex: int32_t,
}
impl_default_zeroed_with_s_type!(VkComputePipelineCreateInfo : VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO);

/// `VkComputePipelineIndirectBufferInfoNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkComputePipelineIndirectBufferInfoNV {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub deviceAddress: VkDeviceAddress,
    pub size: VkDeviceSize,
    pub pipelineDeviceAddressCaptureReplay: VkDeviceAddress,
}
impl_default_zeroed_with_s_type!(VkComputePipelineIndirectBufferInfoNV : VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_INDIRECT_BUFFER_INFO_NV);
impl_extends!(VkComputePipelineIndirectBufferInfoNV : VkComputePipelineCreateInfo);

/// `VkConditionalRenderingBeginInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkConditionalRenderingBeginInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub buffer: VkBuffer,
    pub offset: VkDeviceSize,
    pub flags: VkConditionalRenderingFlagsEXT,
}
impl_default_zeroed_with_s_type!(VkConditionalRenderingBeginInfoEXT : VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT);

flags!(VkConditionalRenderingFlagsEXT);
from_into_transparent!(VkConditionalRenderingFlagsEXT: i32);
/// `VkConditionalRenderingFlagsEXT`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkConditionalRenderingFlagsEXT(pub i32);

/// `1 << 0`  
pub const VK_CONDITIONAL_RENDERING_INVERTED_BIT_EXT: VkConditionalRenderingFlagsEXT = VkConditionalRenderingFlagsEXT(1 << 0);

impl_flags_display!(VkConditionalRenderingFlagsEXT { VK_CONDITIONAL_RENDERING_INVERTED_BIT_EXT });

/// `VkConformanceVersion`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkConformanceVersion {
    pub major: uint8_t,
    pub minor: uint8_t,
    pub subminor: uint8_t,
    pub patch: uint8_t,
}
impl_default_zeroed!(VkConformanceVersion);

/// `VkConformanceVersion`
pub type VkConformanceVersionKHR = VkConformanceVersion;

from_into_transparent!(VkConservativeRasterizationModeEXT: i32);
/// `VkConservativeRasterizationModeEXT`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkConservativeRasterizationModeEXT(pub i32);

/// `0`  
pub const VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT: VkConservativeRasterizationModeEXT = VkConservativeRasterizationModeEXT(0);
/// `1`  
pub const VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT: VkConservativeRasterizationModeEXT = VkConservativeRasterizationModeEXT(1);
/// `2`  
pub const VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT: VkConservativeRasterizationModeEXT = VkConservativeRasterizationModeEXT(2);

impl_enum_display!(VkConservativeRasterizationModeEXT { VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT, VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT, VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT });

/// `VkConvertCooperativeVectorMatrixInfoNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkConvertCooperativeVectorMatrixInfoNV {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub srcSize: size_t,
    pub srcData: VkDeviceOrHostAddressConstKHR,
    pub pDstSize: *mut size_t,
    pub dstData: VkDeviceOrHostAddressKHR,
    pub srcComponentType: VkComponentTypeKHR,
    pub dstComponentType: VkComponentTypeKHR,
    pub numRows: uint32_t,
    pub numColumns: uint32_t,
    pub srcLayout: VkCooperativeVectorMatrixLayoutNV,
    pub srcStride: size_t,
    pub dstLayout: VkCooperativeVectorMatrixLayoutNV,
    pub dstStride: size_t,
}
impl_default_zeroed_with_s_type!(VkConvertCooperativeVectorMatrixInfoNV : VK_STRUCTURE_TYPE_CONVERT_COOPERATIVE_VECTOR_MATRIX_INFO_NV);

/// `VkCooperativeMatrixFlexibleDimensionsPropertiesNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkCooperativeMatrixFlexibleDimensionsPropertiesNV {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub MGranularity: uint32_t,
    pub NGranularity: uint32_t,
    pub KGranularity: uint32_t,
    pub AType: VkComponentTypeKHR,
    pub BType: VkComponentTypeKHR,
    pub CType: VkComponentTypeKHR,
    pub ResultType: VkComponentTypeKHR,
    pub saturatingAccumulation: VkBool32,
    pub scope: VkScopeKHR,
    pub workgroupInvocations: uint32_t,
}
impl_default_zeroed_with_s_type!(VkCooperativeMatrixFlexibleDimensionsPropertiesNV : VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_FLEXIBLE_DIMENSIONS_PROPERTIES_NV);

/// `VkCooperativeMatrixPropertiesKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkCooperativeMatrixPropertiesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub MSize: uint32_t,
    pub NSize: uint32_t,
    pub KSize: uint32_t,
    pub AType: VkComponentTypeKHR,
    pub BType: VkComponentTypeKHR,
    pub CType: VkComponentTypeKHR,
    pub ResultType: VkComponentTypeKHR,
    pub saturatingAccumulation: VkBool32,
    pub scope: VkScopeKHR,
}
impl_default_zeroed_with_s_type!(VkCooperativeMatrixPropertiesKHR : VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_KHR);

/// `VkCooperativeMatrixPropertiesNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkCooperativeMatrixPropertiesNV {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub MSize: uint32_t,
    pub NSize: uint32_t,
    pub KSize: uint32_t,
    pub AType: VkComponentTypeNV,
    pub BType: VkComponentTypeNV,
    pub CType: VkComponentTypeNV,
    pub DType: VkComponentTypeNV,
    pub scope: VkScopeNV,
}
impl_default_zeroed_with_s_type!(VkCooperativeMatrixPropertiesNV : VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_NV);

from_into_transparent!(VkCooperativeVectorMatrixLayoutNV: i32);
/// `VkCooperativeVectorMatrixLayoutNV`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkCooperativeVectorMatrixLayoutNV(pub i32);

/// `0`  
pub const VK_COOPERATIVE_VECTOR_MATRIX_LAYOUT_ROW_MAJOR_NV: VkCooperativeVectorMatrixLayoutNV = VkCooperativeVectorMatrixLayoutNV(0);
/// `1`  
pub const VK_COOPERATIVE_VECTOR_MATRIX_LAYOUT_COLUMN_MAJOR_NV: VkCooperativeVectorMatrixLayoutNV = VkCooperativeVectorMatrixLayoutNV(1);
/// `2`  
pub const VK_COOPERATIVE_VECTOR_MATRIX_LAYOUT_INFERENCING_OPTIMAL_NV: VkCooperativeVectorMatrixLayoutNV = VkCooperativeVectorMatrixLayoutNV(2);
/// `3`  
pub const VK_COOPERATIVE_VECTOR_MATRIX_LAYOUT_TRAINING_OPTIMAL_NV: VkCooperativeVectorMatrixLayoutNV = VkCooperativeVectorMatrixLayoutNV(3);

impl_enum_display!(VkCooperativeVectorMatrixLayoutNV { VK_COOPERATIVE_VECTOR_MATRIX_LAYOUT_ROW_MAJOR_NV, VK_COOPERATIVE_VECTOR_MATRIX_LAYOUT_COLUMN_MAJOR_NV, VK_COOPERATIVE_VECTOR_MATRIX_LAYOUT_INFERENCING_OPTIMAL_NV, VK_COOPERATIVE_VECTOR_MATRIX_LAYOUT_TRAINING_OPTIMAL_NV });

/// `VkCooperativeVectorPropertiesNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkCooperativeVectorPropertiesNV {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub inputType: VkComponentTypeKHR,
    pub inputInterpretation: VkComponentTypeKHR,
    pub matrixInterpretation: VkComponentTypeKHR,
    pub biasInterpretation: VkComponentTypeKHR,
    pub resultType: VkComponentTypeKHR,
    pub transpose: VkBool32,
}
impl_default_zeroed_with_s_type!(VkCooperativeVectorPropertiesNV : VK_STRUCTURE_TYPE_COOPERATIVE_VECTOR_PROPERTIES_NV);

/// `VkCopyAccelerationStructureInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkCopyAccelerationStructureInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub src: VkAccelerationStructureKHR,
    pub dst: VkAccelerationStructureKHR,
    pub mode: VkCopyAccelerationStructureModeKHR,
}
impl_default_zeroed_with_s_type!(VkCopyAccelerationStructureInfoKHR : VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_INFO_KHR);

from_into_transparent!(VkCopyAccelerationStructureModeKHR: i32);
/// `VkCopyAccelerationStructureModeKHR`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkCopyAccelerationStructureModeKHR(pub i32);

/// `0`  
pub const VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_KHR: VkCopyAccelerationStructureModeKHR = VkCopyAccelerationStructureModeKHR(0);
/// `1`  
pub const VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_KHR: VkCopyAccelerationStructureModeKHR = VkCopyAccelerationStructureModeKHR(1);
/// `2`  
pub const VK_COPY_ACCELERATION_STRUCTURE_MODE_SERIALIZE_KHR: VkCopyAccelerationStructureModeKHR = VkCopyAccelerationStructureModeKHR(2);
/// `3`  
pub const VK_COPY_ACCELERATION_STRUCTURE_MODE_DESERIALIZE_KHR: VkCopyAccelerationStructureModeKHR = VkCopyAccelerationStructureModeKHR(3);
/// `VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_KHR`  
pub const VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_NV: VkCopyAccelerationStructureModeKHR = VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_KHR;
/// `VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_KHR`  
pub const VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_NV: VkCopyAccelerationStructureModeKHR = VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_KHR;

impl_enum_display!(VkCopyAccelerationStructureModeKHR { VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_KHR, VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_KHR, VK_COPY_ACCELERATION_STRUCTURE_MODE_SERIALIZE_KHR, VK_COPY_ACCELERATION_STRUCTURE_MODE_DESERIALIZE_KHR, VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_NV, VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_NV });

/// `VkCopyAccelerationStructureModeKHR`
pub type VkCopyAccelerationStructureModeNV = VkCopyAccelerationStructureModeKHR;

/// `VkCopyAccelerationStructureToMemoryInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkCopyAccelerationStructureToMemoryInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub src: VkAccelerationStructureKHR,
    pub dst: VkDeviceOrHostAddressKHR,
    pub mode: VkCopyAccelerationStructureModeKHR,
}
impl_default_zeroed_with_s_type!(VkCopyAccelerationStructureToMemoryInfoKHR : VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR);

/// `VkCopyBufferInfo2`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkCopyBufferInfo2 {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub srcBuffer: VkBuffer,
    pub dstBuffer: VkBuffer,
    pub regionCount: uint32_t,
    pub pRegions: *const VkBufferCopy2,
}
impl_default_zeroed_with_s_type!(VkCopyBufferInfo2 : VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2);

/// `VkCopyBufferInfo2`
pub type VkCopyBufferInfo2KHR = VkCopyBufferInfo2;

/// `VkCopyBufferToImageInfo2`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkCopyBufferToImageInfo2 {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub srcBuffer: VkBuffer,
    pub dstImage: VkImage,
    pub dstImageLayout: VkImageLayout,
    pub regionCount: uint32_t,
    pub pRegions: *const VkBufferImageCopy2,
}
impl_default_zeroed_with_s_type!(VkCopyBufferToImageInfo2 : VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2);

/// `VkCopyBufferToImageInfo2`
pub type VkCopyBufferToImageInfo2KHR = VkCopyBufferToImageInfo2;

/// `VkCopyCommandTransformInfoQCOM`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkCopyCommandTransformInfoQCOM {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub transform: VkSurfaceTransformFlagsKHR,
}
impl_default_zeroed_with_s_type!(VkCopyCommandTransformInfoQCOM : VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM);
impl_extends!(VkCopyCommandTransformInfoQCOM : VkBufferImageCopy2, VkImageBlit2);

/// `VkCopyDescriptorSet`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkCopyDescriptorSet {
    pub sType: VkStructureType,
    pub pNext: *const void,
    /// Source descriptor set
    pub srcSet: VkDescriptorSet,
    /// Binding within the source descriptor set to copy from
    pub srcBinding: uint32_t,
    /// Array element within the source binding to copy from
    pub srcArrayElement: uint32_t,
    /// Destination descriptor set
    pub dstSet: VkDescriptorSet,
    /// Binding within the destination descriptor set to copy to
    pub dstBinding: uint32_t,
    /// Array element within the destination binding to copy to
    pub dstArrayElement: uint32_t,
    /// Number of descriptors to write (determines the size of the array pointed by pDescriptors)
    pub descriptorCount: uint32_t,
}
impl_default_zeroed_with_s_type!(VkCopyDescriptorSet : VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET);

/// `VkCopyImageInfo2`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkCopyImageInfo2 {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub srcImage: VkImage,
    pub srcImageLayout: VkImageLayout,
    pub dstImage: VkImage,
    pub dstImageLayout: VkImageLayout,
    pub regionCount: uint32_t,
    pub pRegions: *const VkImageCopy2,
}
impl_default_zeroed_with_s_type!(VkCopyImageInfo2 : VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2);

/// `VkCopyImageInfo2`
pub type VkCopyImageInfo2KHR = VkCopyImageInfo2;

/// `VkCopyImageToBufferInfo2`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkCopyImageToBufferInfo2 {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub srcImage: VkImage,
    pub srcImageLayout: VkImageLayout,
    pub dstBuffer: VkBuffer,
    pub regionCount: uint32_t,
    pub pRegions: *const VkBufferImageCopy2,
}
impl_default_zeroed_with_s_type!(VkCopyImageToBufferInfo2 : VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2);

/// `VkCopyImageToBufferInfo2`
pub type VkCopyImageToBufferInfo2KHR = VkCopyImageToBufferInfo2;

/// `VkCopyImageToImageInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkCopyImageToImageInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub flags: VkHostImageCopyFlags,
    pub srcImage: VkImage,
    pub srcImageLayout: VkImageLayout,
    pub dstImage: VkImage,
    pub dstImageLayout: VkImageLayout,
    pub regionCount: uint32_t,
    pub pRegions: *const VkImageCopy2,
}
impl_default_zeroed_with_s_type!(VkCopyImageToImageInfo : VK_STRUCTURE_TYPE_COPY_IMAGE_TO_IMAGE_INFO);

/// `VkCopyImageToImageInfo`
pub type VkCopyImageToImageInfoEXT = VkCopyImageToImageInfo;

/// `VkCopyImageToMemoryInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkCopyImageToMemoryInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub flags: VkHostImageCopyFlags,
    pub srcImage: VkImage,
    pub srcImageLayout: VkImageLayout,
    pub regionCount: uint32_t,
    pub pRegions: *const VkImageToMemoryCopy,
}
impl_default_zeroed_with_s_type!(VkCopyImageToMemoryInfo : VK_STRUCTURE_TYPE_COPY_IMAGE_TO_MEMORY_INFO);

/// `VkCopyImageToMemoryInfo`
pub type VkCopyImageToMemoryInfoEXT = VkCopyImageToMemoryInfo;

/// `VkCopyMemoryIndirectCommandKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkCopyMemoryIndirectCommandKHR {
    pub srcAddress: VkDeviceAddress,
    pub dstAddress: VkDeviceAddress,
    pub size: VkDeviceSize,
}
impl_default_zeroed!(VkCopyMemoryIndirectCommandKHR);

/// `VkCopyMemoryIndirectCommandKHR`
pub type VkCopyMemoryIndirectCommandNV = VkCopyMemoryIndirectCommandKHR;

/// `VkCopyMemoryIndirectInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkCopyMemoryIndirectInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub srcCopyFlags: VkAddressCopyFlagsKHR,
    pub dstCopyFlags: VkAddressCopyFlagsKHR,
    pub copyCount: uint32_t,
    pub copyAddressRange: VkStridedDeviceAddressRangeKHR,
}
impl_default_zeroed_with_s_type!(VkCopyMemoryIndirectInfoKHR : VK_STRUCTURE_TYPE_COPY_MEMORY_INDIRECT_INFO_KHR);

/// `VkCopyMemoryToAccelerationStructureInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkCopyMemoryToAccelerationStructureInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub src: VkDeviceOrHostAddressConstKHR,
    pub dst: VkAccelerationStructureKHR,
    pub mode: VkCopyAccelerationStructureModeKHR,
}
impl_default_zeroed_with_s_type!(VkCopyMemoryToAccelerationStructureInfoKHR : VK_STRUCTURE_TYPE_COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR);

/// `VkCopyMemoryToImageIndirectCommandKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkCopyMemoryToImageIndirectCommandKHR {
    pub srcAddress: VkDeviceAddress,
    pub bufferRowLength: uint32_t,
    pub bufferImageHeight: uint32_t,
    pub imageSubresource: VkImageSubresourceLayers,
    pub imageOffset: VkOffset3D,
    pub imageExtent: VkExtent3D,
}
impl_default_zeroed!(VkCopyMemoryToImageIndirectCommandKHR);

/// `VkCopyMemoryToImageIndirectCommandKHR`
pub type VkCopyMemoryToImageIndirectCommandNV = VkCopyMemoryToImageIndirectCommandKHR;

/// `VkCopyMemoryToImageIndirectInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkCopyMemoryToImageIndirectInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub srcCopyFlags: VkAddressCopyFlagsKHR,
    pub copyCount: uint32_t,
    pub copyAddressRange: VkStridedDeviceAddressRangeKHR,
    pub dstImage: VkImage,
    pub dstImageLayout: VkImageLayout,
    pub pImageSubresources: *const VkImageSubresourceLayers,
}
impl_default_zeroed_with_s_type!(VkCopyMemoryToImageIndirectInfoKHR : VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INDIRECT_INFO_KHR);

/// `VkCopyMemoryToImageInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkCopyMemoryToImageInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub flags: VkHostImageCopyFlags,
    pub dstImage: VkImage,
    pub dstImageLayout: VkImageLayout,
    pub regionCount: uint32_t,
    pub pRegions: *const VkMemoryToImageCopy,
}
impl_default_zeroed_with_s_type!(VkCopyMemoryToImageInfo : VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INFO);

/// `VkCopyMemoryToImageInfo`
pub type VkCopyMemoryToImageInfoEXT = VkCopyMemoryToImageInfo;

/// `VkCopyMemoryToMicromapInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkCopyMemoryToMicromapInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub src: VkDeviceOrHostAddressConstKHR,
    pub dst: VkMicromapEXT,
    pub mode: VkCopyMicromapModeEXT,
}
impl_default_zeroed_with_s_type!(VkCopyMemoryToMicromapInfoEXT : VK_STRUCTURE_TYPE_COPY_MEMORY_TO_MICROMAP_INFO_EXT);

/// `VkCopyMicromapInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkCopyMicromapInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub src: VkMicromapEXT,
    pub dst: VkMicromapEXT,
    pub mode: VkCopyMicromapModeEXT,
}
impl_default_zeroed_with_s_type!(VkCopyMicromapInfoEXT : VK_STRUCTURE_TYPE_COPY_MICROMAP_INFO_EXT);

from_into_transparent!(VkCopyMicromapModeEXT: i32);
/// `VkCopyMicromapModeEXT`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkCopyMicromapModeEXT(pub i32);

/// `0`  
pub const VK_COPY_MICROMAP_MODE_CLONE_EXT: VkCopyMicromapModeEXT = VkCopyMicromapModeEXT(0);
/// `1`  
pub const VK_COPY_MICROMAP_MODE_SERIALIZE_EXT: VkCopyMicromapModeEXT = VkCopyMicromapModeEXT(1);
/// `2`  
pub const VK_COPY_MICROMAP_MODE_DESERIALIZE_EXT: VkCopyMicromapModeEXT = VkCopyMicromapModeEXT(2);
/// `3`  
pub const VK_COPY_MICROMAP_MODE_COMPACT_EXT: VkCopyMicromapModeEXT = VkCopyMicromapModeEXT(3);

impl_enum_display!(VkCopyMicromapModeEXT { VK_COPY_MICROMAP_MODE_CLONE_EXT, VK_COPY_MICROMAP_MODE_SERIALIZE_EXT, VK_COPY_MICROMAP_MODE_DESERIALIZE_EXT, VK_COPY_MICROMAP_MODE_COMPACT_EXT });

/// `VkCopyMicromapToMemoryInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkCopyMicromapToMemoryInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub src: VkMicromapEXT,
    pub dst: VkDeviceOrHostAddressKHR,
    pub mode: VkCopyMicromapModeEXT,
}
impl_default_zeroed_with_s_type!(VkCopyMicromapToMemoryInfoEXT : VK_STRUCTURE_TYPE_COPY_MICROMAP_TO_MEMORY_INFO_EXT);

/// `VkCopyTensorInfoARM`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkCopyTensorInfoARM {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub srcTensor: VkTensorARM,
    pub dstTensor: VkTensorARM,
    pub regionCount: uint32_t,
    pub pRegions: *const VkTensorCopyARM,
}
impl_default_zeroed_with_s_type!(VkCopyTensorInfoARM : VK_STRUCTURE_TYPE_COPY_TENSOR_INFO_ARM);

from_into_transparent!(VkCoverageModulationModeNV: i32);
/// `VkCoverageModulationModeNV`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkCoverageModulationModeNV(pub i32);

/// `0`  
pub const VK_COVERAGE_MODULATION_MODE_NONE_NV: VkCoverageModulationModeNV = VkCoverageModulationModeNV(0);
/// `1`  
pub const VK_COVERAGE_MODULATION_MODE_RGB_NV: VkCoverageModulationModeNV = VkCoverageModulationModeNV(1);
/// `2`  
pub const VK_COVERAGE_MODULATION_MODE_ALPHA_NV: VkCoverageModulationModeNV = VkCoverageModulationModeNV(2);
/// `3`  
pub const VK_COVERAGE_MODULATION_MODE_RGBA_NV: VkCoverageModulationModeNV = VkCoverageModulationModeNV(3);

impl_enum_display!(VkCoverageModulationModeNV { VK_COVERAGE_MODULATION_MODE_NONE_NV, VK_COVERAGE_MODULATION_MODE_RGB_NV, VK_COVERAGE_MODULATION_MODE_ALPHA_NV, VK_COVERAGE_MODULATION_MODE_RGBA_NV });

from_into_transparent!(VkCoverageReductionModeNV: i32);
/// `VkCoverageReductionModeNV`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkCoverageReductionModeNV(pub i32);

/// `0`  
pub const VK_COVERAGE_REDUCTION_MODE_MERGE_NV: VkCoverageReductionModeNV = VkCoverageReductionModeNV(0);
/// `1`  
pub const VK_COVERAGE_REDUCTION_MODE_TRUNCATE_NV: VkCoverageReductionModeNV = VkCoverageReductionModeNV(1);

impl_enum_display!(VkCoverageReductionModeNV { VK_COVERAGE_REDUCTION_MODE_MERGE_NV, VK_COVERAGE_REDUCTION_MODE_TRUNCATE_NV });

/// `VkCuFunctionCreateInfoNVX`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkCuFunctionCreateInfoNVX {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub module: VkCuModuleNVX,
    pub pName: *const c_char,
}
impl_default_zeroed_with_s_type!(VkCuFunctionCreateInfoNVX : VK_STRUCTURE_TYPE_CU_FUNCTION_CREATE_INFO_NVX);

/// `VkCuFunctionNVX` : `VkDevice`
#[repr(transparent)]
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkCuFunctionNVX(pub u64);
from_into_transparent!(VkCuFunctionNVX: u64);
impl_handle!(VkCuFunctionNVX: VK_OBJECT_TYPE_CU_FUNCTION_NVX; SubHandle = VkDevice);

/// `VkCuLaunchInfoNVX`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkCuLaunchInfoNVX {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub function: VkCuFunctionNVX,
    pub gridDimX: uint32_t,
    pub gridDimY: uint32_t,
    pub gridDimZ: uint32_t,
    pub blockDimX: uint32_t,
    pub blockDimY: uint32_t,
    pub blockDimZ: uint32_t,
    pub sharedMemBytes: uint32_t,
    pub paramCount: size_t,
    pub pParams: *const void,
    pub extraCount: size_t,
    pub pExtras: *const void,
}
impl_default_zeroed_with_s_type!(VkCuLaunchInfoNVX : VK_STRUCTURE_TYPE_CU_LAUNCH_INFO_NVX);

/// `VkCuModuleCreateInfoNVX`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkCuModuleCreateInfoNVX {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub dataSize: size_t,
    pub pData: *const void,
}
impl_default_zeroed_with_s_type!(VkCuModuleCreateInfoNVX : VK_STRUCTURE_TYPE_CU_MODULE_CREATE_INFO_NVX);

/// `VkCuModuleNVX` : `VkDevice`
#[repr(transparent)]
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkCuModuleNVX(pub u64);
from_into_transparent!(VkCuModuleNVX: u64);
impl_handle!(VkCuModuleNVX: VK_OBJECT_TYPE_CU_MODULE_NVX; SubHandle = VkDevice);

/// `VkCuModuleTexturingModeCreateInfoNVX`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkCuModuleTexturingModeCreateInfoNVX {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub use64bitTexturing: VkBool32,
}
impl_default_zeroed_with_s_type!(VkCuModuleTexturingModeCreateInfoNVX : VK_STRUCTURE_TYPE_CU_MODULE_TEXTURING_MODE_CREATE_INFO_NVX);
impl_extends!(VkCuModuleTexturingModeCreateInfoNVX : VkCuModuleCreateInfoNVX);

from_into_transparent!(VkCubicFilterWeightsQCOM: i32);
/// `VkCubicFilterWeightsQCOM`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkCubicFilterWeightsQCOM(pub i32);

/// `0`  
pub const VK_CUBIC_FILTER_WEIGHTS_CATMULL_ROM_QCOM: VkCubicFilterWeightsQCOM = VkCubicFilterWeightsQCOM(0);
/// `1`  
pub const VK_CUBIC_FILTER_WEIGHTS_ZERO_TANGENT_CARDINAL_QCOM: VkCubicFilterWeightsQCOM = VkCubicFilterWeightsQCOM(1);
/// `2`  
pub const VK_CUBIC_FILTER_WEIGHTS_B_SPLINE_QCOM: VkCubicFilterWeightsQCOM = VkCubicFilterWeightsQCOM(2);
/// `3`  
pub const VK_CUBIC_FILTER_WEIGHTS_MITCHELL_NETRAVALI_QCOM: VkCubicFilterWeightsQCOM = VkCubicFilterWeightsQCOM(3);

impl_enum_display!(VkCubicFilterWeightsQCOM { VK_CUBIC_FILTER_WEIGHTS_CATMULL_ROM_QCOM, VK_CUBIC_FILTER_WEIGHTS_ZERO_TANGENT_CARDINAL_QCOM, VK_CUBIC_FILTER_WEIGHTS_B_SPLINE_QCOM, VK_CUBIC_FILTER_WEIGHTS_MITCHELL_NETRAVALI_QCOM });

/// `VkCudaFunctionCreateInfoNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkCudaFunctionCreateInfoNV {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub module: VkCudaModuleNV,
    pub pName: *const c_char,
}
impl_default_zeroed_with_s_type!(VkCudaFunctionCreateInfoNV : VK_STRUCTURE_TYPE_CUDA_FUNCTION_CREATE_INFO_NV);

/// `VkCudaFunctionNV` : `VkDevice`
#[repr(transparent)]
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkCudaFunctionNV(pub u64);
from_into_transparent!(VkCudaFunctionNV: u64);
impl_handle!(VkCudaFunctionNV: VK_OBJECT_TYPE_CUDA_FUNCTION_NV; SubHandle = VkDevice);

/// `VkCudaLaunchInfoNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkCudaLaunchInfoNV {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub function: VkCudaFunctionNV,
    pub gridDimX: uint32_t,
    pub gridDimY: uint32_t,
    pub gridDimZ: uint32_t,
    pub blockDimX: uint32_t,
    pub blockDimY: uint32_t,
    pub blockDimZ: uint32_t,
    pub sharedMemBytes: uint32_t,
    pub paramCount: size_t,
    pub pParams: *const void,
    pub extraCount: size_t,
    pub pExtras: *const void,
}
impl_default_zeroed_with_s_type!(VkCudaLaunchInfoNV : VK_STRUCTURE_TYPE_CUDA_LAUNCH_INFO_NV);

/// `VkCudaModuleCreateInfoNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkCudaModuleCreateInfoNV {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub dataSize: size_t,
    pub pData: *const void,
}
impl_default_zeroed_with_s_type!(VkCudaModuleCreateInfoNV : VK_STRUCTURE_TYPE_CUDA_MODULE_CREATE_INFO_NV);

/// `VkCudaModuleNV` : `VkDevice`
#[repr(transparent)]
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkCudaModuleNV(pub u64);
from_into_transparent!(VkCudaModuleNV: u64);
impl_handle!(VkCudaModuleNV: VK_OBJECT_TYPE_CUDA_MODULE_NV; SubHandle = VkDevice);

flags!(VkCullModeFlags);
from_into_transparent!(VkCullModeFlags: i32);
/// `VkCullModeFlags`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkCullModeFlags(pub i32);

/// `0`  
pub const VK_CULL_MODE_NONE: VkCullModeFlags = VkCullModeFlags(0);
/// `1 << 0`  
pub const VK_CULL_MODE_FRONT_BIT: VkCullModeFlags = VkCullModeFlags(1 << 0);
/// `1 << 1`  
pub const VK_CULL_MODE_BACK_BIT: VkCullModeFlags = VkCullModeFlags(1 << 1);
/// `0x00000003`  
pub const VK_CULL_MODE_FRONT_AND_BACK: VkCullModeFlags = VkCullModeFlags(0x00000003);

impl_flags_display!(VkCullModeFlags { VK_CULL_MODE_NONE, VK_CULL_MODE_FRONT_BIT, VK_CULL_MODE_BACK_BIT, VK_CULL_MODE_FRONT_AND_BACK });

/// `VkCustomResolveCreateInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkCustomResolveCreateInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub customResolve: VkBool32,
    pub colorAttachmentCount: uint32_t,
    pub pColorAttachmentFormats: *const VkFormat,
    pub depthAttachmentFormat: VkFormat,
    pub stencilAttachmentFormat: VkFormat,
}
impl_default_zeroed_with_s_type!(VkCustomResolveCreateInfoEXT : VK_STRUCTURE_TYPE_CUSTOM_RESOLVE_CREATE_INFO_EXT);
impl_extends!(VkCustomResolveCreateInfoEXT : VkGraphicsPipelineCreateInfo, VkCommandBufferInheritanceInfo, VkShaderCreateInfoEXT);

/// `VkD3D12FenceSubmitInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkD3D12FenceSubmitInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub waitSemaphoreValuesCount: uint32_t,
    pub pWaitSemaphoreValues: *const uint64_t,
    pub signalSemaphoreValuesCount: uint32_t,
    pub pSignalSemaphoreValues: *const uint64_t,
}
impl_default_zeroed_with_s_type!(VkD3D12FenceSubmitInfoKHR : VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR);
impl_extends!(VkD3D12FenceSubmitInfoKHR : VkSubmitInfo);

from_into_transparent!(VkDataGraphModelCacheTypeQCOM: i32);
/// `VkDataGraphModelCacheTypeQCOM`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkDataGraphModelCacheTypeQCOM(pub i32);

/// `0`  
pub const VK_DATA_GRAPH_MODEL_CACHE_TYPE_GENERIC_BINARY_QCOM: VkDataGraphModelCacheTypeQCOM = VkDataGraphModelCacheTypeQCOM(0);

impl_enum_display!(VkDataGraphModelCacheTypeQCOM { VK_DATA_GRAPH_MODEL_CACHE_TYPE_GENERIC_BINARY_QCOM });

/// `VkDataGraphPipelineBuiltinModelCreateInfoQCOM`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDataGraphPipelineBuiltinModelCreateInfoQCOM {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub pOperation: *const VkPhysicalDeviceDataGraphOperationSupportARM,
}
impl_default_zeroed_with_s_type!(VkDataGraphPipelineBuiltinModelCreateInfoQCOM : VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_BUILTIN_MODEL_CREATE_INFO_QCOM);
impl_extends!(VkDataGraphPipelineBuiltinModelCreateInfoQCOM : VkDataGraphPipelineCreateInfoARM);

/// `VkDataGraphPipelineCompilerControlCreateInfoARM`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDataGraphPipelineCompilerControlCreateInfoARM {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub pVendorOptions: *const c_char,
}
impl_default_zeroed_with_s_type!(VkDataGraphPipelineCompilerControlCreateInfoARM : VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_COMPILER_CONTROL_CREATE_INFO_ARM);
impl_extends!(VkDataGraphPipelineCompilerControlCreateInfoARM : VkDataGraphPipelineCreateInfoARM);

/// `VkDataGraphPipelineConstantARM`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDataGraphPipelineConstantARM {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub id: uint32_t,
    pub pConstantData: *const void,
}
impl_default_zeroed_with_s_type!(VkDataGraphPipelineConstantARM : VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CONSTANT_ARM);

/// `VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub dimension: uint32_t,
    pub zeroCount: uint32_t,
    pub groupSize: uint32_t,
}
impl_default_zeroed_with_s_type!(VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM : VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CONSTANT_TENSOR_SEMI_STRUCTURED_SPARSITY_INFO_ARM);
impl_extends!(VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM : VkDataGraphPipelineConstantARM);

/// `VkDataGraphPipelineCreateInfoARM`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDataGraphPipelineCreateInfoARM {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub flags: VkPipelineCreateFlags2KHR,
    pub layout: VkPipelineLayout,
    pub resourceInfoCount: uint32_t,
    pub pResourceInfos: *const VkDataGraphPipelineResourceInfoARM,
}
impl_default_zeroed_with_s_type!(VkDataGraphPipelineCreateInfoARM : VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CREATE_INFO_ARM);

flags!(VkDataGraphPipelineDispatchFlagsARM);
from_into_transparent!(VkDataGraphPipelineDispatchFlagsARM: i64);
/// `VkDataGraphPipelineDispatchFlagsARM`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkDataGraphPipelineDispatchFlagsARM(pub i64);

impl_flags_display!(VkDataGraphPipelineDispatchFlagsARM {  });

/// `VkDataGraphPipelineDispatchInfoARM`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDataGraphPipelineDispatchInfoARM {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub flags: VkDataGraphPipelineDispatchFlagsARM,
}
impl_default_zeroed_with_s_type!(VkDataGraphPipelineDispatchInfoARM : VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_DISPATCH_INFO_ARM);

/// `VkDataGraphPipelineIdentifierCreateInfoARM`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDataGraphPipelineIdentifierCreateInfoARM {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub identifierSize: uint32_t,
    pub pIdentifier: *const uint8_t,
}
impl_default_zeroed_with_s_type!(VkDataGraphPipelineIdentifierCreateInfoARM : VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_IDENTIFIER_CREATE_INFO_ARM);
impl_extends!(VkDataGraphPipelineIdentifierCreateInfoARM : VkDataGraphPipelineCreateInfoARM);

/// `VkDataGraphPipelineInfoARM`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDataGraphPipelineInfoARM {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub dataGraphPipeline: VkPipeline,
}
impl_default_zeroed_with_s_type!(VkDataGraphPipelineInfoARM : VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_INFO_ARM);

from_into_transparent!(VkDataGraphPipelinePropertyARM: i32);
/// `VkDataGraphPipelinePropertyARM`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkDataGraphPipelinePropertyARM(pub i32);

/// `0`  
pub const VK_DATA_GRAPH_PIPELINE_PROPERTY_CREATION_LOG_ARM: VkDataGraphPipelinePropertyARM = VkDataGraphPipelinePropertyARM(0);
/// `1`  
pub const VK_DATA_GRAPH_PIPELINE_PROPERTY_IDENTIFIER_ARM: VkDataGraphPipelinePropertyARM = VkDataGraphPipelinePropertyARM(1);

impl_enum_display!(VkDataGraphPipelinePropertyARM { VK_DATA_GRAPH_PIPELINE_PROPERTY_CREATION_LOG_ARM, VK_DATA_GRAPH_PIPELINE_PROPERTY_IDENTIFIER_ARM });

/// `VkDataGraphPipelinePropertyQueryResultARM`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDataGraphPipelinePropertyQueryResultARM {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub property: VkDataGraphPipelinePropertyARM,
    pub isText: VkBool32,
    pub dataSize: size_t,
    pub pData: *mut void,
}
impl_default_zeroed_with_s_type!(VkDataGraphPipelinePropertyQueryResultARM : VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_PROPERTY_QUERY_RESULT_ARM);

/// `VkDataGraphPipelineResourceInfoARM`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDataGraphPipelineResourceInfoARM {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub descriptorSet: uint32_t,
    pub binding: uint32_t,
    pub arrayElement: uint32_t,
}
impl_default_zeroed_with_s_type!(VkDataGraphPipelineResourceInfoARM : VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_RESOURCE_INFO_ARM);

/// `VkDataGraphPipelineSessionARM` : `VkDevice`
#[repr(transparent)]
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkDataGraphPipelineSessionARM(pub u64);
from_into_transparent!(VkDataGraphPipelineSessionARM: u64);
impl_handle!(VkDataGraphPipelineSessionARM: VK_OBJECT_TYPE_DATA_GRAPH_PIPELINE_SESSION_ARM; SubHandle = VkDevice);

from_into_transparent!(VkDataGraphPipelineSessionBindPointARM: i32);
/// `VkDataGraphPipelineSessionBindPointARM`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkDataGraphPipelineSessionBindPointARM(pub i32);

/// `0`  
pub const VK_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_TRANSIENT_ARM: VkDataGraphPipelineSessionBindPointARM = VkDataGraphPipelineSessionBindPointARM(0);

impl_enum_display!(VkDataGraphPipelineSessionBindPointARM { VK_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_TRANSIENT_ARM });

/// `VkDataGraphPipelineSessionBindPointRequirementARM`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDataGraphPipelineSessionBindPointRequirementARM {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub bindPoint: VkDataGraphPipelineSessionBindPointARM,
    pub bindPointType: VkDataGraphPipelineSessionBindPointTypeARM,
    pub numObjects: uint32_t,
}
impl_default_zeroed_with_s_type!(VkDataGraphPipelineSessionBindPointRequirementARM : VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_REQUIREMENT_ARM);

/// `VkDataGraphPipelineSessionBindPointRequirementsInfoARM`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDataGraphPipelineSessionBindPointRequirementsInfoARM {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub session: VkDataGraphPipelineSessionARM,
}
impl_default_zeroed_with_s_type!(VkDataGraphPipelineSessionBindPointRequirementsInfoARM : VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_REQUIREMENTS_INFO_ARM);

from_into_transparent!(VkDataGraphPipelineSessionBindPointTypeARM: i32);
/// `VkDataGraphPipelineSessionBindPointTypeARM`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkDataGraphPipelineSessionBindPointTypeARM(pub i32);

/// `0`  
pub const VK_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_TYPE_MEMORY_ARM: VkDataGraphPipelineSessionBindPointTypeARM = VkDataGraphPipelineSessionBindPointTypeARM(0);

impl_enum_display!(VkDataGraphPipelineSessionBindPointTypeARM { VK_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_TYPE_MEMORY_ARM });

flags!(VkDataGraphPipelineSessionCreateFlagsARM);
from_into_transparent!(VkDataGraphPipelineSessionCreateFlagsARM: i64);
/// `VkDataGraphPipelineSessionCreateFlagsARM`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkDataGraphPipelineSessionCreateFlagsARM(pub i64);

/// `1 << 0`  
pub const VK_DATA_GRAPH_PIPELINE_SESSION_CREATE_PROTECTED_BIT_ARM: VkDataGraphPipelineSessionCreateFlagsARM = VkDataGraphPipelineSessionCreateFlagsARM(1 << 0);

impl_flags_display!(VkDataGraphPipelineSessionCreateFlagsARM { VK_DATA_GRAPH_PIPELINE_SESSION_CREATE_PROTECTED_BIT_ARM });

/// `VkDataGraphPipelineSessionCreateInfoARM`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDataGraphPipelineSessionCreateInfoARM {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub flags: VkDataGraphPipelineSessionCreateFlagsARM,
    pub dataGraphPipeline: VkPipeline,
}
impl_default_zeroed_with_s_type!(VkDataGraphPipelineSessionCreateInfoARM : VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_CREATE_INFO_ARM);

/// `VkDataGraphPipelineSessionMemoryRequirementsInfoARM`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDataGraphPipelineSessionMemoryRequirementsInfoARM {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub session: VkDataGraphPipelineSessionARM,
    pub bindPoint: VkDataGraphPipelineSessionBindPointARM,
    pub objectIndex: uint32_t,
}
impl_default_zeroed_with_s_type!(VkDataGraphPipelineSessionMemoryRequirementsInfoARM : VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_MEMORY_REQUIREMENTS_INFO_ARM);

/// `VkDataGraphPipelineShaderModuleCreateInfoARM`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDataGraphPipelineShaderModuleCreateInfoARM {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub module: VkShaderModule,
    pub pName: *const c_char,
    pub pSpecializationInfo: *const VkSpecializationInfo,
    pub constantCount: uint32_t,
    pub pConstants: *const VkDataGraphPipelineConstantARM,
}
impl_default_zeroed_with_s_type!(VkDataGraphPipelineShaderModuleCreateInfoARM : VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SHADER_MODULE_CREATE_INFO_ARM);
impl_extends!(VkDataGraphPipelineShaderModuleCreateInfoARM : VkDataGraphPipelineCreateInfoARM);

/// `VkDataGraphProcessingEngineCreateInfoARM`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDataGraphProcessingEngineCreateInfoARM {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub processingEngineCount: uint32_t,
    pub pProcessingEngines: *mut VkPhysicalDeviceDataGraphProcessingEngineARM,
}
impl_default_zeroed_with_s_type!(VkDataGraphProcessingEngineCreateInfoARM : VK_STRUCTURE_TYPE_DATA_GRAPH_PROCESSING_ENGINE_CREATE_INFO_ARM);
impl_extends!(VkDataGraphProcessingEngineCreateInfoARM : VkDataGraphPipelineCreateInfoARM, VkDescriptorPoolCreateInfo, VkCommandPoolCreateInfo);

/// `VkDebugMarkerMarkerInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDebugMarkerMarkerInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    /// Name of the debug marker
    pub pMarkerName: *const c_char,
    /// Optional color for debug marker
    pub color: [float; 4 as usize],
}
impl_default_zeroed_with_s_type!(VkDebugMarkerMarkerInfoEXT : VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT);

/// `VkDebugMarkerObjectNameInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDebugMarkerObjectNameInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    /// The type of the object
    pub objectType: VkDebugReportObjectTypeEXT,
    /// The handle of the object, cast to uint64_t
    pub object: uint64_t,
    /// Name to apply to the object
    pub pObjectName: *const c_char,
}
impl_default_zeroed_with_s_type!(VkDebugMarkerObjectNameInfoEXT : VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT);

/// `VkDebugMarkerObjectTagInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDebugMarkerObjectTagInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    /// The type of the object
    pub objectType: VkDebugReportObjectTypeEXT,
    /// The handle of the object, cast to uint64_t
    pub object: uint64_t,
    /// The name of the tag to set on the object
    pub tagName: uint64_t,
    /// The length in bytes of the tag data
    pub tagSize: size_t,
    /// Tag data to attach to the object
    pub pTag: *const void,
}
impl_default_zeroed_with_s_type!(VkDebugMarkerObjectTagInfoEXT : VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT);

/// `VkDebugReportCallbackCreateInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDebugReportCallbackCreateInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    /// Indicates which events call this callback
    pub flags: VkDebugReportFlagsEXT,
    /// Function pointer of a callback function
    pub pfnCallback: PFN_vkDebugReportCallbackEXT,
    /// Data provided to callback function
    pub pUserData: *mut void,
}
impl_default_zeroed_with_s_type!(VkDebugReportCallbackCreateInfoEXT : VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT);
impl_extends!(VkDebugReportCallbackCreateInfoEXT : VkInstanceCreateInfo);

/// `VkDebugReportCallbackEXT` : `VkInstance`
#[repr(transparent)]
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkDebugReportCallbackEXT(pub u64);
from_into_transparent!(VkDebugReportCallbackEXT: u64);
impl_handle!(VkDebugReportCallbackEXT: VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT; SubHandle = VkInstance);

flags!(VkDebugReportFlagsEXT);
from_into_transparent!(VkDebugReportFlagsEXT: i32);
/// `VkDebugReportFlagsEXT`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkDebugReportFlagsEXT(pub i32);

/// `1 << 0`  
pub const VK_DEBUG_REPORT_INFORMATION_BIT_EXT: VkDebugReportFlagsEXT = VkDebugReportFlagsEXT(1 << 0);
/// `1 << 1`  
pub const VK_DEBUG_REPORT_WARNING_BIT_EXT: VkDebugReportFlagsEXT = VkDebugReportFlagsEXT(1 << 1);
/// `1 << 2`  
pub const VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT: VkDebugReportFlagsEXT = VkDebugReportFlagsEXT(1 << 2);
/// `1 << 3`  
pub const VK_DEBUG_REPORT_ERROR_BIT_EXT: VkDebugReportFlagsEXT = VkDebugReportFlagsEXT(1 << 3);
/// `1 << 4`  
pub const VK_DEBUG_REPORT_DEBUG_BIT_EXT: VkDebugReportFlagsEXT = VkDebugReportFlagsEXT(1 << 4);

impl_flags_display!(VkDebugReportFlagsEXT { VK_DEBUG_REPORT_INFORMATION_BIT_EXT, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_DEBUG_BIT_EXT });

from_into_transparent!(VkDebugReportObjectTypeEXT: i32);
/// `VkDebugReportObjectTypeEXT`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkDebugReportObjectTypeEXT(pub i32);

/// `0`  
pub const VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT: VkDebugReportObjectTypeEXT = VkDebugReportObjectTypeEXT(0);
/// `1`  
pub const VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT: VkDebugReportObjectTypeEXT = VkDebugReportObjectTypeEXT(1);
/// `2`  
pub const VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT: VkDebugReportObjectTypeEXT = VkDebugReportObjectTypeEXT(2);
/// `3`  
pub const VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT: VkDebugReportObjectTypeEXT = VkDebugReportObjectTypeEXT(3);
/// `4`  
pub const VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT: VkDebugReportObjectTypeEXT = VkDebugReportObjectTypeEXT(4);
/// `5`  
pub const VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT: VkDebugReportObjectTypeEXT = VkDebugReportObjectTypeEXT(5);
/// `6`  
pub const VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT: VkDebugReportObjectTypeEXT = VkDebugReportObjectTypeEXT(6);
/// `7`  
pub const VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT: VkDebugReportObjectTypeEXT = VkDebugReportObjectTypeEXT(7);
/// `8`  
pub const VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT: VkDebugReportObjectTypeEXT = VkDebugReportObjectTypeEXT(8);
/// `9`  
pub const VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT: VkDebugReportObjectTypeEXT = VkDebugReportObjectTypeEXT(9);
/// `10`  
pub const VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT: VkDebugReportObjectTypeEXT = VkDebugReportObjectTypeEXT(10);
/// `11`  
pub const VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT: VkDebugReportObjectTypeEXT = VkDebugReportObjectTypeEXT(11);
/// `12`  
pub const VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT: VkDebugReportObjectTypeEXT = VkDebugReportObjectTypeEXT(12);
/// `13`  
pub const VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT: VkDebugReportObjectTypeEXT = VkDebugReportObjectTypeEXT(13);
/// `14`  
pub const VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT: VkDebugReportObjectTypeEXT = VkDebugReportObjectTypeEXT(14);
/// `15`  
pub const VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT: VkDebugReportObjectTypeEXT = VkDebugReportObjectTypeEXT(15);
/// `16`  
pub const VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT: VkDebugReportObjectTypeEXT = VkDebugReportObjectTypeEXT(16);
/// `17`  
pub const VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT: VkDebugReportObjectTypeEXT = VkDebugReportObjectTypeEXT(17);
/// `18`  
pub const VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT: VkDebugReportObjectTypeEXT = VkDebugReportObjectTypeEXT(18);
/// `19`  
pub const VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT: VkDebugReportObjectTypeEXT = VkDebugReportObjectTypeEXT(19);
/// `20`  
pub const VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT: VkDebugReportObjectTypeEXT = VkDebugReportObjectTypeEXT(20);
/// `21`  
pub const VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT: VkDebugReportObjectTypeEXT = VkDebugReportObjectTypeEXT(21);
/// `22`  
pub const VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT: VkDebugReportObjectTypeEXT = VkDebugReportObjectTypeEXT(22);
/// `23`  
pub const VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT: VkDebugReportObjectTypeEXT = VkDebugReportObjectTypeEXT(23);
/// `24`  
pub const VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT: VkDebugReportObjectTypeEXT = VkDebugReportObjectTypeEXT(24);
/// `25`  
pub const VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT: VkDebugReportObjectTypeEXT = VkDebugReportObjectTypeEXT(25);
/// `26`  
pub const VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT: VkDebugReportObjectTypeEXT = VkDebugReportObjectTypeEXT(26);
/// `27`  
pub const VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT: VkDebugReportObjectTypeEXT = VkDebugReportObjectTypeEXT(27);
/// `28`  
pub const VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT: VkDebugReportObjectTypeEXT = VkDebugReportObjectTypeEXT(28);
/// `VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT`  
pub const VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT: VkDebugReportObjectTypeEXT = VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT;
/// `29`  
pub const VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT: VkDebugReportObjectTypeEXT = VkDebugReportObjectTypeEXT(29);
/// `30`  
pub const VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT: VkDebugReportObjectTypeEXT = VkDebugReportObjectTypeEXT(30);
/// `33`  
pub const VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT: VkDebugReportObjectTypeEXT = VkDebugReportObjectTypeEXT(33);
/// `VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT`  
pub const VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT: VkDebugReportObjectTypeEXT = VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT;
/// `1000156000`  
pub const VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT: VkDebugReportObjectTypeEXT = VkDebugReportObjectTypeEXT(1000156000);
/// `1000085000`  
pub const VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT: VkDebugReportObjectTypeEXT = VkDebugReportObjectTypeEXT(1000085000);
/// `1000029000`  
pub const VK_DEBUG_REPORT_OBJECT_TYPE_CU_MODULE_NVX_EXT: VkDebugReportObjectTypeEXT = VkDebugReportObjectTypeEXT(1000029000);
/// `1000029001`  
pub const VK_DEBUG_REPORT_OBJECT_TYPE_CU_FUNCTION_NVX_EXT: VkDebugReportObjectTypeEXT = VkDebugReportObjectTypeEXT(1000029001);
/// `VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT`  
pub const VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR_EXT: VkDebugReportObjectTypeEXT = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT;
/// `1000150000`  
pub const VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR_EXT: VkDebugReportObjectTypeEXT = VkDebugReportObjectTypeEXT(1000150000);
/// `VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT`  
pub const VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR_EXT: VkDebugReportObjectTypeEXT = VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT;
/// `1000165000`  
pub const VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV_EXT: VkDebugReportObjectTypeEXT = VkDebugReportObjectTypeEXT(1000165000);
/// `1000307000`  
pub const VK_DEBUG_REPORT_OBJECT_TYPE_CUDA_MODULE_NV_EXT: VkDebugReportObjectTypeEXT = VkDebugReportObjectTypeEXT(1000307000);
/// `1000307001`  
pub const VK_DEBUG_REPORT_OBJECT_TYPE_CUDA_FUNCTION_NV_EXT: VkDebugReportObjectTypeEXT = VkDebugReportObjectTypeEXT(1000307001);
/// `1000366000`  
pub const VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIA_EXT: VkDebugReportObjectTypeEXT = VkDebugReportObjectTypeEXT(1000366000);

impl_enum_display!(VkDebugReportObjectTypeEXT { VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_CU_MODULE_NVX_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_CU_FUNCTION_NVX_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_CUDA_MODULE_NV_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_CUDA_FUNCTION_NV_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIA_EXT });

/// `VkDebugUtilsLabelEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDebugUtilsLabelEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub pLabelName: *const c_char,
    pub color: [float; 4 as usize],
}
impl_default_zeroed_with_s_type!(VkDebugUtilsLabelEXT : VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT);

flags!(VkDebugUtilsMessageSeverityFlagsEXT);
from_into_transparent!(VkDebugUtilsMessageSeverityFlagsEXT: i32);
/// `VkDebugUtilsMessageSeverityFlagsEXT`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkDebugUtilsMessageSeverityFlagsEXT(pub i32);

/// `1 << 0`  
pub const VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT: VkDebugUtilsMessageSeverityFlagsEXT = VkDebugUtilsMessageSeverityFlagsEXT(1 << 0);
/// `1 << 4`  
pub const VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT: VkDebugUtilsMessageSeverityFlagsEXT = VkDebugUtilsMessageSeverityFlagsEXT(1 << 4);
/// `1 << 8`  
pub const VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT: VkDebugUtilsMessageSeverityFlagsEXT = VkDebugUtilsMessageSeverityFlagsEXT(1 << 8);
/// `1 << 12`  
pub const VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT: VkDebugUtilsMessageSeverityFlagsEXT = VkDebugUtilsMessageSeverityFlagsEXT(1 << 12);

impl_flags_display!(VkDebugUtilsMessageSeverityFlagsEXT { VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT, VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT, VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT, VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT });

flags!(VkDebugUtilsMessageTypeFlagsEXT);
from_into_transparent!(VkDebugUtilsMessageTypeFlagsEXT: i32);
/// `VkDebugUtilsMessageTypeFlagsEXT`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkDebugUtilsMessageTypeFlagsEXT(pub i32);

/// `1 << 0`  
pub const VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT: VkDebugUtilsMessageTypeFlagsEXT = VkDebugUtilsMessageTypeFlagsEXT(1 << 0);
/// `1 << 1`  
pub const VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT: VkDebugUtilsMessageTypeFlagsEXT = VkDebugUtilsMessageTypeFlagsEXT(1 << 1);
/// `1 << 2`  
pub const VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT: VkDebugUtilsMessageTypeFlagsEXT = VkDebugUtilsMessageTypeFlagsEXT(1 << 2);
/// `1 << 3`  
pub const VK_DEBUG_UTILS_MESSAGE_TYPE_DEVICE_ADDRESS_BINDING_BIT_EXT: VkDebugUtilsMessageTypeFlagsEXT = VkDebugUtilsMessageTypeFlagsEXT(1 << 3);

impl_flags_display!(VkDebugUtilsMessageTypeFlagsEXT { VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT, VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT, VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT, VK_DEBUG_UTILS_MESSAGE_TYPE_DEVICE_ADDRESS_BINDING_BIT_EXT });

/// `VkDebugUtilsMessengerCallbackDataEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDebugUtilsMessengerCallbackDataEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub flags: VkDebugUtilsMessengerCallbackDataFlagsEXT,
    pub pMessageIdName: *const c_char,
    pub messageIdNumber: int32_t,
    pub pMessage: *const c_char,
    pub queueLabelCount: uint32_t,
    pub pQueueLabels: *const VkDebugUtilsLabelEXT,
    pub cmdBufLabelCount: uint32_t,
    pub pCmdBufLabels: *const VkDebugUtilsLabelEXT,
    pub objectCount: uint32_t,
    pub pObjects: *const VkDebugUtilsObjectNameInfoEXT,
}
impl_default_zeroed_with_s_type!(VkDebugUtilsMessengerCallbackDataEXT : VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT);

flags!(VkDebugUtilsMessengerCallbackDataFlagsEXT);
from_into_transparent!(VkDebugUtilsMessengerCallbackDataFlagsEXT: i32);
/// `VkDebugUtilsMessengerCallbackDataFlagsEXT`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkDebugUtilsMessengerCallbackDataFlagsEXT(pub i32);

impl_flags_display!(VkDebugUtilsMessengerCallbackDataFlagsEXT {  });

flags!(VkDebugUtilsMessengerCreateFlagsEXT);
from_into_transparent!(VkDebugUtilsMessengerCreateFlagsEXT: i32);
/// `VkDebugUtilsMessengerCreateFlagsEXT`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkDebugUtilsMessengerCreateFlagsEXT(pub i32);

impl_flags_display!(VkDebugUtilsMessengerCreateFlagsEXT {  });

/// `VkDebugUtilsMessengerCreateInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDebugUtilsMessengerCreateInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub flags: VkDebugUtilsMessengerCreateFlagsEXT,
    pub messageSeverity: VkDebugUtilsMessageSeverityFlagsEXT,
    pub messageType: VkDebugUtilsMessageTypeFlagsEXT,
    pub pfnUserCallback: PFN_vkDebugUtilsMessengerCallbackEXT,
    pub pUserData: *mut void,
}
impl_default_zeroed_with_s_type!(VkDebugUtilsMessengerCreateInfoEXT : VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT);
impl_extends!(VkDebugUtilsMessengerCreateInfoEXT : VkInstanceCreateInfo);

/// `VkDebugUtilsMessengerEXT` : `VkInstance`
#[repr(transparent)]
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkDebugUtilsMessengerEXT(pub u64);
from_into_transparent!(VkDebugUtilsMessengerEXT: u64);
impl_handle!(VkDebugUtilsMessengerEXT: VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT; SubHandle = VkInstance);

/// `VkDebugUtilsObjectNameInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDebugUtilsObjectNameInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub objectType: VkObjectType,
    pub objectHandle: uint64_t,
    pub pObjectName: *const c_char,
}
impl_default_zeroed_with_s_type!(VkDebugUtilsObjectNameInfoEXT : VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT);
impl_extends!(VkDebugUtilsObjectNameInfoEXT : VkPipelineShaderStageCreateInfo, VkResourceDescriptorInfoEXT, VkSamplerCreateInfo);

/// `VkDebugUtilsObjectTagInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDebugUtilsObjectTagInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub objectType: VkObjectType,
    pub objectHandle: uint64_t,
    pub tagName: uint64_t,
    pub tagSize: size_t,
    pub pTag: *const void,
}
impl_default_zeroed_with_s_type!(VkDebugUtilsObjectTagInfoEXT : VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT);

/// `VkDecompressMemoryInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDecompressMemoryInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub decompressionMethod: VkMemoryDecompressionMethodFlagsEXT,
    pub regionCount: uint32_t,
    pub pRegions: *const VkDecompressMemoryRegionEXT,
}
impl_default_zeroed_with_s_type!(VkDecompressMemoryInfoEXT : VK_STRUCTURE_TYPE_DECOMPRESS_MEMORY_INFO_EXT);

/// `VkDecompressMemoryRegionEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDecompressMemoryRegionEXT {
    pub srcAddress: VkDeviceAddress,
    pub dstAddress: VkDeviceAddress,
    /// Specified in bytes
    pub compressedSize: VkDeviceSize,
    /// Specified in bytes
    pub decompressedSize: VkDeviceSize,
}
impl_default_zeroed!(VkDecompressMemoryRegionEXT);

/// `VkDecompressMemoryRegionNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDecompressMemoryRegionNV {
    pub srcAddress: VkDeviceAddress,
    pub dstAddress: VkDeviceAddress,
    /// Specified in bytes
    pub compressedSize: VkDeviceSize,
    /// Specified in bytes
    pub decompressedSize: VkDeviceSize,
    pub decompressionMethod: VkMemoryDecompressionMethodFlagsNV,
}
impl_default_zeroed!(VkDecompressMemoryRegionNV);

/// `VkDedicatedAllocationBufferCreateInfoNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDedicatedAllocationBufferCreateInfoNV {
    pub sType: VkStructureType,
    pub pNext: *const void,
    /// Whether this buffer uses a dedicated allocation
    pub dedicatedAllocation: VkBool32,
}
impl_default_zeroed_with_s_type!(VkDedicatedAllocationBufferCreateInfoNV : VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV);
impl_extends!(VkDedicatedAllocationBufferCreateInfoNV : VkBufferCreateInfo);

/// `VkDedicatedAllocationImageCreateInfoNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDedicatedAllocationImageCreateInfoNV {
    pub sType: VkStructureType,
    pub pNext: *const void,
    /// Whether this image uses a dedicated allocation
    pub dedicatedAllocation: VkBool32,
}
impl_default_zeroed_with_s_type!(VkDedicatedAllocationImageCreateInfoNV : VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV);
impl_extends!(VkDedicatedAllocationImageCreateInfoNV : VkImageCreateInfo);

/// `VkDedicatedAllocationMemoryAllocateInfoNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDedicatedAllocationMemoryAllocateInfoNV {
    pub sType: VkStructureType,
    pub pNext: *const void,
    /// Image that this allocation will be bound to
    pub image: VkImage,
    /// Buffer that this allocation will be bound to
    pub buffer: VkBuffer,
}
impl_default_zeroed_with_s_type!(VkDedicatedAllocationMemoryAllocateInfoNV : VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV);
impl_extends!(VkDedicatedAllocationMemoryAllocateInfoNV : VkMemoryAllocateInfo);

from_into_transparent!(VkDefaultVertexAttributeValueKHR: i32);
/// `VkDefaultVertexAttributeValueKHR`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkDefaultVertexAttributeValueKHR(pub i32);

/// `0`  
pub const VK_DEFAULT_VERTEX_ATTRIBUTE_VALUE_ZERO_ZERO_ZERO_ZERO_KHR: VkDefaultVertexAttributeValueKHR = VkDefaultVertexAttributeValueKHR(0);
/// `1`  
pub const VK_DEFAULT_VERTEX_ATTRIBUTE_VALUE_ZERO_ZERO_ZERO_ONE_KHR: VkDefaultVertexAttributeValueKHR = VkDefaultVertexAttributeValueKHR(1);

impl_enum_display!(VkDefaultVertexAttributeValueKHR { VK_DEFAULT_VERTEX_ATTRIBUTE_VALUE_ZERO_ZERO_ZERO_ZERO_KHR, VK_DEFAULT_VERTEX_ATTRIBUTE_VALUE_ZERO_ZERO_ZERO_ONE_KHR });

/// `VkDeferredOperationKHR` : `VkDevice`
#[repr(transparent)]
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkDeferredOperationKHR(pub u64);
from_into_transparent!(VkDeferredOperationKHR: u64);
impl_handle!(VkDeferredOperationKHR: VK_OBJECT_TYPE_DEFERRED_OPERATION_KHR; SubHandle = VkDevice);

flags!(VkDependencyFlags);
from_into_transparent!(VkDependencyFlags: i32);
/// `VkDependencyFlags`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkDependencyFlags(pub i32);

/// `1 << 0`  
/// 
/// Dependency is per pixel region 
pub const VK_DEPENDENCY_BY_REGION_BIT: VkDependencyFlags = VkDependencyFlags(1 << 0);
/// `1 << 2`  
/// 
/// Dependency is across devices
pub const VK_DEPENDENCY_DEVICE_GROUP_BIT: VkDependencyFlags = VkDependencyFlags(1 << 2);
/// `1 << 1`  
pub const VK_DEPENDENCY_VIEW_LOCAL_BIT: VkDependencyFlags = VkDependencyFlags(1 << 1);
/// `VK_DEPENDENCY_VIEW_LOCAL_BIT`  
pub const VK_DEPENDENCY_VIEW_LOCAL_BIT_KHR: VkDependencyFlags = VK_DEPENDENCY_VIEW_LOCAL_BIT;
/// `VK_DEPENDENCY_DEVICE_GROUP_BIT`  
pub const VK_DEPENDENCY_DEVICE_GROUP_BIT_KHR: VkDependencyFlags = VK_DEPENDENCY_DEVICE_GROUP_BIT;
/// `1 << 3`  
/// 
/// Dependency may be a feedback loop
pub const VK_DEPENDENCY_FEEDBACK_LOOP_BIT_EXT: VkDependencyFlags = VkDependencyFlags(1 << 3);
/// `1 << 5`  
pub const VK_DEPENDENCY_QUEUE_FAMILY_OWNERSHIP_TRANSFER_USE_ALL_STAGES_BIT_KHR: VkDependencyFlags = VkDependencyFlags(1 << 5);
/// `1 << 6`  
pub const VK_DEPENDENCY_ASYMMETRIC_EVENT_BIT_KHR: VkDependencyFlags = VkDependencyFlags(1 << 6);
/// `1 << 4`  
pub const VK_DEPENDENCY_EXTENSION_586_BIT_IMG: VkDependencyFlags = VkDependencyFlags(1 << 4);

impl_flags_display!(VkDependencyFlags { VK_DEPENDENCY_BY_REGION_BIT, VK_DEPENDENCY_DEVICE_GROUP_BIT, VK_DEPENDENCY_VIEW_LOCAL_BIT, VK_DEPENDENCY_VIEW_LOCAL_BIT_KHR, VK_DEPENDENCY_DEVICE_GROUP_BIT_KHR, VK_DEPENDENCY_FEEDBACK_LOOP_BIT_EXT, VK_DEPENDENCY_QUEUE_FAMILY_OWNERSHIP_TRANSFER_USE_ALL_STAGES_BIT_KHR, VK_DEPENDENCY_ASYMMETRIC_EVENT_BIT_KHR, VK_DEPENDENCY_EXTENSION_586_BIT_IMG });

/// `VkDependencyInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDependencyInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub dependencyFlags: VkDependencyFlags,
    pub memoryBarrierCount: uint32_t,
    pub pMemoryBarriers: *const VkMemoryBarrier2,
    pub bufferMemoryBarrierCount: uint32_t,
    pub pBufferMemoryBarriers: *const VkBufferMemoryBarrier2,
    pub imageMemoryBarrierCount: uint32_t,
    pub pImageMemoryBarriers: *const VkImageMemoryBarrier2,
}
impl_default_zeroed_with_s_type!(VkDependencyInfo : VK_STRUCTURE_TYPE_DEPENDENCY_INFO);

/// `VkDependencyInfo`
pub type VkDependencyInfoKHR = VkDependencyInfo;

/// `VkDepthBiasInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDepthBiasInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub depthBiasConstantFactor: float,
    pub depthBiasClamp: float,
    pub depthBiasSlopeFactor: float,
}
impl_default_zeroed_with_s_type!(VkDepthBiasInfoEXT : VK_STRUCTURE_TYPE_DEPTH_BIAS_INFO_EXT);

from_into_transparent!(VkDepthBiasRepresentationEXT: i32);
/// `VkDepthBiasRepresentationEXT`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkDepthBiasRepresentationEXT(pub i32);

/// `0`  
pub const VK_DEPTH_BIAS_REPRESENTATION_LEAST_REPRESENTABLE_VALUE_FORMAT_EXT: VkDepthBiasRepresentationEXT = VkDepthBiasRepresentationEXT(0);
/// `1`  
pub const VK_DEPTH_BIAS_REPRESENTATION_LEAST_REPRESENTABLE_VALUE_FORCE_UNORM_EXT: VkDepthBiasRepresentationEXT = VkDepthBiasRepresentationEXT(1);
/// `2`  
pub const VK_DEPTH_BIAS_REPRESENTATION_FLOAT_EXT: VkDepthBiasRepresentationEXT = VkDepthBiasRepresentationEXT(2);

impl_enum_display!(VkDepthBiasRepresentationEXT { VK_DEPTH_BIAS_REPRESENTATION_LEAST_REPRESENTABLE_VALUE_FORMAT_EXT, VK_DEPTH_BIAS_REPRESENTATION_LEAST_REPRESENTABLE_VALUE_FORCE_UNORM_EXT, VK_DEPTH_BIAS_REPRESENTATION_FLOAT_EXT });

/// `VkDepthBiasRepresentationInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDepthBiasRepresentationInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub depthBiasRepresentation: VkDepthBiasRepresentationEXT,
    pub depthBiasExact: VkBool32,
}
impl_default_zeroed_with_s_type!(VkDepthBiasRepresentationInfoEXT : VK_STRUCTURE_TYPE_DEPTH_BIAS_REPRESENTATION_INFO_EXT);
impl_extends!(VkDepthBiasRepresentationInfoEXT : VkDepthBiasInfoEXT, VkPipelineRasterizationStateCreateInfo);

from_into_transparent!(VkDepthClampModeEXT: i32);
/// `VkDepthClampModeEXT`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkDepthClampModeEXT(pub i32);

/// `0`  
pub const VK_DEPTH_CLAMP_MODE_VIEWPORT_RANGE_EXT: VkDepthClampModeEXT = VkDepthClampModeEXT(0);
/// `1`  
pub const VK_DEPTH_CLAMP_MODE_USER_DEFINED_RANGE_EXT: VkDepthClampModeEXT = VkDepthClampModeEXT(1);

impl_enum_display!(VkDepthClampModeEXT { VK_DEPTH_CLAMP_MODE_VIEWPORT_RANGE_EXT, VK_DEPTH_CLAMP_MODE_USER_DEFINED_RANGE_EXT });

/// `VkDepthClampRangeEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDepthClampRangeEXT {
    pub minDepthClamp: float,
    pub maxDepthClamp: float,
}
impl_default_zeroed!(VkDepthClampRangeEXT);

/// `VkDescriptorAddressInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDescriptorAddressInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub address: VkDeviceAddress,
    pub range: VkDeviceSize,
    pub format: VkFormat,
}
impl_default_zeroed_with_s_type!(VkDescriptorAddressInfoEXT : VK_STRUCTURE_TYPE_DESCRIPTOR_ADDRESS_INFO_EXT);

flags!(VkDescriptorBindingFlags);
from_into_transparent!(VkDescriptorBindingFlags: i32);
/// `VkDescriptorBindingFlags`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkDescriptorBindingFlags(pub i32);

/// `1 << 0`  
pub const VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT: VkDescriptorBindingFlags = VkDescriptorBindingFlags(1 << 0);
/// `1 << 1`  
pub const VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT: VkDescriptorBindingFlags = VkDescriptorBindingFlags(1 << 1);
/// `1 << 2`  
pub const VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT: VkDescriptorBindingFlags = VkDescriptorBindingFlags(1 << 2);
/// `1 << 3`  
pub const VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT: VkDescriptorBindingFlags = VkDescriptorBindingFlags(1 << 3);
/// `VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT`  
pub const VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT_EXT: VkDescriptorBindingFlags = VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT;
/// `VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT`  
pub const VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT_EXT: VkDescriptorBindingFlags = VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT;
/// `VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT`  
pub const VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT_EXT: VkDescriptorBindingFlags = VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT;
/// `VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT`  
pub const VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT_EXT: VkDescriptorBindingFlags = VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT;
/// `1 << 4`  
pub const VK_DESCRIPTOR_BINDING_RESERVED_4_BIT_QCOM: VkDescriptorBindingFlags = VkDescriptorBindingFlags(1 << 4);

impl_flags_display!(VkDescriptorBindingFlags { VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT, VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT, VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT, VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT, VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT_EXT, VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT_EXT, VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT_EXT, VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT_EXT, VK_DESCRIPTOR_BINDING_RESERVED_4_BIT_QCOM });

/// `VkDescriptorBindingFlags`
pub type VkDescriptorBindingFlagsEXT = VkDescriptorBindingFlags;

/// `VkDescriptorBufferBindingInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDescriptorBufferBindingInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub address: VkDeviceAddress,
    pub usage: VkBufferUsageFlags,
}
impl_default_zeroed_with_s_type!(VkDescriptorBufferBindingInfoEXT : VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_INFO_EXT);

/// `VkDescriptorBufferBindingPushDescriptorBufferHandleEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDescriptorBufferBindingPushDescriptorBufferHandleEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub buffer: VkBuffer,
}
impl_default_zeroed_with_s_type!(VkDescriptorBufferBindingPushDescriptorBufferHandleEXT : VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT);
impl_extends!(VkDescriptorBufferBindingPushDescriptorBufferHandleEXT : VkDescriptorBufferBindingInfoEXT);

/// `VkDescriptorBufferInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDescriptorBufferInfo {
    /// Buffer used for this descriptor slot.
    pub buffer: VkBuffer,
    /// Base offset from buffer start in bytes to update in the descriptor set.
    pub offset: VkDeviceSize,
    /// Size in bytes of the buffer resource for this descriptor update.
    pub range: VkDeviceSize,
}
impl_default_zeroed!(VkDescriptorBufferInfo);

/// `VkDescriptorDataEXT`
#[repr(C)]
#[derive(Clone, Copy)]
pub union VkDescriptorDataEXT {
    pub pSampler: *const VkSampler,
    pub pCombinedImageSampler: *const VkDescriptorImageInfo,
    pub pInputAttachmentImage: *const VkDescriptorImageInfo,
    pub pSampledImage: *const VkDescriptorImageInfo,
    pub pStorageImage: *const VkDescriptorImageInfo,
    pub pUniformTexelBuffer: *const VkDescriptorAddressInfoEXT,
    pub pStorageTexelBuffer: *const VkDescriptorAddressInfoEXT,
    pub pUniformBuffer: *const VkDescriptorAddressInfoEXT,
    pub pStorageBuffer: *const VkDescriptorAddressInfoEXT,
    pub accelerationStructure: VkDeviceAddress,
}
impl_debug_for_union!(VkDescriptorDataEXT);
impl_default_zeroed!(VkDescriptorDataEXT);

/// `VkDescriptorGetInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDescriptorGetInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub r#type: VkDescriptorType,
    pub data: VkDescriptorDataEXT,
}
impl_default_zeroed_with_s_type!(VkDescriptorGetInfoEXT : VK_STRUCTURE_TYPE_DESCRIPTOR_GET_INFO_EXT);

/// `VkDescriptorGetTensorInfoARM`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDescriptorGetTensorInfoARM {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub tensorView: VkTensorViewARM,
}
impl_default_zeroed_with_s_type!(VkDescriptorGetTensorInfoARM : VK_STRUCTURE_TYPE_DESCRIPTOR_GET_TENSOR_INFO_ARM);
impl_extends!(VkDescriptorGetTensorInfoARM : VkDescriptorGetInfoEXT);

/// `VkDescriptorImageInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDescriptorImageInfo {
    /// Sampler to write to the descriptor in case it is a SAMPLER or COMBINED_IMAGE_SAMPLER descriptor. Ignored otherwise.
    pub sampler: VkSampler,
    /// 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 imageView: VkImageView,
    /// Layout the image is expected to be in when accessed using this descriptor (only used if imageView is not VK_NULL_HANDLE).
    pub imageLayout: VkImageLayout,
}
impl_default_zeroed!(VkDescriptorImageInfo);

/// `VkDescriptorMappingSourceConstantOffsetEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDescriptorMappingSourceConstantOffsetEXT {
    pub heapOffset: uint32_t,
    pub heapArrayStride: uint32_t,
    pub pEmbeddedSampler: *const VkSamplerCreateInfo,
    pub samplerHeapOffset: uint32_t,
    pub samplerHeapArrayStride: uint32_t,
}
impl_default_zeroed!(VkDescriptorMappingSourceConstantOffsetEXT);

/// `VkDescriptorMappingSourceDataEXT`
#[repr(C)]
#[derive(Clone, Copy)]
pub union VkDescriptorMappingSourceDataEXT {
    pub constantOffset: VkDescriptorMappingSourceConstantOffsetEXT,
    pub pushIndex: VkDescriptorMappingSourcePushIndexEXT,
    pub indirectIndex: VkDescriptorMappingSourceIndirectIndexEXT,
    pub indirectIndexArray: VkDescriptorMappingSourceIndirectIndexArrayEXT,
    pub heapData: VkDescriptorMappingSourceHeapDataEXT,
    pub pushDataOffset: uint32_t,
    pub pushAddressOffset: uint32_t,
    pub indirectAddress: VkDescriptorMappingSourceIndirectAddressEXT,
    pub shaderRecordIndex: VkDescriptorMappingSourceShaderRecordIndexEXT,
    pub shaderRecordDataOffset: uint32_t,
    pub shaderRecordAddressOffset: uint32_t,
}
impl_debug_for_union!(VkDescriptorMappingSourceDataEXT);
impl_default_zeroed!(VkDescriptorMappingSourceDataEXT);

from_into_transparent!(VkDescriptorMappingSourceEXT: i32);
/// `VkDescriptorMappingSourceEXT`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkDescriptorMappingSourceEXT(pub i32);

/// `0`  
pub const VK_DESCRIPTOR_MAPPING_SOURCE_HEAP_WITH_CONSTANT_OFFSET_EXT: VkDescriptorMappingSourceEXT = VkDescriptorMappingSourceEXT(0);
/// `1`  
pub const VK_DESCRIPTOR_MAPPING_SOURCE_HEAP_WITH_PUSH_INDEX_EXT: VkDescriptorMappingSourceEXT = VkDescriptorMappingSourceEXT(1);
/// `2`  
pub const VK_DESCRIPTOR_MAPPING_SOURCE_HEAP_WITH_INDIRECT_INDEX_EXT: VkDescriptorMappingSourceEXT = VkDescriptorMappingSourceEXT(2);
/// `3`  
pub const VK_DESCRIPTOR_MAPPING_SOURCE_HEAP_WITH_INDIRECT_INDEX_ARRAY_EXT: VkDescriptorMappingSourceEXT = VkDescriptorMappingSourceEXT(3);
/// `4`  
pub const VK_DESCRIPTOR_MAPPING_SOURCE_RESOURCE_HEAP_DATA_EXT: VkDescriptorMappingSourceEXT = VkDescriptorMappingSourceEXT(4);
/// `5`  
pub const VK_DESCRIPTOR_MAPPING_SOURCE_PUSH_DATA_EXT: VkDescriptorMappingSourceEXT = VkDescriptorMappingSourceEXT(5);
/// `6`  
pub const VK_DESCRIPTOR_MAPPING_SOURCE_PUSH_ADDRESS_EXT: VkDescriptorMappingSourceEXT = VkDescriptorMappingSourceEXT(6);
/// `7`  
pub const VK_DESCRIPTOR_MAPPING_SOURCE_INDIRECT_ADDRESS_EXT: VkDescriptorMappingSourceEXT = VkDescriptorMappingSourceEXT(7);
/// `8`  
pub const VK_DESCRIPTOR_MAPPING_SOURCE_HEAP_WITH_SHADER_RECORD_INDEX_EXT: VkDescriptorMappingSourceEXT = VkDescriptorMappingSourceEXT(8);
/// `9`  
pub const VK_DESCRIPTOR_MAPPING_SOURCE_SHADER_RECORD_DATA_EXT: VkDescriptorMappingSourceEXT = VkDescriptorMappingSourceEXT(9);
/// `10`  
pub const VK_DESCRIPTOR_MAPPING_SOURCE_SHADER_RECORD_ADDRESS_EXT: VkDescriptorMappingSourceEXT = VkDescriptorMappingSourceEXT(10);

impl_enum_display!(VkDescriptorMappingSourceEXT { VK_DESCRIPTOR_MAPPING_SOURCE_HEAP_WITH_CONSTANT_OFFSET_EXT, VK_DESCRIPTOR_MAPPING_SOURCE_HEAP_WITH_PUSH_INDEX_EXT, VK_DESCRIPTOR_MAPPING_SOURCE_HEAP_WITH_INDIRECT_INDEX_EXT, VK_DESCRIPTOR_MAPPING_SOURCE_HEAP_WITH_INDIRECT_INDEX_ARRAY_EXT, VK_DESCRIPTOR_MAPPING_SOURCE_RESOURCE_HEAP_DATA_EXT, VK_DESCRIPTOR_MAPPING_SOURCE_PUSH_DATA_EXT, VK_DESCRIPTOR_MAPPING_SOURCE_PUSH_ADDRESS_EXT, VK_DESCRIPTOR_MAPPING_SOURCE_INDIRECT_ADDRESS_EXT, VK_DESCRIPTOR_MAPPING_SOURCE_HEAP_WITH_SHADER_RECORD_INDEX_EXT, VK_DESCRIPTOR_MAPPING_SOURCE_SHADER_RECORD_DATA_EXT, VK_DESCRIPTOR_MAPPING_SOURCE_SHADER_RECORD_ADDRESS_EXT });

/// `VkDescriptorMappingSourceHeapDataEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDescriptorMappingSourceHeapDataEXT {
    pub heapOffset: uint32_t,
    pub pushOffset: uint32_t,
}
impl_default_zeroed!(VkDescriptorMappingSourceHeapDataEXT);

/// `VkDescriptorMappingSourceIndirectAddressEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDescriptorMappingSourceIndirectAddressEXT {
    pub pushOffset: uint32_t,
    pub addressOffset: uint32_t,
}
impl_default_zeroed!(VkDescriptorMappingSourceIndirectAddressEXT);

/// `VkDescriptorMappingSourceIndirectIndexArrayEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDescriptorMappingSourceIndirectIndexArrayEXT {
    pub heapOffset: uint32_t,
    pub pushOffset: uint32_t,
    pub addressOffset: uint32_t,
    pub heapIndexStride: uint32_t,
    pub pEmbeddedSampler: *const VkSamplerCreateInfo,
    pub useCombinedImageSamplerIndex: VkBool32,
    pub samplerHeapOffset: uint32_t,
    pub samplerPushOffset: uint32_t,
    pub samplerAddressOffset: uint32_t,
    pub samplerHeapIndexStride: uint32_t,
}
impl_default_zeroed!(VkDescriptorMappingSourceIndirectIndexArrayEXT);

/// `VkDescriptorMappingSourceIndirectIndexEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDescriptorMappingSourceIndirectIndexEXT {
    pub heapOffset: uint32_t,
    pub pushOffset: uint32_t,
    pub addressOffset: uint32_t,
    pub heapIndexStride: uint32_t,
    pub heapArrayStride: uint32_t,
    pub pEmbeddedSampler: *const VkSamplerCreateInfo,
    pub useCombinedImageSamplerIndex: VkBool32,
    pub samplerHeapOffset: uint32_t,
    pub samplerPushOffset: uint32_t,
    pub samplerAddressOffset: uint32_t,
    pub samplerHeapIndexStride: uint32_t,
    pub samplerHeapArrayStride: uint32_t,
}
impl_default_zeroed!(VkDescriptorMappingSourceIndirectIndexEXT);

/// `VkDescriptorMappingSourcePushIndexEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDescriptorMappingSourcePushIndexEXT {
    pub heapOffset: uint32_t,
    pub pushOffset: uint32_t,
    pub heapIndexStride: uint32_t,
    pub heapArrayStride: uint32_t,
    pub pEmbeddedSampler: *const VkSamplerCreateInfo,
    pub useCombinedImageSamplerIndex: VkBool32,
    pub samplerHeapOffset: uint32_t,
    pub samplerPushOffset: uint32_t,
    pub samplerHeapIndexStride: uint32_t,
    pub samplerHeapArrayStride: uint32_t,
}
impl_default_zeroed!(VkDescriptorMappingSourcePushIndexEXT);

/// `VkDescriptorMappingSourceShaderRecordIndexEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDescriptorMappingSourceShaderRecordIndexEXT {
    pub heapOffset: uint32_t,
    pub shaderRecordOffset: uint32_t,
    pub heapIndexStride: uint32_t,
    pub heapArrayStride: uint32_t,
    pub pEmbeddedSampler: *const VkSamplerCreateInfo,
    pub useCombinedImageSamplerIndex: VkBool32,
    pub samplerHeapOffset: uint32_t,
    pub samplerShaderRecordOffset: uint32_t,
    pub samplerHeapIndexStride: uint32_t,
    pub samplerHeapArrayStride: uint32_t,
}
impl_default_zeroed!(VkDescriptorMappingSourceShaderRecordIndexEXT);

/// `VkDescriptorPool` : `VkDevice`
#[repr(transparent)]
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkDescriptorPool(pub u64);
from_into_transparent!(VkDescriptorPool: u64);
impl_handle!(VkDescriptorPool: VK_OBJECT_TYPE_DESCRIPTOR_POOL; SubHandle = VkDevice);

flags!(VkDescriptorPoolCreateFlags);
from_into_transparent!(VkDescriptorPoolCreateFlags: i32);
/// `VkDescriptorPoolCreateFlags`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkDescriptorPoolCreateFlags(pub i32);

/// `1 << 0`  
/// 
/// Descriptor sets may be freed individually
pub const VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT: VkDescriptorPoolCreateFlags = VkDescriptorPoolCreateFlags(1 << 0);
/// `1 << 1`  
pub const VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT: VkDescriptorPoolCreateFlags = VkDescriptorPoolCreateFlags(1 << 1);
/// `VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT`  
pub const VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT_EXT: VkDescriptorPoolCreateFlags = VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT;
/// `VK_DESCRIPTOR_POOL_CREATE_HOST_ONLY_BIT_EXT`  
pub const VK_DESCRIPTOR_POOL_CREATE_HOST_ONLY_BIT_VALVE: VkDescriptorPoolCreateFlags = VK_DESCRIPTOR_POOL_CREATE_HOST_ONLY_BIT_EXT;
/// `1 << 2`  
pub const VK_DESCRIPTOR_POOL_CREATE_HOST_ONLY_BIT_EXT: VkDescriptorPoolCreateFlags = VkDescriptorPoolCreateFlags(1 << 2);
/// `1 << 3`  
pub const VK_DESCRIPTOR_POOL_CREATE_ALLOW_OVERALLOCATION_SETS_BIT_NV: VkDescriptorPoolCreateFlags = VkDescriptorPoolCreateFlags(1 << 3);
/// `1 << 4`  
pub const VK_DESCRIPTOR_POOL_CREATE_ALLOW_OVERALLOCATION_POOLS_BIT_NV: VkDescriptorPoolCreateFlags = VkDescriptorPoolCreateFlags(1 << 4);

impl_flags_display!(VkDescriptorPoolCreateFlags { VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT, VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT_EXT, VK_DESCRIPTOR_POOL_CREATE_HOST_ONLY_BIT_VALVE, VK_DESCRIPTOR_POOL_CREATE_HOST_ONLY_BIT_EXT, VK_DESCRIPTOR_POOL_CREATE_ALLOW_OVERALLOCATION_SETS_BIT_NV, VK_DESCRIPTOR_POOL_CREATE_ALLOW_OVERALLOCATION_POOLS_BIT_NV });

/// `VkDescriptorPoolCreateInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDescriptorPoolCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub flags: VkDescriptorPoolCreateFlags,
    pub maxSets: uint32_t,
    pub poolSizeCount: uint32_t,
    pub pPoolSizes: *const VkDescriptorPoolSize,
}
impl_default_zeroed_with_s_type!(VkDescriptorPoolCreateInfo : VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO);

/// `VkDescriptorPoolInlineUniformBlockCreateInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDescriptorPoolInlineUniformBlockCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub maxInlineUniformBlockBindings: uint32_t,
}
impl_default_zeroed_with_s_type!(VkDescriptorPoolInlineUniformBlockCreateInfo : VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO);
impl_extends!(VkDescriptorPoolInlineUniformBlockCreateInfo : VkDescriptorPoolCreateInfo);

/// `VkDescriptorPoolInlineUniformBlockCreateInfo`
pub type VkDescriptorPoolInlineUniformBlockCreateInfoEXT = VkDescriptorPoolInlineUniformBlockCreateInfo;

flags!(VkDescriptorPoolResetFlags);
from_into_transparent!(VkDescriptorPoolResetFlags: i32);
/// `VkDescriptorPoolResetFlags`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkDescriptorPoolResetFlags(pub i32);

impl_flags_display!(VkDescriptorPoolResetFlags {  });

/// `VkDescriptorPoolSize`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDescriptorPoolSize {
    pub r#type: VkDescriptorType,
    pub descriptorCount: uint32_t,
}
impl_default_zeroed!(VkDescriptorPoolSize);

/// `VkDescriptorSet` : `VkDescriptorPool`
#[repr(transparent)]
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkDescriptorSet(pub u64);
from_into_transparent!(VkDescriptorSet: u64);
impl_handle!(VkDescriptorSet: VK_OBJECT_TYPE_DESCRIPTOR_SET; SubHandle = VkDescriptorPool);

/// `VkDescriptorSetAllocateInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDescriptorSetAllocateInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub descriptorPool: VkDescriptorPool,
    pub descriptorSetCount: uint32_t,
    pub pSetLayouts: *const VkDescriptorSetLayout,
}
impl_default_zeroed_with_s_type!(VkDescriptorSetAllocateInfo : VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO);

/// `VkDescriptorSetAndBindingMappingEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDescriptorSetAndBindingMappingEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub descriptorSet: uint32_t,
    pub firstBinding: uint32_t,
    pub bindingCount: uint32_t,
    pub resourceMask: VkSpirvResourceTypeFlagsEXT,
    pub source: VkDescriptorMappingSourceEXT,
    pub sourceData: VkDescriptorMappingSourceDataEXT,
}
impl_default_zeroed_with_s_type!(VkDescriptorSetAndBindingMappingEXT : VK_STRUCTURE_TYPE_DESCRIPTOR_SET_AND_BINDING_MAPPING_EXT);

/// `VkDescriptorSetBindingReferenceVALVE`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDescriptorSetBindingReferenceVALVE {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub descriptorSetLayout: VkDescriptorSetLayout,
    pub binding: uint32_t,
}
impl_default_zeroed_with_s_type!(VkDescriptorSetBindingReferenceVALVE : VK_STRUCTURE_TYPE_DESCRIPTOR_SET_BINDING_REFERENCE_VALVE);

/// `VkDescriptorSetLayout` : `VkDevice`
#[repr(transparent)]
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkDescriptorSetLayout(pub u64);
from_into_transparent!(VkDescriptorSetLayout: u64);
impl_handle!(VkDescriptorSetLayout: VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT; SubHandle = VkDevice);

/// `VkDescriptorSetLayoutBinding`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDescriptorSetLayoutBinding {
    /// Binding number for this entry
    pub binding: uint32_t,
    /// Type of the descriptors in this binding
    pub descriptorType: VkDescriptorType,
    /// Number of descriptors in this binding
    pub descriptorCount: uint32_t,
    /// Shader stages this binding is visible to
    pub stageFlags: VkShaderStageFlags,
    /// Immutable samplers (used if descriptor type is SAMPLER or COMBINED_IMAGE_SAMPLER, is either NULL or contains count number of elements)
    pub pImmutableSamplers: *const VkSampler,
}
impl_default_zeroed!(VkDescriptorSetLayoutBinding);

/// `VkDescriptorSetLayoutBindingFlagsCreateInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDescriptorSetLayoutBindingFlagsCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub bindingCount: uint32_t,
    pub pBindingFlags: *const VkDescriptorBindingFlags,
}
impl_default_zeroed_with_s_type!(VkDescriptorSetLayoutBindingFlagsCreateInfo : VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO);
impl_extends!(VkDescriptorSetLayoutBindingFlagsCreateInfo : VkDescriptorSetLayoutCreateInfo);

/// `VkDescriptorSetLayoutBindingFlagsCreateInfo`
pub type VkDescriptorSetLayoutBindingFlagsCreateInfoEXT = VkDescriptorSetLayoutBindingFlagsCreateInfo;

flags!(VkDescriptorSetLayoutCreateFlags);
from_into_transparent!(VkDescriptorSetLayoutCreateFlags: i32);
/// `VkDescriptorSetLayoutCreateFlags`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkDescriptorSetLayoutCreateFlags(pub i32);

/// `1 << 1`  
pub const VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT: VkDescriptorSetLayoutCreateFlags = VkDescriptorSetLayoutCreateFlags(1 << 1);
/// `1 << 0`  
pub const VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT: VkDescriptorSetLayoutCreateFlags = VkDescriptorSetLayoutCreateFlags(1 << 0);
/// `VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT`  
/// 
/// Descriptors are pushed via flink:vkCmdPushDescriptorSet
pub const VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR: VkDescriptorSetLayoutCreateFlags = VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT;
/// `VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT`  
pub const VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT: VkDescriptorSetLayoutCreateFlags = VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT;
/// `1 << 4`  
pub const VK_DESCRIPTOR_SET_LAYOUT_CREATE_DESCRIPTOR_BUFFER_BIT_EXT: VkDescriptorSetLayoutCreateFlags = VkDescriptorSetLayoutCreateFlags(1 << 4);
/// `1 << 5`  
pub const VK_DESCRIPTOR_SET_LAYOUT_CREATE_EMBEDDED_IMMUTABLE_SAMPLERS_BIT_EXT: VkDescriptorSetLayoutCreateFlags = VkDescriptorSetLayoutCreateFlags(1 << 5);
/// `1 << 3`  
pub const VK_DESCRIPTOR_SET_LAYOUT_CREATE_RESERVED_3_BIT_AMD: VkDescriptorSetLayoutCreateFlags = VkDescriptorSetLayoutCreateFlags(1 << 3);
/// `VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_EXT`  
pub const VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_VALVE: VkDescriptorSetLayoutCreateFlags = VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_EXT;
/// `1 << 7`  
pub const VK_DESCRIPTOR_SET_LAYOUT_CREATE_INDIRECT_BINDABLE_BIT_NV: VkDescriptorSetLayoutCreateFlags = VkDescriptorSetLayoutCreateFlags(1 << 7);
/// `1 << 2`  
pub const VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_EXT: VkDescriptorSetLayoutCreateFlags = VkDescriptorSetLayoutCreateFlags(1 << 2);
/// `1 << 6`  
pub const VK_DESCRIPTOR_SET_LAYOUT_CREATE_PER_STAGE_BIT_NV: VkDescriptorSetLayoutCreateFlags = VkDescriptorSetLayoutCreateFlags(1 << 6);

impl_flags_display!(VkDescriptorSetLayoutCreateFlags { VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT, VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT, VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR, VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT, VK_DESCRIPTOR_SET_LAYOUT_CREATE_DESCRIPTOR_BUFFER_BIT_EXT, VK_DESCRIPTOR_SET_LAYOUT_CREATE_EMBEDDED_IMMUTABLE_SAMPLERS_BIT_EXT, VK_DESCRIPTOR_SET_LAYOUT_CREATE_RESERVED_3_BIT_AMD, VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_VALVE, VK_DESCRIPTOR_SET_LAYOUT_CREATE_INDIRECT_BINDABLE_BIT_NV, VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_EXT, VK_DESCRIPTOR_SET_LAYOUT_CREATE_PER_STAGE_BIT_NV });

/// `VkDescriptorSetLayoutCreateInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDescriptorSetLayoutCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub flags: VkDescriptorSetLayoutCreateFlags,
    /// Number of bindings in the descriptor set layout
    pub bindingCount: uint32_t,
    /// Array of descriptor set layout bindings
    pub pBindings: *const VkDescriptorSetLayoutBinding,
}
impl_default_zeroed_with_s_type!(VkDescriptorSetLayoutCreateInfo : VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO);

/// `VkDescriptorSetLayoutHostMappingInfoVALVE`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDescriptorSetLayoutHostMappingInfoVALVE {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub descriptorOffset: size_t,
    pub descriptorSize: uint32_t,
}
impl_default_zeroed_with_s_type!(VkDescriptorSetLayoutHostMappingInfoVALVE : VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_HOST_MAPPING_INFO_VALVE);

/// `VkDescriptorSetLayoutSupport`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDescriptorSetLayoutSupport {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub supported: VkBool32,
}
impl_default_zeroed_with_s_type!(VkDescriptorSetLayoutSupport : VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT);

/// `VkDescriptorSetLayoutSupport`
pub type VkDescriptorSetLayoutSupportKHR = VkDescriptorSetLayoutSupport;

/// `VkDescriptorSetVariableDescriptorCountAllocateInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDescriptorSetVariableDescriptorCountAllocateInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub descriptorSetCount: uint32_t,
    pub pDescriptorCounts: *const uint32_t,
}
impl_default_zeroed_with_s_type!(VkDescriptorSetVariableDescriptorCountAllocateInfo : VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO);
impl_extends!(VkDescriptorSetVariableDescriptorCountAllocateInfo : VkDescriptorSetAllocateInfo);

/// `VkDescriptorSetVariableDescriptorCountAllocateInfo`
pub type VkDescriptorSetVariableDescriptorCountAllocateInfoEXT = VkDescriptorSetVariableDescriptorCountAllocateInfo;

/// `VkDescriptorSetVariableDescriptorCountLayoutSupport`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDescriptorSetVariableDescriptorCountLayoutSupport {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub maxVariableDescriptorCount: uint32_t,
}
impl_default_zeroed_with_s_type!(VkDescriptorSetVariableDescriptorCountLayoutSupport : VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT);
impl_extends!(VkDescriptorSetVariableDescriptorCountLayoutSupport : VkDescriptorSetLayoutSupport);

/// `VkDescriptorSetVariableDescriptorCountLayoutSupport`
pub type VkDescriptorSetVariableDescriptorCountLayoutSupportEXT = VkDescriptorSetVariableDescriptorCountLayoutSupport;

from_into_transparent!(VkDescriptorType: i32);
/// `VkDescriptorType`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkDescriptorType(pub i32);

/// `0`  
pub const VK_DESCRIPTOR_TYPE_SAMPLER: VkDescriptorType = VkDescriptorType(0);
/// `1`  
pub const VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER: VkDescriptorType = VkDescriptorType(1);
/// `2`  
pub const VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE: VkDescriptorType = VkDescriptorType(2);
/// `3`  
pub const VK_DESCRIPTOR_TYPE_STORAGE_IMAGE: VkDescriptorType = VkDescriptorType(3);
/// `4`  
pub const VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER: VkDescriptorType = VkDescriptorType(4);
/// `5`  
pub const VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER: VkDescriptorType = VkDescriptorType(5);
/// `6`  
pub const VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER: VkDescriptorType = VkDescriptorType(6);
/// `7`  
pub const VK_DESCRIPTOR_TYPE_STORAGE_BUFFER: VkDescriptorType = VkDescriptorType(7);
/// `8`  
pub const VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC: VkDescriptorType = VkDescriptorType(8);
/// `9`  
pub const VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC: VkDescriptorType = VkDescriptorType(9);
/// `10`  
pub const VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT: VkDescriptorType = VkDescriptorType(10);
/// `1000138000`  
pub const VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK: VkDescriptorType = VkDescriptorType(1000138000);
/// `VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK`  
pub const VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT: VkDescriptorType = VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK;
/// `1000150000`  
pub const VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR: VkDescriptorType = VkDescriptorType(1000150000);
/// `1000165000`  
pub const VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV: VkDescriptorType = VkDescriptorType(1000165000);
/// `VK_DESCRIPTOR_TYPE_MUTABLE_EXT`  
pub const VK_DESCRIPTOR_TYPE_MUTABLE_VALVE: VkDescriptorType = VK_DESCRIPTOR_TYPE_MUTABLE_EXT;
/// `1000440000`  
pub const VK_DESCRIPTOR_TYPE_SAMPLE_WEIGHT_IMAGE_QCOM: VkDescriptorType = VkDescriptorType(1000440000);
/// `1000440001`  
pub const VK_DESCRIPTOR_TYPE_BLOCK_MATCH_IMAGE_QCOM: VkDescriptorType = VkDescriptorType(1000440001);
/// `1000460000`  
pub const VK_DESCRIPTOR_TYPE_TENSOR_ARM: VkDescriptorType = VkDescriptorType(1000460000);
/// `1000351000`  
pub const VK_DESCRIPTOR_TYPE_MUTABLE_EXT: VkDescriptorType = VkDescriptorType(1000351000);
/// `1000570000`  
pub const VK_DESCRIPTOR_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_NV: VkDescriptorType = VkDescriptorType(1000570000);

impl_enum_display!(VkDescriptorType { VK_DESCRIPTOR_TYPE_SAMPLER, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER, VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC, VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK, VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT, VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR, VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV, VK_DESCRIPTOR_TYPE_MUTABLE_VALVE, VK_DESCRIPTOR_TYPE_SAMPLE_WEIGHT_IMAGE_QCOM, VK_DESCRIPTOR_TYPE_BLOCK_MATCH_IMAGE_QCOM, VK_DESCRIPTOR_TYPE_TENSOR_ARM, VK_DESCRIPTOR_TYPE_MUTABLE_EXT, VK_DESCRIPTOR_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_NV });

/// `VkDescriptorUpdateTemplate` : `VkDevice`
#[repr(transparent)]
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkDescriptorUpdateTemplate(pub u64);
from_into_transparent!(VkDescriptorUpdateTemplate: u64);
impl_handle!(VkDescriptorUpdateTemplate: VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE; SubHandle = VkDevice);

flags!(VkDescriptorUpdateTemplateCreateFlags);
from_into_transparent!(VkDescriptorUpdateTemplateCreateFlags: i32);
/// `VkDescriptorUpdateTemplateCreateFlags`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkDescriptorUpdateTemplateCreateFlags(pub i32);

impl_flags_display!(VkDescriptorUpdateTemplateCreateFlags {  });

/// `VkDescriptorUpdateTemplateCreateFlags`
pub type VkDescriptorUpdateTemplateCreateFlagsKHR = VkDescriptorUpdateTemplateCreateFlags;

/// `VkDescriptorUpdateTemplateCreateInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDescriptorUpdateTemplateCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub flags: VkDescriptorUpdateTemplateCreateFlags,
    /// Number of descriptor update entries to use for the update template
    pub descriptorUpdateEntryCount: uint32_t,
    /// Descriptor update entries for the template
    pub pDescriptorUpdateEntries: *const VkDescriptorUpdateTemplateEntry,
    pub templateType: VkDescriptorUpdateTemplateType,
    pub descriptorSetLayout: VkDescriptorSetLayout,
    pub pipelineBindPoint: VkPipelineBindPoint,
    /// If used for push descriptors, this is the only allowed layout
    pub pipelineLayout: VkPipelineLayout,
    pub set: uint32_t,
}
impl_default_zeroed_with_s_type!(VkDescriptorUpdateTemplateCreateInfo : VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO);

/// `VkDescriptorUpdateTemplateCreateInfo`
pub type VkDescriptorUpdateTemplateCreateInfoKHR = VkDescriptorUpdateTemplateCreateInfo;

/// `VkDescriptorUpdateTemplateEntry`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDescriptorUpdateTemplateEntry {
    /// Binding within the destination descriptor set to write
    pub dstBinding: uint32_t,
    /// Array element within the destination binding to write
    pub dstArrayElement: uint32_t,
    /// Number of descriptors to write
    pub descriptorCount: uint32_t,
    /// Descriptor type to write
    pub descriptorType: VkDescriptorType,
    /// Offset into pData where the descriptors to update are stored
    pub offset: size_t,
    /// Stride between two descriptors in pData when writing more than one descriptor
    pub stride: size_t,
}
impl_default_zeroed!(VkDescriptorUpdateTemplateEntry);

/// `VkDescriptorUpdateTemplateEntry`
pub type VkDescriptorUpdateTemplateEntryKHR = VkDescriptorUpdateTemplateEntry;

/// `VkDescriptorUpdateTemplate`
pub type VkDescriptorUpdateTemplateKHR = VkDescriptorUpdateTemplate;

from_into_transparent!(VkDescriptorUpdateTemplateType: i32);
/// `VkDescriptorUpdateTemplateType`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkDescriptorUpdateTemplateType(pub i32);

/// `0`  
/// 
/// Create descriptor update template for descriptor set updates
pub const VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET: VkDescriptorUpdateTemplateType = VkDescriptorUpdateTemplateType(0);
/// `1`  
pub const VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS: VkDescriptorUpdateTemplateType = VkDescriptorUpdateTemplateType(1);
/// `VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS`  
/// 
/// Create descriptor update template for pushed descriptor updates
pub const VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR: VkDescriptorUpdateTemplateType = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS;
/// `VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET`  
pub const VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET_KHR: VkDescriptorUpdateTemplateType = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET;

impl_enum_display!(VkDescriptorUpdateTemplateType { VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET, VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS, VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR, VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET_KHR });

/// `VkDescriptorUpdateTemplateType`
pub type VkDescriptorUpdateTemplateTypeKHR = VkDescriptorUpdateTemplateType;

/// `VkDevice` : `VkPhysicalDevice`
#[repr(transparent)]
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkDevice(pub *mut void);
from_into_transparent!(VkDevice: *mut void);
from_into_transparent!(VkDevice: u64);
impl_handle!(VkDevice: VK_OBJECT_TYPE_DEVICE; SubHandle = VkPhysicalDevice);

/// `VkDeviceAddressBindingCallbackDataEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDeviceAddressBindingCallbackDataEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub flags: VkDeviceAddressBindingFlagsEXT,
    pub baseAddress: VkDeviceAddress,
    pub size: VkDeviceSize,
    pub bindingType: VkDeviceAddressBindingTypeEXT,
}
impl_default_zeroed_with_s_type!(VkDeviceAddressBindingCallbackDataEXT : VK_STRUCTURE_TYPE_DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT);
impl_extends!(VkDeviceAddressBindingCallbackDataEXT : VkDebugUtilsMessengerCallbackDataEXT);

flags!(VkDeviceAddressBindingFlagsEXT);
from_into_transparent!(VkDeviceAddressBindingFlagsEXT: i32);
/// `VkDeviceAddressBindingFlagsEXT`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkDeviceAddressBindingFlagsEXT(pub i32);

/// `1 << 0`  
pub const VK_DEVICE_ADDRESS_BINDING_INTERNAL_OBJECT_BIT_EXT: VkDeviceAddressBindingFlagsEXT = VkDeviceAddressBindingFlagsEXT(1 << 0);

impl_flags_display!(VkDeviceAddressBindingFlagsEXT { VK_DEVICE_ADDRESS_BINDING_INTERNAL_OBJECT_BIT_EXT });

from_into_transparent!(VkDeviceAddressBindingTypeEXT: i32);
/// `VkDeviceAddressBindingTypeEXT`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkDeviceAddressBindingTypeEXT(pub i32);

/// `0`  
pub const VK_DEVICE_ADDRESS_BINDING_TYPE_BIND_EXT: VkDeviceAddressBindingTypeEXT = VkDeviceAddressBindingTypeEXT(0);
/// `1`  
pub const VK_DEVICE_ADDRESS_BINDING_TYPE_UNBIND_EXT: VkDeviceAddressBindingTypeEXT = VkDeviceAddressBindingTypeEXT(1);

impl_enum_display!(VkDeviceAddressBindingTypeEXT { VK_DEVICE_ADDRESS_BINDING_TYPE_BIND_EXT, VK_DEVICE_ADDRESS_BINDING_TYPE_UNBIND_EXT });

/// `VkDeviceAddressRangeEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDeviceAddressRangeEXT {
    pub address: VkDeviceAddress,
    pub size: VkDeviceSize,
}
impl_default_zeroed!(VkDeviceAddressRangeEXT);

/// `VkDeviceBufferMemoryRequirements`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDeviceBufferMemoryRequirements {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub pCreateInfo: *const VkBufferCreateInfo,
}
impl_default_zeroed_with_s_type!(VkDeviceBufferMemoryRequirements : VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS);

/// `VkDeviceBufferMemoryRequirements`
pub type VkDeviceBufferMemoryRequirementsKHR = VkDeviceBufferMemoryRequirements;

flags!(VkDeviceCreateFlags);
from_into_transparent!(VkDeviceCreateFlags: i32);
/// `VkDeviceCreateFlags`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkDeviceCreateFlags(pub i32);

impl_flags_display!(VkDeviceCreateFlags {  });

/// `VkDeviceCreateInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDeviceCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub flags: VkDeviceCreateFlags,
    pub queueCreateInfoCount: uint32_t,
    pub pQueueCreateInfos: *const VkDeviceQueueCreateInfo,
    pub enabledLayerCount: uint32_t,
    /// Ordered list of layer names to be enabled
    pub ppEnabledLayerNames: *const *const c_char,
    pub enabledExtensionCount: uint32_t,
    pub ppEnabledExtensionNames: *const *const c_char,
    pub pEnabledFeatures: *const VkPhysicalDeviceFeatures,
}
impl_default_zeroed_with_s_type!(VkDeviceCreateInfo : VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO);

/// `VkDeviceDeviceMemoryReportCreateInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDeviceDeviceMemoryReportCreateInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub flags: VkDeviceMemoryReportFlagsEXT,
    pub pfnUserCallback: PFN_vkDeviceMemoryReportCallbackEXT,
    pub pUserData: *mut void,
}
impl_default_zeroed_with_s_type!(VkDeviceDeviceMemoryReportCreateInfoEXT : VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT);
impl_extends!(VkDeviceDeviceMemoryReportCreateInfoEXT : VkDeviceCreateInfo);

/// `VkDeviceDiagnosticsConfigCreateInfoNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDeviceDiagnosticsConfigCreateInfoNV {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub flags: VkDeviceDiagnosticsConfigFlagsNV,
}
impl_default_zeroed_with_s_type!(VkDeviceDiagnosticsConfigCreateInfoNV : VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV);
impl_extends!(VkDeviceDiagnosticsConfigCreateInfoNV : VkDeviceCreateInfo);

flags!(VkDeviceDiagnosticsConfigFlagsNV);
from_into_transparent!(VkDeviceDiagnosticsConfigFlagsNV: i32);
/// `VkDeviceDiagnosticsConfigFlagsNV`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkDeviceDiagnosticsConfigFlagsNV(pub i32);

/// `1 << 0`  
pub const VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_SHADER_DEBUG_INFO_BIT_NV: VkDeviceDiagnosticsConfigFlagsNV = VkDeviceDiagnosticsConfigFlagsNV(1 << 0);
/// `1 << 1`  
pub const VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_RESOURCE_TRACKING_BIT_NV: VkDeviceDiagnosticsConfigFlagsNV = VkDeviceDiagnosticsConfigFlagsNV(1 << 1);
/// `1 << 2`  
pub const VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_AUTOMATIC_CHECKPOINTS_BIT_NV: VkDeviceDiagnosticsConfigFlagsNV = VkDeviceDiagnosticsConfigFlagsNV(1 << 2);
/// `1 << 3`  
pub const VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_SHADER_ERROR_REPORTING_BIT_NV: VkDeviceDiagnosticsConfigFlagsNV = VkDeviceDiagnosticsConfigFlagsNV(1 << 3);

impl_flags_display!(VkDeviceDiagnosticsConfigFlagsNV { VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_SHADER_DEBUG_INFO_BIT_NV, VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_RESOURCE_TRACKING_BIT_NV, VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_AUTOMATIC_CHECKPOINTS_BIT_NV, VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_SHADER_ERROR_REPORTING_BIT_NV });

/// `VkDeviceEventInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDeviceEventInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub deviceEvent: VkDeviceEventTypeEXT,
}
impl_default_zeroed_with_s_type!(VkDeviceEventInfoEXT : VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT);

from_into_transparent!(VkDeviceEventTypeEXT: i32);
/// `VkDeviceEventTypeEXT`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkDeviceEventTypeEXT(pub i32);

/// `0`  
pub const VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT: VkDeviceEventTypeEXT = VkDeviceEventTypeEXT(0);

impl_enum_display!(VkDeviceEventTypeEXT { VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT });

/// `VkDeviceFaultAddressInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDeviceFaultAddressInfoEXT {
    pub addressType: VkDeviceFaultAddressTypeEXT,
    pub reportedAddress: VkDeviceAddress,
    pub addressPrecision: VkDeviceSize,
}
impl_default_zeroed!(VkDeviceFaultAddressInfoEXT);

from_into_transparent!(VkDeviceFaultAddressTypeEXT: i32);
/// `VkDeviceFaultAddressTypeEXT`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkDeviceFaultAddressTypeEXT(pub i32);

/// `0`  
/// 
/// Currently unused
pub const VK_DEVICE_FAULT_ADDRESS_TYPE_NONE_EXT: VkDeviceFaultAddressTypeEXT = VkDeviceFaultAddressTypeEXT(0);
/// `1`  
pub const VK_DEVICE_FAULT_ADDRESS_TYPE_READ_INVALID_EXT: VkDeviceFaultAddressTypeEXT = VkDeviceFaultAddressTypeEXT(1);
/// `2`  
pub const VK_DEVICE_FAULT_ADDRESS_TYPE_WRITE_INVALID_EXT: VkDeviceFaultAddressTypeEXT = VkDeviceFaultAddressTypeEXT(2);
/// `3`  
pub const VK_DEVICE_FAULT_ADDRESS_TYPE_EXECUTE_INVALID_EXT: VkDeviceFaultAddressTypeEXT = VkDeviceFaultAddressTypeEXT(3);
/// `4`  
pub const VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_UNKNOWN_EXT: VkDeviceFaultAddressTypeEXT = VkDeviceFaultAddressTypeEXT(4);
/// `5`  
pub const VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_INVALID_EXT: VkDeviceFaultAddressTypeEXT = VkDeviceFaultAddressTypeEXT(5);
/// `6`  
pub const VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_FAULT_EXT: VkDeviceFaultAddressTypeEXT = VkDeviceFaultAddressTypeEXT(6);

impl_enum_display!(VkDeviceFaultAddressTypeEXT { VK_DEVICE_FAULT_ADDRESS_TYPE_NONE_EXT, VK_DEVICE_FAULT_ADDRESS_TYPE_READ_INVALID_EXT, VK_DEVICE_FAULT_ADDRESS_TYPE_WRITE_INVALID_EXT, VK_DEVICE_FAULT_ADDRESS_TYPE_EXECUTE_INVALID_EXT, VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_UNKNOWN_EXT, VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_INVALID_EXT, VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_FAULT_EXT });

/// `VkDeviceFaultCountsEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDeviceFaultCountsEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub addressInfoCount: uint32_t,
    pub vendorInfoCount: uint32_t,
    /// Specified in bytes
    pub vendorBinarySize: VkDeviceSize,
}
impl_default_zeroed_with_s_type!(VkDeviceFaultCountsEXT : VK_STRUCTURE_TYPE_DEVICE_FAULT_COUNTS_EXT);

/// `VkDeviceFaultInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDeviceFaultInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    /// Free-form description of the fault
    pub description: [c_char; VK_MAX_DESCRIPTION_SIZE as usize],
    pub pAddressInfos: *mut VkDeviceFaultAddressInfoEXT,
    pub pVendorInfos: *mut VkDeviceFaultVendorInfoEXT,
    pub pVendorBinaryData: *mut void,
}
impl_default_zeroed_with_s_type!(VkDeviceFaultInfoEXT : VK_STRUCTURE_TYPE_DEVICE_FAULT_INFO_EXT);

from_into_transparent!(VkDeviceFaultVendorBinaryHeaderVersionEXT: i32);
/// `VkDeviceFaultVendorBinaryHeaderVersionEXT`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkDeviceFaultVendorBinaryHeaderVersionEXT(pub i32);

/// `1`  
pub const VK_DEVICE_FAULT_VENDOR_BINARY_HEADER_VERSION_ONE_EXT: VkDeviceFaultVendorBinaryHeaderVersionEXT = VkDeviceFaultVendorBinaryHeaderVersionEXT(1);

impl_enum_display!(VkDeviceFaultVendorBinaryHeaderVersionEXT { VK_DEVICE_FAULT_VENDOR_BINARY_HEADER_VERSION_ONE_EXT });

/// `VkDeviceFaultVendorBinaryHeaderVersionOneEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDeviceFaultVendorBinaryHeaderVersionOneEXT {
    pub headerSize: uint32_t,
    pub headerVersion: VkDeviceFaultVendorBinaryHeaderVersionEXT,
    pub vendorID: uint32_t,
    pub deviceID: uint32_t,
    pub driverVersion: uint32_t,
    pub pipelineCacheUUID: [uint8_t; VK_UUID_SIZE as usize],
    pub applicationNameOffset: uint32_t,
    pub applicationVersion: uint32_t,
    pub engineNameOffset: uint32_t,
    pub engineVersion: uint32_t,
    pub apiVersion: uint32_t,
}
impl_default_zeroed!(VkDeviceFaultVendorBinaryHeaderVersionOneEXT);

/// `VkDeviceFaultVendorInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDeviceFaultVendorInfoEXT {
    /// Free-form description of the fault
    pub description: [c_char; VK_MAX_DESCRIPTION_SIZE as usize],
    pub vendorFaultCode: uint64_t,
    pub vendorFaultData: uint64_t,
}
impl_default_zeroed!(VkDeviceFaultVendorInfoEXT);

/// `VkDeviceGroupBindSparseInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDeviceGroupBindSparseInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub resourceDeviceIndex: uint32_t,
    pub memoryDeviceIndex: uint32_t,
}
impl_default_zeroed_with_s_type!(VkDeviceGroupBindSparseInfo : VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO);
impl_extends!(VkDeviceGroupBindSparseInfo : VkBindSparseInfo);

/// `VkDeviceGroupBindSparseInfo`
pub type VkDeviceGroupBindSparseInfoKHR = VkDeviceGroupBindSparseInfo;

/// `VkDeviceGroupCommandBufferBeginInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDeviceGroupCommandBufferBeginInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub deviceMask: uint32_t,
}
impl_default_zeroed_with_s_type!(VkDeviceGroupCommandBufferBeginInfo : VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO);
impl_extends!(VkDeviceGroupCommandBufferBeginInfo : VkCommandBufferBeginInfo);

/// `VkDeviceGroupCommandBufferBeginInfo`
pub type VkDeviceGroupCommandBufferBeginInfoKHR = VkDeviceGroupCommandBufferBeginInfo;

/// `VkDeviceGroupDeviceCreateInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDeviceGroupDeviceCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub physicalDeviceCount: uint32_t,
    pub pPhysicalDevices: *const VkPhysicalDevice,
}
impl_default_zeroed_with_s_type!(VkDeviceGroupDeviceCreateInfo : VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO);
impl_extends!(VkDeviceGroupDeviceCreateInfo : VkDeviceCreateInfo);

/// `VkDeviceGroupDeviceCreateInfo`
pub type VkDeviceGroupDeviceCreateInfoKHR = VkDeviceGroupDeviceCreateInfo;

/// `VkDeviceGroupPresentCapabilitiesKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDeviceGroupPresentCapabilitiesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub presentMask: [uint32_t; VK_MAX_DEVICE_GROUP_SIZE as usize],
    pub modes: VkDeviceGroupPresentModeFlagsKHR,
}
impl_default_zeroed_with_s_type!(VkDeviceGroupPresentCapabilitiesKHR : VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR);

/// `VkDeviceGroupPresentInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDeviceGroupPresentInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub swapchainCount: uint32_t,
    pub pDeviceMasks: *const uint32_t,
    pub mode: VkDeviceGroupPresentModeFlagsKHR,
}
impl_default_zeroed_with_s_type!(VkDeviceGroupPresentInfoKHR : VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR);
impl_extends!(VkDeviceGroupPresentInfoKHR : VkPresentInfoKHR);

flags!(VkDeviceGroupPresentModeFlagsKHR);
from_into_transparent!(VkDeviceGroupPresentModeFlagsKHR: i32);
/// `VkDeviceGroupPresentModeFlagsKHR`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkDeviceGroupPresentModeFlagsKHR(pub i32);

/// `1 << 0`  
/// 
/// Present from local memory
pub const VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR: VkDeviceGroupPresentModeFlagsKHR = VkDeviceGroupPresentModeFlagsKHR(1 << 0);
/// `1 << 1`  
/// 
/// Present from remote memory
pub const VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHR: VkDeviceGroupPresentModeFlagsKHR = VkDeviceGroupPresentModeFlagsKHR(1 << 1);
/// `1 << 2`  
/// 
/// Present sum of local and/or remote memory
pub const VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHR: VkDeviceGroupPresentModeFlagsKHR = VkDeviceGroupPresentModeFlagsKHR(1 << 2);
/// `1 << 3`  
/// 
/// Each physical device presents from local memory
pub const VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHR: VkDeviceGroupPresentModeFlagsKHR = VkDeviceGroupPresentModeFlagsKHR(1 << 3);

impl_flags_display!(VkDeviceGroupPresentModeFlagsKHR { VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR, VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHR, VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHR, VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHR });

/// `VkDeviceGroupRenderPassBeginInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDeviceGroupRenderPassBeginInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub deviceMask: uint32_t,
    pub deviceRenderAreaCount: uint32_t,
    pub pDeviceRenderAreas: *const VkRect2D,
}
impl_default_zeroed_with_s_type!(VkDeviceGroupRenderPassBeginInfo : VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO);
impl_extends!(VkDeviceGroupRenderPassBeginInfo : VkRenderPassBeginInfo, VkRenderingInfo);

/// `VkDeviceGroupRenderPassBeginInfo`
pub type VkDeviceGroupRenderPassBeginInfoKHR = VkDeviceGroupRenderPassBeginInfo;

/// `VkDeviceGroupSubmitInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDeviceGroupSubmitInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub waitSemaphoreCount: uint32_t,
    pub pWaitSemaphoreDeviceIndices: *const uint32_t,
    pub commandBufferCount: uint32_t,
    pub pCommandBufferDeviceMasks: *const uint32_t,
    pub signalSemaphoreCount: uint32_t,
    pub pSignalSemaphoreDeviceIndices: *const uint32_t,
}
impl_default_zeroed_with_s_type!(VkDeviceGroupSubmitInfo : VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO);
impl_extends!(VkDeviceGroupSubmitInfo : VkSubmitInfo);

/// `VkDeviceGroupSubmitInfo`
pub type VkDeviceGroupSubmitInfoKHR = VkDeviceGroupSubmitInfo;

/// `VkDeviceGroupSwapchainCreateInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDeviceGroupSwapchainCreateInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub modes: VkDeviceGroupPresentModeFlagsKHR,
}
impl_default_zeroed_with_s_type!(VkDeviceGroupSwapchainCreateInfoKHR : VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR);
impl_extends!(VkDeviceGroupSwapchainCreateInfoKHR : VkSwapchainCreateInfoKHR);

/// `VkDeviceImageMemoryRequirements`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDeviceImageMemoryRequirements {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub pCreateInfo: *const VkImageCreateInfo,
    pub planeAspect: VkImageAspectFlags,
}
impl_default_zeroed_with_s_type!(VkDeviceImageMemoryRequirements : VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS);

/// `VkDeviceImageMemoryRequirements`
pub type VkDeviceImageMemoryRequirementsKHR = VkDeviceImageMemoryRequirements;

/// `VkDeviceImageSubresourceInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDeviceImageSubresourceInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub pCreateInfo: *const VkImageCreateInfo,
    pub pSubresource: *const VkImageSubresource2,
}
impl_default_zeroed_with_s_type!(VkDeviceImageSubresourceInfo : VK_STRUCTURE_TYPE_DEVICE_IMAGE_SUBRESOURCE_INFO);

/// `VkDeviceImageSubresourceInfo`
pub type VkDeviceImageSubresourceInfoKHR = VkDeviceImageSubresourceInfo;

/// `VkDeviceMemory` : `VkDevice`
#[repr(transparent)]
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkDeviceMemory(pub u64);
from_into_transparent!(VkDeviceMemory: u64);
impl_handle!(VkDeviceMemory: VK_OBJECT_TYPE_DEVICE_MEMORY; SubHandle = VkDevice);

/// `VkDeviceMemoryOpaqueCaptureAddressInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDeviceMemoryOpaqueCaptureAddressInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub memory: VkDeviceMemory,
}
impl_default_zeroed_with_s_type!(VkDeviceMemoryOpaqueCaptureAddressInfo : VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO);

/// `VkDeviceMemoryOpaqueCaptureAddressInfo`
pub type VkDeviceMemoryOpaqueCaptureAddressInfoKHR = VkDeviceMemoryOpaqueCaptureAddressInfo;

/// `VkDeviceMemoryOverallocationCreateInfoAMD`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDeviceMemoryOverallocationCreateInfoAMD {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub overallocationBehavior: VkMemoryOverallocationBehaviorAMD,
}
impl_default_zeroed_with_s_type!(VkDeviceMemoryOverallocationCreateInfoAMD : VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD);
impl_extends!(VkDeviceMemoryOverallocationCreateInfoAMD : VkDeviceCreateInfo);

/// `VkDeviceMemoryReportCallbackDataEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDeviceMemoryReportCallbackDataEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub flags: VkDeviceMemoryReportFlagsEXT,
    pub r#type: VkDeviceMemoryReportEventTypeEXT,
    pub memoryObjectId: uint64_t,
    pub size: VkDeviceSize,
    pub objectType: VkObjectType,
    pub objectHandle: uint64_t,
    pub heapIndex: uint32_t,
}
impl_default_zeroed_with_s_type!(VkDeviceMemoryReportCallbackDataEXT : VK_STRUCTURE_TYPE_DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT);

from_into_transparent!(VkDeviceMemoryReportEventTypeEXT: i32);
/// `VkDeviceMemoryReportEventTypeEXT`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkDeviceMemoryReportEventTypeEXT(pub i32);

/// `0`  
pub const VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_ALLOCATE_EXT: VkDeviceMemoryReportEventTypeEXT = VkDeviceMemoryReportEventTypeEXT(0);
/// `1`  
pub const VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_FREE_EXT: VkDeviceMemoryReportEventTypeEXT = VkDeviceMemoryReportEventTypeEXT(1);
/// `2`  
pub const VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_IMPORT_EXT: VkDeviceMemoryReportEventTypeEXT = VkDeviceMemoryReportEventTypeEXT(2);
/// `3`  
pub const VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_UNIMPORT_EXT: VkDeviceMemoryReportEventTypeEXT = VkDeviceMemoryReportEventTypeEXT(3);
/// `4`  
pub const VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_ALLOCATION_FAILED_EXT: VkDeviceMemoryReportEventTypeEXT = VkDeviceMemoryReportEventTypeEXT(4);

impl_enum_display!(VkDeviceMemoryReportEventTypeEXT { VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_ALLOCATE_EXT, VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_FREE_EXT, VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_IMPORT_EXT, VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_UNIMPORT_EXT, VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_ALLOCATION_FAILED_EXT });

flags!(VkDeviceMemoryReportFlagsEXT);
from_into_transparent!(VkDeviceMemoryReportFlagsEXT: i32);
/// `VkDeviceMemoryReportFlagsEXT`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkDeviceMemoryReportFlagsEXT(pub i32);

impl_flags_display!(VkDeviceMemoryReportFlagsEXT {  });

/// `VkDeviceObjectReservationCreateInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDeviceObjectReservationCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub pipelineCacheCreateInfoCount: uint32_t,
    pub pPipelineCacheCreateInfos: *const VkPipelineCacheCreateInfo,
    pub pipelinePoolSizeCount: uint32_t,
    pub pPipelinePoolSizes: *const VkPipelinePoolSize,
    pub semaphoreRequestCount: uint32_t,
    pub commandBufferRequestCount: uint32_t,
    pub fenceRequestCount: uint32_t,
    pub deviceMemoryRequestCount: uint32_t,
    pub bufferRequestCount: uint32_t,
    pub imageRequestCount: uint32_t,
    pub eventRequestCount: uint32_t,
    pub queryPoolRequestCount: uint32_t,
    pub bufferViewRequestCount: uint32_t,
    pub imageViewRequestCount: uint32_t,
    pub layeredImageViewRequestCount: uint32_t,
    pub pipelineCacheRequestCount: uint32_t,
    pub pipelineLayoutRequestCount: uint32_t,
    pub renderPassRequestCount: uint32_t,
    pub graphicsPipelineRequestCount: uint32_t,
    pub computePipelineRequestCount: uint32_t,
    pub descriptorSetLayoutRequestCount: uint32_t,
    pub samplerRequestCount: uint32_t,
    pub descriptorPoolRequestCount: uint32_t,
    pub descriptorSetRequestCount: uint32_t,
    pub framebufferRequestCount: uint32_t,
    pub commandPoolRequestCount: uint32_t,
    pub samplerYcbcrConversionRequestCount: uint32_t,
    pub surfaceRequestCount: uint32_t,
    pub swapchainRequestCount: uint32_t,
    pub displayModeRequestCount: uint32_t,
    pub subpassDescriptionRequestCount: uint32_t,
    pub attachmentDescriptionRequestCount: uint32_t,
    pub descriptorSetLayoutBindingRequestCount: uint32_t,
    pub descriptorSetLayoutBindingLimit: uint32_t,
    pub maxImageViewMipLevels: uint32_t,
    pub maxImageViewArrayLayers: uint32_t,
    pub maxLayeredImageViewMipLevels: uint32_t,
    pub maxOcclusionQueriesPerPool: uint32_t,
    pub maxPipelineStatisticsQueriesPerPool: uint32_t,
    pub maxTimestampQueriesPerPool: uint32_t,
    pub maxImmutableSamplersPerDescriptorSetLayout: uint32_t,
}
impl_default_zeroed_with_s_type!(VkDeviceObjectReservationCreateInfo : VK_STRUCTURE_TYPE_DEVICE_OBJECT_RESERVATION_CREATE_INFO);
impl_extends!(VkDeviceObjectReservationCreateInfo : VkDeviceCreateInfo);

/// `VkDeviceOrHostAddressConstAMDX`
#[repr(C)]
#[derive(Clone, Copy)]
pub union VkDeviceOrHostAddressConstAMDX {
    pub deviceAddress: VkDeviceAddress,
    pub hostAddress: *const void,
}
impl_debug_for_union!(VkDeviceOrHostAddressConstAMDX);
impl_default_zeroed!(VkDeviceOrHostAddressConstAMDX);

/// `VkDeviceOrHostAddressConstKHR`
#[repr(C)]
#[derive(Clone, Copy)]
pub union VkDeviceOrHostAddressConstKHR {
    pub deviceAddress: VkDeviceAddress,
    pub hostAddress: *const void,
}
impl_debug_for_union!(VkDeviceOrHostAddressConstKHR);
impl_default_zeroed!(VkDeviceOrHostAddressConstKHR);

/// `VkDeviceOrHostAddressKHR`
#[repr(C)]
#[derive(Clone, Copy)]
pub union VkDeviceOrHostAddressKHR {
    pub deviceAddress: VkDeviceAddress,
    pub hostAddress: *mut void,
}
impl_debug_for_union!(VkDeviceOrHostAddressKHR);
impl_default_zeroed!(VkDeviceOrHostAddressKHR);

/// `VkDevicePipelineBinaryInternalCacheControlKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDevicePipelineBinaryInternalCacheControlKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub disableInternalCache: VkBool32,
}
impl_default_zeroed_with_s_type!(VkDevicePipelineBinaryInternalCacheControlKHR : VK_STRUCTURE_TYPE_DEVICE_PIPELINE_BINARY_INTERNAL_CACHE_CONTROL_KHR);
impl_extends!(VkDevicePipelineBinaryInternalCacheControlKHR : VkDeviceCreateInfo);

/// `VkDevicePrivateDataCreateInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDevicePrivateDataCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub privateDataSlotRequestCount: uint32_t,
}
impl_default_zeroed_with_s_type!(VkDevicePrivateDataCreateInfo : VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO);
impl_extends!(VkDevicePrivateDataCreateInfo : VkDeviceCreateInfo);

/// `VkDevicePrivateDataCreateInfo`
pub type VkDevicePrivateDataCreateInfoEXT = VkDevicePrivateDataCreateInfo;

flags!(VkDeviceQueueCreateFlags);
from_into_transparent!(VkDeviceQueueCreateFlags: i32);
/// `VkDeviceQueueCreateFlags`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkDeviceQueueCreateFlags(pub i32);

/// `1 << 0`  
/// 
/// Queue is a protected-capable device queue
pub const VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT: VkDeviceQueueCreateFlags = VkDeviceQueueCreateFlags(1 << 0);
/// `1 << 1`  
pub const VK_DEVICE_QUEUE_CREATE_RESERVED_1_BIT_QCOM: VkDeviceQueueCreateFlags = VkDeviceQueueCreateFlags(1 << 1);
/// `1 << 2`  
pub const VK_DEVICE_QUEUE_CREATE_INTERNALLY_SYNCHRONIZED_BIT_KHR: VkDeviceQueueCreateFlags = VkDeviceQueueCreateFlags(1 << 2);

impl_flags_display!(VkDeviceQueueCreateFlags { VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT, VK_DEVICE_QUEUE_CREATE_RESERVED_1_BIT_QCOM, VK_DEVICE_QUEUE_CREATE_INTERNALLY_SYNCHRONIZED_BIT_KHR });

/// `VkDeviceQueueCreateInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDeviceQueueCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub flags: VkDeviceQueueCreateFlags,
    pub queueFamilyIndex: uint32_t,
    pub queueCount: uint32_t,
    pub pQueuePriorities: *const float,
}
impl_default_zeroed_with_s_type!(VkDeviceQueueCreateInfo : VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO);

/// `VkDeviceQueueGlobalPriorityCreateInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDeviceQueueGlobalPriorityCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub globalPriority: VkQueueGlobalPriority,
}
impl_default_zeroed_with_s_type!(VkDeviceQueueGlobalPriorityCreateInfo : VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO);
impl_extends!(VkDeviceQueueGlobalPriorityCreateInfo : VkDeviceQueueCreateInfo);

/// `VkDeviceQueueGlobalPriorityCreateInfo`
pub type VkDeviceQueueGlobalPriorityCreateInfoEXT = VkDeviceQueueGlobalPriorityCreateInfo;

/// `VkDeviceQueueGlobalPriorityCreateInfo`
pub type VkDeviceQueueGlobalPriorityCreateInfoKHR = VkDeviceQueueGlobalPriorityCreateInfo;

/// `VkDeviceQueueInfo2`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDeviceQueueInfo2 {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub flags: VkDeviceQueueCreateFlags,
    pub queueFamilyIndex: uint32_t,
    pub queueIndex: uint32_t,
}
impl_default_zeroed_with_s_type!(VkDeviceQueueInfo2 : VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2);

/// `VkDeviceQueueShaderCoreControlCreateInfoARM`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDeviceQueueShaderCoreControlCreateInfoARM {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub shaderCoreCount: uint32_t,
}
impl_default_zeroed_with_s_type!(VkDeviceQueueShaderCoreControlCreateInfoARM : VK_STRUCTURE_TYPE_DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM);
impl_extends!(VkDeviceQueueShaderCoreControlCreateInfoARM : VkDeviceQueueCreateInfo, VkDeviceCreateInfo);

/// `VkDeviceSemaphoreSciSyncPoolReservationCreateInfoNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDeviceSemaphoreSciSyncPoolReservationCreateInfoNV {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub semaphoreSciSyncPoolRequestCount: uint32_t,
}
impl_default_zeroed_with_s_type!(VkDeviceSemaphoreSciSyncPoolReservationCreateInfoNV : VK_STRUCTURE_TYPE_DEVICE_SEMAPHORE_SCI_SYNC_POOL_RESERVATION_CREATE_INFO_NV);
impl_extends!(VkDeviceSemaphoreSciSyncPoolReservationCreateInfoNV : VkDeviceCreateInfo);

/// `VkDeviceTensorMemoryRequirementsARM`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDeviceTensorMemoryRequirementsARM {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub pCreateInfo: *const VkTensorCreateInfoARM,
}
impl_default_zeroed_with_s_type!(VkDeviceTensorMemoryRequirementsARM : VK_STRUCTURE_TYPE_DEVICE_TENSOR_MEMORY_REQUIREMENTS_ARM);

flags!(VkDirectDriverLoadingFlagsLUNARG);
from_into_transparent!(VkDirectDriverLoadingFlagsLUNARG: i32);
/// `VkDirectDriverLoadingFlagsLUNARG`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkDirectDriverLoadingFlagsLUNARG(pub i32);

impl_flags_display!(VkDirectDriverLoadingFlagsLUNARG {  });

/// `VkDirectDriverLoadingInfoLUNARG`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDirectDriverLoadingInfoLUNARG {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub flags: VkDirectDriverLoadingFlagsLUNARG,
    pub pfnGetInstanceProcAddr: PFN_vkGetInstanceProcAddrLUNARG,
}
impl_default_zeroed_with_s_type!(VkDirectDriverLoadingInfoLUNARG : VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_INFO_LUNARG);

/// `VkDirectDriverLoadingListLUNARG`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDirectDriverLoadingListLUNARG {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub mode: VkDirectDriverLoadingModeLUNARG,
    pub driverCount: uint32_t,
    pub pDrivers: *const VkDirectDriverLoadingInfoLUNARG,
}
impl_default_zeroed_with_s_type!(VkDirectDriverLoadingListLUNARG : VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_LIST_LUNARG);
impl_extends!(VkDirectDriverLoadingListLUNARG : VkInstanceCreateInfo);

from_into_transparent!(VkDirectDriverLoadingModeLUNARG: i32);
/// `VkDirectDriverLoadingModeLUNARG`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkDirectDriverLoadingModeLUNARG(pub i32);

/// `0`  
pub const VK_DIRECT_DRIVER_LOADING_MODE_EXCLUSIVE_LUNARG: VkDirectDriverLoadingModeLUNARG = VkDirectDriverLoadingModeLUNARG(0);
/// `1`  
pub const VK_DIRECT_DRIVER_LOADING_MODE_INCLUSIVE_LUNARG: VkDirectDriverLoadingModeLUNARG = VkDirectDriverLoadingModeLUNARG(1);

impl_enum_display!(VkDirectDriverLoadingModeLUNARG { VK_DIRECT_DRIVER_LOADING_MODE_EXCLUSIVE_LUNARG, VK_DIRECT_DRIVER_LOADING_MODE_INCLUSIVE_LUNARG });

flags!(VkDirectFBSurfaceCreateFlagsEXT);
from_into_transparent!(VkDirectFBSurfaceCreateFlagsEXT: i32);
/// `VkDirectFBSurfaceCreateFlagsEXT`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkDirectFBSurfaceCreateFlagsEXT(pub i32);

impl_flags_display!(VkDirectFBSurfaceCreateFlagsEXT {  });

/// `VkDirectFBSurfaceCreateInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDirectFBSurfaceCreateInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub flags: VkDirectFBSurfaceCreateFlagsEXT,
    pub dfb: *mut IDirectFB,
    pub surface: *mut IDirectFBSurface,
}
impl_default_zeroed_with_s_type!(VkDirectFBSurfaceCreateInfoEXT : VK_STRUCTURE_TYPE_DIRECTFB_SURFACE_CREATE_INFO_EXT);

from_into_transparent!(VkDiscardRectangleModeEXT: i32);
/// `VkDiscardRectangleModeEXT`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkDiscardRectangleModeEXT(pub i32);

/// `0`  
pub const VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT: VkDiscardRectangleModeEXT = VkDiscardRectangleModeEXT(0);
/// `1`  
pub const VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT: VkDiscardRectangleModeEXT = VkDiscardRectangleModeEXT(1);

impl_enum_display!(VkDiscardRectangleModeEXT { VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT, VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT });

/// `VkDispatchGraphCountInfoAMDX`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDispatchGraphCountInfoAMDX {
    pub count: uint32_t,
    pub infos: VkDeviceOrHostAddressConstAMDX,
    pub stride: uint64_t,
}
impl_default_zeroed!(VkDispatchGraphCountInfoAMDX);

/// `VkDispatchGraphInfoAMDX`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDispatchGraphInfoAMDX {
    pub nodeIndex: uint32_t,
    pub payloadCount: uint32_t,
    pub payloads: VkDeviceOrHostAddressConstAMDX,
    pub payloadStride: uint64_t,
}
impl_default_zeroed!(VkDispatchGraphInfoAMDX);

/// `VkDispatchIndirectCommand`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDispatchIndirectCommand {
    pub x: uint32_t,
    pub y: uint32_t,
    pub z: uint32_t,
}
impl_default_zeroed!(VkDispatchIndirectCommand);

/// `VkDispatchTileInfoQCOM`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDispatchTileInfoQCOM {
    pub sType: VkStructureType,
    pub pNext: *const void,
}
impl_default_zeroed_with_s_type!(VkDispatchTileInfoQCOM : VK_STRUCTURE_TYPE_DISPATCH_TILE_INFO_QCOM);

from_into_transparent!(VkDisplacementMicromapFormatNV: i32);
/// `VkDisplacementMicromapFormatNV`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkDisplacementMicromapFormatNV(pub i32);

/// `1`  
pub const VK_DISPLACEMENT_MICROMAP_FORMAT_64_TRIANGLES_64_BYTES_NV: VkDisplacementMicromapFormatNV = VkDisplacementMicromapFormatNV(1);
/// `2`  
pub const VK_DISPLACEMENT_MICROMAP_FORMAT_256_TRIANGLES_128_BYTES_NV: VkDisplacementMicromapFormatNV = VkDisplacementMicromapFormatNV(2);
/// `3`  
pub const VK_DISPLACEMENT_MICROMAP_FORMAT_1024_TRIANGLES_128_BYTES_NV: VkDisplacementMicromapFormatNV = VkDisplacementMicromapFormatNV(3);

impl_enum_display!(VkDisplacementMicromapFormatNV { VK_DISPLACEMENT_MICROMAP_FORMAT_64_TRIANGLES_64_BYTES_NV, VK_DISPLACEMENT_MICROMAP_FORMAT_256_TRIANGLES_128_BYTES_NV, VK_DISPLACEMENT_MICROMAP_FORMAT_1024_TRIANGLES_128_BYTES_NV });

/// `VkDisplayEventInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDisplayEventInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub displayEvent: VkDisplayEventTypeEXT,
}
impl_default_zeroed_with_s_type!(VkDisplayEventInfoEXT : VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT);

from_into_transparent!(VkDisplayEventTypeEXT: i32);
/// `VkDisplayEventTypeEXT`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkDisplayEventTypeEXT(pub i32);

/// `0`  
pub const VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT: VkDisplayEventTypeEXT = VkDisplayEventTypeEXT(0);

impl_enum_display!(VkDisplayEventTypeEXT { VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT });

/// `VkDisplayKHR` : `VkPhysicalDevice`
#[repr(transparent)]
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkDisplayKHR(pub u64);
from_into_transparent!(VkDisplayKHR: u64);
impl_handle!(VkDisplayKHR: VK_OBJECT_TYPE_DISPLAY_KHR; SubHandle = VkPhysicalDevice);

flags!(VkDisplayModeCreateFlagsKHR);
from_into_transparent!(VkDisplayModeCreateFlagsKHR: i32);
/// `VkDisplayModeCreateFlagsKHR`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkDisplayModeCreateFlagsKHR(pub i32);

impl_flags_display!(VkDisplayModeCreateFlagsKHR {  });

/// `VkDisplayModeCreateInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDisplayModeCreateInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub flags: VkDisplayModeCreateFlagsKHR,
    /// The parameters this mode uses.
    pub parameters: VkDisplayModeParametersKHR,
}
impl_default_zeroed_with_s_type!(VkDisplayModeCreateInfoKHR : VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR);

/// `VkDisplayModeKHR` : `VkDisplayKHR`
#[repr(transparent)]
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkDisplayModeKHR(pub u64);
from_into_transparent!(VkDisplayModeKHR: u64);
impl_handle!(VkDisplayModeKHR: VK_OBJECT_TYPE_DISPLAY_MODE_KHR; SubHandle = VkDisplayKHR);

/// `VkDisplayModeParametersKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDisplayModeParametersKHR {
    /// Visible scanout region.
    pub visibleRegion: VkExtent2D,
    /// Number of times per second the display is updated.
    pub refreshRate: uint32_t,
}
impl_default_zeroed!(VkDisplayModeParametersKHR);

/// `VkDisplayModeProperties2KHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDisplayModeProperties2KHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub displayModeProperties: VkDisplayModePropertiesKHR,
}
impl_default_zeroed_with_s_type!(VkDisplayModeProperties2KHR : VK_STRUCTURE_TYPE_DISPLAY_MODE_PROPERTIES_2_KHR);

/// `VkDisplayModePropertiesKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDisplayModePropertiesKHR {
    /// Handle of this display mode.
    pub displayMode: VkDisplayModeKHR,
    /// The parameters this mode uses.
    pub parameters: VkDisplayModeParametersKHR,
}
impl_default_zeroed!(VkDisplayModePropertiesKHR);

/// `VkDisplayModeStereoPropertiesNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDisplayModeStereoPropertiesNV {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    /// Whether this mode supports HDMI 3D stereo rendering.
    pub hdmi3DSupported: VkBool32,
}
impl_default_zeroed_with_s_type!(VkDisplayModeStereoPropertiesNV : VK_STRUCTURE_TYPE_DISPLAY_MODE_STEREO_PROPERTIES_NV);
impl_extends!(VkDisplayModeStereoPropertiesNV : VkDisplayModeProperties2KHR);

/// `VkDisplayNativeHdrSurfaceCapabilitiesAMD`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDisplayNativeHdrSurfaceCapabilitiesAMD {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub localDimmingSupport: VkBool32,
}
impl_default_zeroed_with_s_type!(VkDisplayNativeHdrSurfaceCapabilitiesAMD : VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD);
impl_extends!(VkDisplayNativeHdrSurfaceCapabilitiesAMD : VkSurfaceCapabilities2KHR);

flags!(VkDisplayPlaneAlphaFlagsKHR);
from_into_transparent!(VkDisplayPlaneAlphaFlagsKHR: i32);
/// `VkDisplayPlaneAlphaFlagsKHR`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkDisplayPlaneAlphaFlagsKHR(pub i32);

/// `1 << 0`  
pub const VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR: VkDisplayPlaneAlphaFlagsKHR = VkDisplayPlaneAlphaFlagsKHR(1 << 0);
/// `1 << 1`  
pub const VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR: VkDisplayPlaneAlphaFlagsKHR = VkDisplayPlaneAlphaFlagsKHR(1 << 1);
/// `1 << 2`  
pub const VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR: VkDisplayPlaneAlphaFlagsKHR = VkDisplayPlaneAlphaFlagsKHR(1 << 2);
/// `1 << 3`  
pub const VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR: VkDisplayPlaneAlphaFlagsKHR = VkDisplayPlaneAlphaFlagsKHR(1 << 3);

impl_flags_display!(VkDisplayPlaneAlphaFlagsKHR { VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR, VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR, VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR, VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR });

/// `VkDisplayPlaneCapabilities2KHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDisplayPlaneCapabilities2KHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub capabilities: VkDisplayPlaneCapabilitiesKHR,
}
impl_default_zeroed_with_s_type!(VkDisplayPlaneCapabilities2KHR : VK_STRUCTURE_TYPE_DISPLAY_PLANE_CAPABILITIES_2_KHR);

/// `VkDisplayPlaneCapabilitiesKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDisplayPlaneCapabilitiesKHR {
    /// Types of alpha blending supported, if any.
    pub supportedAlpha: VkDisplayPlaneAlphaFlagsKHR,
    /// Does the plane have any position and extent restrictions?
    pub minSrcPosition: VkOffset2D,
    pub maxSrcPosition: VkOffset2D,
    pub minSrcExtent: VkExtent2D,
    pub maxSrcExtent: VkExtent2D,
    pub minDstPosition: VkOffset2D,
    pub maxDstPosition: VkOffset2D,
    pub minDstExtent: VkExtent2D,
    pub maxDstExtent: VkExtent2D,
}
impl_default_zeroed!(VkDisplayPlaneCapabilitiesKHR);

/// `VkDisplayPlaneInfo2KHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDisplayPlaneInfo2KHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub mode: VkDisplayModeKHR,
    pub planeIndex: uint32_t,
}
impl_default_zeroed_with_s_type!(VkDisplayPlaneInfo2KHR : VK_STRUCTURE_TYPE_DISPLAY_PLANE_INFO_2_KHR);

/// `VkDisplayPlaneProperties2KHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDisplayPlaneProperties2KHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub displayPlaneProperties: VkDisplayPlanePropertiesKHR,
}
impl_default_zeroed_with_s_type!(VkDisplayPlaneProperties2KHR : VK_STRUCTURE_TYPE_DISPLAY_PLANE_PROPERTIES_2_KHR);

/// `VkDisplayPlanePropertiesKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDisplayPlanePropertiesKHR {
    /// Display the plane is currently associated with.  Will be VK_NULL_HANDLE if the plane is not in use.
    pub currentDisplay: VkDisplayKHR,
    /// Current z-order of the plane.
    pub currentStackIndex: uint32_t,
}
impl_default_zeroed!(VkDisplayPlanePropertiesKHR);

/// `VkDisplayPowerInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDisplayPowerInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub powerState: VkDisplayPowerStateEXT,
}
impl_default_zeroed_with_s_type!(VkDisplayPowerInfoEXT : VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT);

from_into_transparent!(VkDisplayPowerStateEXT: i32);
/// `VkDisplayPowerStateEXT`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkDisplayPowerStateEXT(pub i32);

/// `0`  
pub const VK_DISPLAY_POWER_STATE_OFF_EXT: VkDisplayPowerStateEXT = VkDisplayPowerStateEXT(0);
/// `1`  
pub const VK_DISPLAY_POWER_STATE_SUSPEND_EXT: VkDisplayPowerStateEXT = VkDisplayPowerStateEXT(1);
/// `2`  
pub const VK_DISPLAY_POWER_STATE_ON_EXT: VkDisplayPowerStateEXT = VkDisplayPowerStateEXT(2);

impl_enum_display!(VkDisplayPowerStateEXT { VK_DISPLAY_POWER_STATE_OFF_EXT, VK_DISPLAY_POWER_STATE_SUSPEND_EXT, VK_DISPLAY_POWER_STATE_ON_EXT });

/// `VkDisplayPresentInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDisplayPresentInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    /// Rectangle within the presentable image to read pixel data from when presenting to the display.
    pub srcRect: VkRect2D,
    /// Rectangle within the current display mode's visible region to display srcRectangle in.
    pub dstRect: VkRect2D,
    /// For smart displays, use buffered mode.  If the display properties member "persistentMode" is VK_FALSE, this member must always be VK_FALSE.
    pub persistent: VkBool32,
}
impl_default_zeroed_with_s_type!(VkDisplayPresentInfoKHR : VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR);
impl_extends!(VkDisplayPresentInfoKHR : VkPresentInfoKHR);

/// `VkDisplayProperties2KHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDisplayProperties2KHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub displayProperties: VkDisplayPropertiesKHR,
}
impl_default_zeroed_with_s_type!(VkDisplayProperties2KHR : VK_STRUCTURE_TYPE_DISPLAY_PROPERTIES_2_KHR);

/// `VkDisplayPropertiesKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDisplayPropertiesKHR {
    /// Handle of the display object
    pub display: VkDisplayKHR,
    /// Name of the display
    pub displayName: *const c_char,
    /// In millimeters?
    pub physicalDimensions: VkExtent2D,
    /// Max resolution for CRT?
    pub physicalResolution: VkExtent2D,
    /// one or more bits from VkSurfaceTransformFlagsKHR
    pub supportedTransforms: VkSurfaceTransformFlagsKHR,
    /// VK_TRUE if the overlay plane's z-order can be changed on this display.
    pub planeReorderPossible: VkBool32,
    /// VK_TRUE if this is a "smart" display that supports self-refresh/internal buffering.
    pub persistentContent: VkBool32,
}
impl_default_zeroed!(VkDisplayPropertiesKHR);

flags!(VkDisplaySurfaceCreateFlagsKHR);
from_into_transparent!(VkDisplaySurfaceCreateFlagsKHR: i32);
/// `VkDisplaySurfaceCreateFlagsKHR`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkDisplaySurfaceCreateFlagsKHR(pub i32);

impl_flags_display!(VkDisplaySurfaceCreateFlagsKHR {  });

/// `VkDisplaySurfaceCreateInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDisplaySurfaceCreateInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub flags: VkDisplaySurfaceCreateFlagsKHR,
    /// The mode to use when displaying this surface
    pub displayMode: VkDisplayModeKHR,
    /// The plane on which this surface appears.  Must be between 0 and the value returned by vkGetPhysicalDeviceDisplayPlanePropertiesKHR() in pPropertyCount.
    pub planeIndex: uint32_t,
    /// The z-order of the plane.
    pub planeStackIndex: uint32_t,
    /// Transform to apply to the images as part of the scanout operation
    pub transform: VkSurfaceTransformFlagsKHR,
    /// Global alpha value.  Must be between 0 and 1, inclusive.  Ignored if alphaMode is not VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR
    pub globalAlpha: float,
    /// The type of alpha blending to use. Must be one of the bits from VkDisplayPlaneCapabilitiesKHR::supportedAlpha for this display plane
    pub alphaMode: VkDisplayPlaneAlphaFlagsKHR,
    /// size of the images to use with this surface
    pub imageExtent: VkExtent2D,
}
impl_default_zeroed_with_s_type!(VkDisplaySurfaceCreateInfoKHR : VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR);

/// `VkDisplaySurfaceStereoCreateInfoNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDisplaySurfaceStereoCreateInfoNV {
    pub sType: VkStructureType,
    pub pNext: *const void,
    /// The 3D stereo type to use when presenting this surface.
    pub stereoType: VkDisplaySurfaceStereoTypeNV,
}
impl_default_zeroed_with_s_type!(VkDisplaySurfaceStereoCreateInfoNV : VK_STRUCTURE_TYPE_DISPLAY_SURFACE_STEREO_CREATE_INFO_NV);
impl_extends!(VkDisplaySurfaceStereoCreateInfoNV : VkDisplaySurfaceCreateInfoKHR);

from_into_transparent!(VkDisplaySurfaceStereoTypeNV: i32);
/// `VkDisplaySurfaceStereoTypeNV`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkDisplaySurfaceStereoTypeNV(pub i32);

/// `0`  
pub const VK_DISPLAY_SURFACE_STEREO_TYPE_NONE_NV: VkDisplaySurfaceStereoTypeNV = VkDisplaySurfaceStereoTypeNV(0);
/// `1`  
pub const VK_DISPLAY_SURFACE_STEREO_TYPE_ONBOARD_DIN_NV: VkDisplaySurfaceStereoTypeNV = VkDisplaySurfaceStereoTypeNV(1);
/// `2`  
pub const VK_DISPLAY_SURFACE_STEREO_TYPE_HDMI_3D_NV: VkDisplaySurfaceStereoTypeNV = VkDisplaySurfaceStereoTypeNV(2);
/// `3`  
pub const VK_DISPLAY_SURFACE_STEREO_TYPE_INBAND_DISPLAYPORT_NV: VkDisplaySurfaceStereoTypeNV = VkDisplaySurfaceStereoTypeNV(3);

impl_enum_display!(VkDisplaySurfaceStereoTypeNV { VK_DISPLAY_SURFACE_STEREO_TYPE_NONE_NV, VK_DISPLAY_SURFACE_STEREO_TYPE_ONBOARD_DIN_NV, VK_DISPLAY_SURFACE_STEREO_TYPE_HDMI_3D_NV, VK_DISPLAY_SURFACE_STEREO_TYPE_INBAND_DISPLAYPORT_NV });

/// `VkDrawIndexedIndirectCommand`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDrawIndexedIndirectCommand {
    pub indexCount: uint32_t,
    pub instanceCount: uint32_t,
    pub firstIndex: uint32_t,
    pub vertexOffset: int32_t,
    pub firstInstance: uint32_t,
}
impl_default_zeroed!(VkDrawIndexedIndirectCommand);

/// `VkDrawIndirectCommand`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDrawIndirectCommand {
    pub vertexCount: uint32_t,
    pub instanceCount: uint32_t,
    pub firstVertex: uint32_t,
    pub firstInstance: uint32_t,
}
impl_default_zeroed!(VkDrawIndirectCommand);

/// `VkDrawIndirectCountIndirectCommandEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDrawIndirectCountIndirectCommandEXT {
    pub bufferAddress: VkDeviceAddress,
    pub stride: uint32_t,
    pub commandCount: uint32_t,
}
impl_default_zeroed!(VkDrawIndirectCountIndirectCommandEXT);

/// `VkDrawMeshTasksIndirectCommandEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDrawMeshTasksIndirectCommandEXT {
    pub groupCountX: uint32_t,
    pub groupCountY: uint32_t,
    pub groupCountZ: uint32_t,
}
impl_default_zeroed!(VkDrawMeshTasksIndirectCommandEXT);

/// `VkDrawMeshTasksIndirectCommandNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDrawMeshTasksIndirectCommandNV {
    pub taskCount: uint32_t,
    pub firstTask: uint32_t,
}
impl_default_zeroed!(VkDrawMeshTasksIndirectCommandNV);

from_into_transparent!(VkDriverId: i32);
/// `VkDriverId`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkDriverId(pub i32);

/// `1`  
/// 
/// Advanced Micro Devices, Inc.
pub const VK_DRIVER_ID_AMD_PROPRIETARY: VkDriverId = VkDriverId(1);
/// `2`  
/// 
/// Advanced Micro Devices, Inc.
pub const VK_DRIVER_ID_AMD_OPEN_SOURCE: VkDriverId = VkDriverId(2);
/// `3`  
/// 
/// Mesa open source project
pub const VK_DRIVER_ID_MESA_RADV: VkDriverId = VkDriverId(3);
/// `4`  
/// 
/// NVIDIA Corporation
pub const VK_DRIVER_ID_NVIDIA_PROPRIETARY: VkDriverId = VkDriverId(4);
/// `5`  
/// 
/// Intel Corporation
pub const VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS: VkDriverId = VkDriverId(5);
/// `6`  
/// 
/// Intel Corporation
pub const VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA: VkDriverId = VkDriverId(6);
/// `7`  
/// 
/// Imagination Technologies
pub const VK_DRIVER_ID_IMAGINATION_PROPRIETARY: VkDriverId = VkDriverId(7);
/// `8`  
/// 
/// Qualcomm Technologies, Inc.
pub const VK_DRIVER_ID_QUALCOMM_PROPRIETARY: VkDriverId = VkDriverId(8);
/// `9`  
/// 
/// Arm Limited
pub const VK_DRIVER_ID_ARM_PROPRIETARY: VkDriverId = VkDriverId(9);
/// `10`  
/// 
/// Google LLC
pub const VK_DRIVER_ID_GOOGLE_SWIFTSHADER: VkDriverId = VkDriverId(10);
/// `11`  
/// 
/// Google LLC
pub const VK_DRIVER_ID_GGP_PROPRIETARY: VkDriverId = VkDriverId(11);
/// `12`  
/// 
/// Broadcom Inc.
pub const VK_DRIVER_ID_BROADCOM_PROPRIETARY: VkDriverId = VkDriverId(12);
/// `13`  
/// 
/// Mesa
pub const VK_DRIVER_ID_MESA_LLVMPIPE: VkDriverId = VkDriverId(13);
/// `14`  
/// 
/// MoltenVK
pub const VK_DRIVER_ID_MOLTENVK: VkDriverId = VkDriverId(14);
/// `15`  
/// 
/// Core Avionics & Industrial Inc.
pub const VK_DRIVER_ID_COREAVI_PROPRIETARY: VkDriverId = VkDriverId(15);
/// `16`  
/// 
/// Juice Technologies, Inc.
pub const VK_DRIVER_ID_JUICE_PROPRIETARY: VkDriverId = VkDriverId(16);
/// `17`  
/// 
/// Verisilicon, Inc.
pub const VK_DRIVER_ID_VERISILICON_PROPRIETARY: VkDriverId = VkDriverId(17);
/// `18`  
/// 
/// Mesa open source project
pub const VK_DRIVER_ID_MESA_TURNIP: VkDriverId = VkDriverId(18);
/// `19`  
/// 
/// Mesa open source project
pub const VK_DRIVER_ID_MESA_V3DV: VkDriverId = VkDriverId(19);
/// `20`  
/// 
/// Mesa open source project
pub const VK_DRIVER_ID_MESA_PANVK: VkDriverId = VkDriverId(20);
/// `21`  
/// 
/// Samsung Electronics Co., Ltd.
pub const VK_DRIVER_ID_SAMSUNG_PROPRIETARY: VkDriverId = VkDriverId(21);
/// `22`  
/// 
/// Mesa open source project
pub const VK_DRIVER_ID_MESA_VENUS: VkDriverId = VkDriverId(22);
/// `23`  
/// 
/// Mesa open source project
pub const VK_DRIVER_ID_MESA_DOZEN: VkDriverId = VkDriverId(23);
/// `24`  
/// 
/// Mesa open source project
pub const VK_DRIVER_ID_MESA_NVK: VkDriverId = VkDriverId(24);
/// `25`  
/// 
/// Imagination Technologies
pub const VK_DRIVER_ID_IMAGINATION_OPEN_SOURCE_MESA: VkDriverId = VkDriverId(25);
/// `26`  
/// 
/// Mesa open source project
pub const VK_DRIVER_ID_MESA_HONEYKRISP: VkDriverId = VkDriverId(26);
/// `27`  
/// 
/// Vulkan SC Emulation on Vulkan
pub const VK_DRIVER_ID_VULKAN_SC_EMULATION_ON_VULKAN: VkDriverId = VkDriverId(27);
/// `28`  
/// 
/// Mesa open source project
pub const VK_DRIVER_ID_MESA_KOSMICKRISP: VkDriverId = VkDriverId(28);
/// `VK_DRIVER_ID_AMD_PROPRIETARY`  
pub const VK_DRIVER_ID_AMD_PROPRIETARY_KHR: VkDriverId = VK_DRIVER_ID_AMD_PROPRIETARY;
/// `VK_DRIVER_ID_AMD_OPEN_SOURCE`  
pub const VK_DRIVER_ID_AMD_OPEN_SOURCE_KHR: VkDriverId = VK_DRIVER_ID_AMD_OPEN_SOURCE;
/// `VK_DRIVER_ID_MESA_RADV`  
pub const VK_DRIVER_ID_MESA_RADV_KHR: VkDriverId = VK_DRIVER_ID_MESA_RADV;
/// `VK_DRIVER_ID_NVIDIA_PROPRIETARY`  
pub const VK_DRIVER_ID_NVIDIA_PROPRIETARY_KHR: VkDriverId = VK_DRIVER_ID_NVIDIA_PROPRIETARY;
/// `VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS`  
pub const VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS_KHR: VkDriverId = VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS;
/// `VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA`  
pub const VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA_KHR: VkDriverId = VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA;
/// `VK_DRIVER_ID_IMAGINATION_PROPRIETARY`  
pub const VK_DRIVER_ID_IMAGINATION_PROPRIETARY_KHR: VkDriverId = VK_DRIVER_ID_IMAGINATION_PROPRIETARY;
/// `VK_DRIVER_ID_QUALCOMM_PROPRIETARY`  
pub const VK_DRIVER_ID_QUALCOMM_PROPRIETARY_KHR: VkDriverId = VK_DRIVER_ID_QUALCOMM_PROPRIETARY;
/// `VK_DRIVER_ID_ARM_PROPRIETARY`  
pub const VK_DRIVER_ID_ARM_PROPRIETARY_KHR: VkDriverId = VK_DRIVER_ID_ARM_PROPRIETARY;
/// `VK_DRIVER_ID_GOOGLE_SWIFTSHADER`  
pub const VK_DRIVER_ID_GOOGLE_SWIFTSHADER_KHR: VkDriverId = VK_DRIVER_ID_GOOGLE_SWIFTSHADER;
/// `VK_DRIVER_ID_GGP_PROPRIETARY`  
pub const VK_DRIVER_ID_GGP_PROPRIETARY_KHR: VkDriverId = VK_DRIVER_ID_GGP_PROPRIETARY;
/// `VK_DRIVER_ID_BROADCOM_PROPRIETARY`  
pub const VK_DRIVER_ID_BROADCOM_PROPRIETARY_KHR: VkDriverId = VK_DRIVER_ID_BROADCOM_PROPRIETARY;

impl_enum_display!(VkDriverId { VK_DRIVER_ID_AMD_PROPRIETARY, VK_DRIVER_ID_AMD_OPEN_SOURCE, VK_DRIVER_ID_MESA_RADV, VK_DRIVER_ID_NVIDIA_PROPRIETARY, VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS, VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA, VK_DRIVER_ID_IMAGINATION_PROPRIETARY, VK_DRIVER_ID_QUALCOMM_PROPRIETARY, VK_DRIVER_ID_ARM_PROPRIETARY, VK_DRIVER_ID_GOOGLE_SWIFTSHADER, VK_DRIVER_ID_GGP_PROPRIETARY, VK_DRIVER_ID_BROADCOM_PROPRIETARY, VK_DRIVER_ID_MESA_LLVMPIPE, VK_DRIVER_ID_MOLTENVK, VK_DRIVER_ID_COREAVI_PROPRIETARY, VK_DRIVER_ID_JUICE_PROPRIETARY, VK_DRIVER_ID_VERISILICON_PROPRIETARY, VK_DRIVER_ID_MESA_TURNIP, VK_DRIVER_ID_MESA_V3DV, VK_DRIVER_ID_MESA_PANVK, VK_DRIVER_ID_SAMSUNG_PROPRIETARY, VK_DRIVER_ID_MESA_VENUS, VK_DRIVER_ID_MESA_DOZEN, VK_DRIVER_ID_MESA_NVK, VK_DRIVER_ID_IMAGINATION_OPEN_SOURCE_MESA, VK_DRIVER_ID_MESA_HONEYKRISP, VK_DRIVER_ID_VULKAN_SC_EMULATION_ON_VULKAN, VK_DRIVER_ID_MESA_KOSMICKRISP, VK_DRIVER_ID_AMD_PROPRIETARY_KHR, VK_DRIVER_ID_AMD_OPEN_SOURCE_KHR, VK_DRIVER_ID_MESA_RADV_KHR, VK_DRIVER_ID_NVIDIA_PROPRIETARY_KHR, VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS_KHR, VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA_KHR, VK_DRIVER_ID_IMAGINATION_PROPRIETARY_KHR, VK_DRIVER_ID_QUALCOMM_PROPRIETARY_KHR, VK_DRIVER_ID_ARM_PROPRIETARY_KHR, VK_DRIVER_ID_GOOGLE_SWIFTSHADER_KHR, VK_DRIVER_ID_GGP_PROPRIETARY_KHR, VK_DRIVER_ID_BROADCOM_PROPRIETARY_KHR });

/// `VkDriverId`
pub type VkDriverIdKHR = VkDriverId;

/// `VkDrmFormatModifierProperties2EXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDrmFormatModifierProperties2EXT {
    pub drmFormatModifier: uint64_t,
    pub drmFormatModifierPlaneCount: uint32_t,
    pub drmFormatModifierTilingFeatures: VkFormatFeatureFlags2,
}
impl_default_zeroed!(VkDrmFormatModifierProperties2EXT);

/// `VkDrmFormatModifierPropertiesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDrmFormatModifierPropertiesEXT {
    pub drmFormatModifier: uint64_t,
    pub drmFormatModifierPlaneCount: uint32_t,
    pub drmFormatModifierTilingFeatures: VkFormatFeatureFlags,
}
impl_default_zeroed!(VkDrmFormatModifierPropertiesEXT);

/// `VkDrmFormatModifierPropertiesList2EXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDrmFormatModifierPropertiesList2EXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub drmFormatModifierCount: uint32_t,
    pub pDrmFormatModifierProperties: *mut VkDrmFormatModifierProperties2EXT,
}
impl_default_zeroed_with_s_type!(VkDrmFormatModifierPropertiesList2EXT : VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT);
impl_extends!(VkDrmFormatModifierPropertiesList2EXT : VkFormatProperties2);

/// `VkDrmFormatModifierPropertiesListEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkDrmFormatModifierPropertiesListEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub drmFormatModifierCount: uint32_t,
    pub pDrmFormatModifierProperties: *mut VkDrmFormatModifierPropertiesEXT,
}
impl_default_zeroed_with_s_type!(VkDrmFormatModifierPropertiesListEXT : VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT);
impl_extends!(VkDrmFormatModifierPropertiesListEXT : VkFormatProperties2);

from_into_transparent!(VkDynamicState: i32);
/// `VkDynamicState`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkDynamicState(pub i32);

/// `0`  
pub const VK_DYNAMIC_STATE_VIEWPORT: VkDynamicState = VkDynamicState(0);
/// `1`  
pub const VK_DYNAMIC_STATE_SCISSOR: VkDynamicState = VkDynamicState(1);
/// `2`  
pub const VK_DYNAMIC_STATE_LINE_WIDTH: VkDynamicState = VkDynamicState(2);
/// `3`  
pub const VK_DYNAMIC_STATE_DEPTH_BIAS: VkDynamicState = VkDynamicState(3);
/// `4`  
pub const VK_DYNAMIC_STATE_BLEND_CONSTANTS: VkDynamicState = VkDynamicState(4);
/// `5`  
pub const VK_DYNAMIC_STATE_DEPTH_BOUNDS: VkDynamicState = VkDynamicState(5);
/// `6`  
pub const VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK: VkDynamicState = VkDynamicState(6);
/// `7`  
pub const VK_DYNAMIC_STATE_STENCIL_WRITE_MASK: VkDynamicState = VkDynamicState(7);
/// `8`  
pub const VK_DYNAMIC_STATE_STENCIL_REFERENCE: VkDynamicState = VkDynamicState(8);
/// `1000267000`  
pub const VK_DYNAMIC_STATE_CULL_MODE: VkDynamicState = VkDynamicState(1000267000);
/// `1000267001`  
pub const VK_DYNAMIC_STATE_FRONT_FACE: VkDynamicState = VkDynamicState(1000267001);
/// `1000267002`  
pub const VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY: VkDynamicState = VkDynamicState(1000267002);
/// `1000267003`  
pub const VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT: VkDynamicState = VkDynamicState(1000267003);
/// `1000267004`  
pub const VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT: VkDynamicState = VkDynamicState(1000267004);
/// `1000267005`  
pub const VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE: VkDynamicState = VkDynamicState(1000267005);
/// `1000267006`  
pub const VK_DYNAMIC_STATE_DEPTH_TEST_ENABLE: VkDynamicState = VkDynamicState(1000267006);
/// `1000267007`  
pub const VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE: VkDynamicState = VkDynamicState(1000267007);
/// `1000267008`  
pub const VK_DYNAMIC_STATE_DEPTH_COMPARE_OP: VkDynamicState = VkDynamicState(1000267008);
/// `1000267009`  
pub const VK_DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE: VkDynamicState = VkDynamicState(1000267009);
/// `1000267010`  
pub const VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE: VkDynamicState = VkDynamicState(1000267010);
/// `1000267011`  
pub const VK_DYNAMIC_STATE_STENCIL_OP: VkDynamicState = VkDynamicState(1000267011);
/// `1000377001`  
pub const VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE: VkDynamicState = VkDynamicState(1000377001);
/// `1000377002`  
pub const VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE: VkDynamicState = VkDynamicState(1000377002);
/// `1000377004`  
pub const VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE: VkDynamicState = VkDynamicState(1000377004);
/// `1000259000`  
pub const VK_DYNAMIC_STATE_LINE_STIPPLE: VkDynamicState = VkDynamicState(1000259000);
/// `1000087000`  
pub const VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV: VkDynamicState = VkDynamicState(1000087000);
/// `1000099000`  
pub const VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT: VkDynamicState = VkDynamicState(1000099000);
/// `1000099001`  
pub const VK_DYNAMIC_STATE_DISCARD_RECTANGLE_ENABLE_EXT: VkDynamicState = VkDynamicState(1000099001);
/// `1000099002`  
pub const VK_DYNAMIC_STATE_DISCARD_RECTANGLE_MODE_EXT: VkDynamicState = VkDynamicState(1000099002);
/// `1000143000`  
pub const VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT: VkDynamicState = VkDynamicState(1000143000);
/// `1000347000`  
pub const VK_DYNAMIC_STATE_RAY_TRACING_PIPELINE_STACK_SIZE_KHR: VkDynamicState = VkDynamicState(1000347000);
/// `1000164004`  
pub const VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV: VkDynamicState = VkDynamicState(1000164004);
/// `1000164006`  
pub const VK_DYNAMIC_STATE_VIEWPORT_COARSE_SAMPLE_ORDER_NV: VkDynamicState = VkDynamicState(1000164006);
/// `1000205000`  
pub const VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_ENABLE_NV: VkDynamicState = VkDynamicState(1000205000);
/// `1000205001`  
pub const VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV: VkDynamicState = VkDynamicState(1000205001);
/// `1000226000`  
pub const VK_DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR: VkDynamicState = VkDynamicState(1000226000);
/// `VK_DYNAMIC_STATE_LINE_STIPPLE`  
pub const VK_DYNAMIC_STATE_LINE_STIPPLE_EXT: VkDynamicState = VK_DYNAMIC_STATE_LINE_STIPPLE;
/// `VK_DYNAMIC_STATE_CULL_MODE`  
pub const VK_DYNAMIC_STATE_CULL_MODE_EXT: VkDynamicState = VK_DYNAMIC_STATE_CULL_MODE;
/// `VK_DYNAMIC_STATE_FRONT_FACE`  
pub const VK_DYNAMIC_STATE_FRONT_FACE_EXT: VkDynamicState = VK_DYNAMIC_STATE_FRONT_FACE;
/// `VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY`  
pub const VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY_EXT: VkDynamicState = VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY;
/// `VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT`  
pub const VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT: VkDynamicState = VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT;
/// `VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT`  
pub const VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT_EXT: VkDynamicState = VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT;
/// `VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE`  
pub const VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE_EXT: VkDynamicState = VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE;
/// `VK_DYNAMIC_STATE_DEPTH_TEST_ENABLE`  
pub const VK_DYNAMIC_STATE_DEPTH_TEST_ENABLE_EXT: VkDynamicState = VK_DYNAMIC_STATE_DEPTH_TEST_ENABLE;
/// `VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE`  
pub const VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE_EXT: VkDynamicState = VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE;
/// `VK_DYNAMIC_STATE_DEPTH_COMPARE_OP`  
pub const VK_DYNAMIC_STATE_DEPTH_COMPARE_OP_EXT: VkDynamicState = VK_DYNAMIC_STATE_DEPTH_COMPARE_OP;
/// `VK_DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE`  
pub const VK_DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE_EXT: VkDynamicState = VK_DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE;
/// `VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE`  
pub const VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE_EXT: VkDynamicState = VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE;
/// `VK_DYNAMIC_STATE_STENCIL_OP`  
pub const VK_DYNAMIC_STATE_STENCIL_OP_EXT: VkDynamicState = VK_DYNAMIC_STATE_STENCIL_OP;
/// `1000352000`  
pub const VK_DYNAMIC_STATE_VERTEX_INPUT_EXT: VkDynamicState = VkDynamicState(1000352000);
/// `1000377000`  
/// 
/// Not promoted to 1.3
pub const VK_DYNAMIC_STATE_PATCH_CONTROL_POINTS_EXT: VkDynamicState = VkDynamicState(1000377000);
/// `VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE`  
pub const VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE_EXT: VkDynamicState = VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE;
/// `VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE`  
pub const VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE_EXT: VkDynamicState = VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE;
/// `1000377003`  
/// 
/// Not promoted to 1.3
pub const VK_DYNAMIC_STATE_LOGIC_OP_EXT: VkDynamicState = VkDynamicState(1000377003);
/// `VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE`  
pub const VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE_EXT: VkDynamicState = VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE;
/// `1000381000`  
pub const VK_DYNAMIC_STATE_COLOR_WRITE_ENABLE_EXT: VkDynamicState = VkDynamicState(1000381000);
/// `1000455003`  
pub const VK_DYNAMIC_STATE_DEPTH_CLAMP_ENABLE_EXT: VkDynamicState = VkDynamicState(1000455003);
/// `1000455004`  
pub const VK_DYNAMIC_STATE_POLYGON_MODE_EXT: VkDynamicState = VkDynamicState(1000455004);
/// `1000455005`  
pub const VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT: VkDynamicState = VkDynamicState(1000455005);
/// `1000455006`  
pub const VK_DYNAMIC_STATE_SAMPLE_MASK_EXT: VkDynamicState = VkDynamicState(1000455006);
/// `1000455007`  
pub const VK_DYNAMIC_STATE_ALPHA_TO_COVERAGE_ENABLE_EXT: VkDynamicState = VkDynamicState(1000455007);
/// `1000455008`  
pub const VK_DYNAMIC_STATE_ALPHA_TO_ONE_ENABLE_EXT: VkDynamicState = VkDynamicState(1000455008);
/// `1000455009`  
pub const VK_DYNAMIC_STATE_LOGIC_OP_ENABLE_EXT: VkDynamicState = VkDynamicState(1000455009);
/// `1000455010`  
pub const VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT: VkDynamicState = VkDynamicState(1000455010);
/// `1000455011`  
pub const VK_DYNAMIC_STATE_COLOR_BLEND_EQUATION_EXT: VkDynamicState = VkDynamicState(1000455011);
/// `1000455012`  
pub const VK_DYNAMIC_STATE_COLOR_WRITE_MASK_EXT: VkDynamicState = VkDynamicState(1000455012);
/// `1000455002`  
pub const VK_DYNAMIC_STATE_TESSELLATION_DOMAIN_ORIGIN_EXT: VkDynamicState = VkDynamicState(1000455002);
/// `1000455013`  
pub const VK_DYNAMIC_STATE_RASTERIZATION_STREAM_EXT: VkDynamicState = VkDynamicState(1000455013);
/// `1000455014`  
pub const VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT: VkDynamicState = VkDynamicState(1000455014);
/// `1000455015`  
pub const VK_DYNAMIC_STATE_EXTRA_PRIMITIVE_OVERESTIMATION_SIZE_EXT: VkDynamicState = VkDynamicState(1000455015);
/// `1000455016`  
pub const VK_DYNAMIC_STATE_DEPTH_CLIP_ENABLE_EXT: VkDynamicState = VkDynamicState(1000455016);
/// `1000455017`  
pub const VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_ENABLE_EXT: VkDynamicState = VkDynamicState(1000455017);
/// `1000455018`  
pub const VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT: VkDynamicState = VkDynamicState(1000455018);
/// `1000455019`  
pub const VK_DYNAMIC_STATE_PROVOKING_VERTEX_MODE_EXT: VkDynamicState = VkDynamicState(1000455019);
/// `1000455020`  
pub const VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT: VkDynamicState = VkDynamicState(1000455020);
/// `1000455021`  
pub const VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT: VkDynamicState = VkDynamicState(1000455021);
/// `1000455022`  
pub const VK_DYNAMIC_STATE_DEPTH_CLIP_NEGATIVE_ONE_TO_ONE_EXT: VkDynamicState = VkDynamicState(1000455022);
/// `1000455023`  
pub const VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_ENABLE_NV: VkDynamicState = VkDynamicState(1000455023);
/// `1000455024`  
pub const VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV: VkDynamicState = VkDynamicState(1000455024);
/// `1000455025`  
pub const VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV: VkDynamicState = VkDynamicState(1000455025);
/// `1000455026`  
pub const VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_LOCATION_NV: VkDynamicState = VkDynamicState(1000455026);
/// `1000455027`  
pub const VK_DYNAMIC_STATE_COVERAGE_MODULATION_MODE_NV: VkDynamicState = VkDynamicState(1000455027);
/// `1000455028`  
pub const VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_ENABLE_NV: VkDynamicState = VkDynamicState(1000455028);
/// `1000455029`  
pub const VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_NV: VkDynamicState = VkDynamicState(1000455029);
/// `1000455030`  
pub const VK_DYNAMIC_STATE_SHADING_RATE_IMAGE_ENABLE_NV: VkDynamicState = VkDynamicState(1000455030);
/// `1000455031`  
pub const VK_DYNAMIC_STATE_REPRESENTATIVE_FRAGMENT_TEST_ENABLE_NV: VkDynamicState = VkDynamicState(1000455031);
/// `1000455032`  
pub const VK_DYNAMIC_STATE_COVERAGE_REDUCTION_MODE_NV: VkDynamicState = VkDynamicState(1000455032);
/// `1000524000`  
pub const VK_DYNAMIC_STATE_ATTACHMENT_FEEDBACK_LOOP_ENABLE_EXT: VkDynamicState = VkDynamicState(1000524000);
/// `VK_DYNAMIC_STATE_LINE_STIPPLE`  
pub const VK_DYNAMIC_STATE_LINE_STIPPLE_KHR: VkDynamicState = VK_DYNAMIC_STATE_LINE_STIPPLE;
/// `1000582000`  
pub const VK_DYNAMIC_STATE_DEPTH_CLAMP_RANGE_EXT: VkDynamicState = VkDynamicState(1000582000);

impl_enum_display!(VkDynamicState { VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR, VK_DYNAMIC_STATE_LINE_WIDTH, VK_DYNAMIC_STATE_DEPTH_BIAS, VK_DYNAMIC_STATE_BLEND_CONSTANTS, VK_DYNAMIC_STATE_DEPTH_BOUNDS, VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK, VK_DYNAMIC_STATE_STENCIL_WRITE_MASK, VK_DYNAMIC_STATE_STENCIL_REFERENCE, VK_DYNAMIC_STATE_CULL_MODE, VK_DYNAMIC_STATE_FRONT_FACE, VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY, VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT, VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT, VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE, VK_DYNAMIC_STATE_DEPTH_TEST_ENABLE, VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE, VK_DYNAMIC_STATE_DEPTH_COMPARE_OP, VK_DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE, VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE, VK_DYNAMIC_STATE_STENCIL_OP, VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE, VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE, VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE, VK_DYNAMIC_STATE_LINE_STIPPLE, VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV, VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT, VK_DYNAMIC_STATE_DISCARD_RECTANGLE_ENABLE_EXT, VK_DYNAMIC_STATE_DISCARD_RECTANGLE_MODE_EXT, VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT, VK_DYNAMIC_STATE_RAY_TRACING_PIPELINE_STACK_SIZE_KHR, VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV, VK_DYNAMIC_STATE_VIEWPORT_COARSE_SAMPLE_ORDER_NV, VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_ENABLE_NV, VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV, VK_DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR, VK_DYNAMIC_STATE_LINE_STIPPLE_EXT, VK_DYNAMIC_STATE_CULL_MODE_EXT, VK_DYNAMIC_STATE_FRONT_FACE_EXT, VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY_EXT, VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT, VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT_EXT, VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE_EXT, VK_DYNAMIC_STATE_DEPTH_TEST_ENABLE_EXT, VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE_EXT, VK_DYNAMIC_STATE_DEPTH_COMPARE_OP_EXT, VK_DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE_EXT, VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE_EXT, VK_DYNAMIC_STATE_STENCIL_OP_EXT, VK_DYNAMIC_STATE_VERTEX_INPUT_EXT, VK_DYNAMIC_STATE_PATCH_CONTROL_POINTS_EXT, VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE_EXT, VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE_EXT, VK_DYNAMIC_STATE_LOGIC_OP_EXT, VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE_EXT, VK_DYNAMIC_STATE_COLOR_WRITE_ENABLE_EXT, VK_DYNAMIC_STATE_DEPTH_CLAMP_ENABLE_EXT, VK_DYNAMIC_STATE_POLYGON_MODE_EXT, VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT, VK_DYNAMIC_STATE_SAMPLE_MASK_EXT, VK_DYNAMIC_STATE_ALPHA_TO_COVERAGE_ENABLE_EXT, VK_DYNAMIC_STATE_ALPHA_TO_ONE_ENABLE_EXT, VK_DYNAMIC_STATE_LOGIC_OP_ENABLE_EXT, VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT, VK_DYNAMIC_STATE_COLOR_BLEND_EQUATION_EXT, VK_DYNAMIC_STATE_COLOR_WRITE_MASK_EXT, VK_DYNAMIC_STATE_TESSELLATION_DOMAIN_ORIGIN_EXT, VK_DYNAMIC_STATE_RASTERIZATION_STREAM_EXT, VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT, VK_DYNAMIC_STATE_EXTRA_PRIMITIVE_OVERESTIMATION_SIZE_EXT, VK_DYNAMIC_STATE_DEPTH_CLIP_ENABLE_EXT, VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_ENABLE_EXT, VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT, VK_DYNAMIC_STATE_PROVOKING_VERTEX_MODE_EXT, VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT, VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT, VK_DYNAMIC_STATE_DEPTH_CLIP_NEGATIVE_ONE_TO_ONE_EXT, VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_ENABLE_NV, VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV, VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV, VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_LOCATION_NV, VK_DYNAMIC_STATE_COVERAGE_MODULATION_MODE_NV, VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_ENABLE_NV, VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_NV, VK_DYNAMIC_STATE_SHADING_RATE_IMAGE_ENABLE_NV, VK_DYNAMIC_STATE_REPRESENTATIVE_FRAGMENT_TEST_ENABLE_NV, VK_DYNAMIC_STATE_COVERAGE_REDUCTION_MODE_NV, VK_DYNAMIC_STATE_ATTACHMENT_FEEDBACK_LOOP_ENABLE_EXT, VK_DYNAMIC_STATE_LINE_STIPPLE_KHR, VK_DYNAMIC_STATE_DEPTH_CLAMP_RANGE_EXT });

/// `VkEvent` : `VkDevice`
#[repr(transparent)]
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkEvent(pub u64);
from_into_transparent!(VkEvent: u64);
impl_handle!(VkEvent: VK_OBJECT_TYPE_EVENT; SubHandle = VkDevice);

flags!(VkEventCreateFlags);
from_into_transparent!(VkEventCreateFlags: i32);
/// `VkEventCreateFlags`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkEventCreateFlags(pub i32);

/// `1 << 0`  
pub const VK_EVENT_CREATE_DEVICE_ONLY_BIT: VkEventCreateFlags = VkEventCreateFlags(1 << 0);
/// `VK_EVENT_CREATE_DEVICE_ONLY_BIT`  
pub const VK_EVENT_CREATE_DEVICE_ONLY_BIT_KHR: VkEventCreateFlags = VK_EVENT_CREATE_DEVICE_ONLY_BIT;

impl_flags_display!(VkEventCreateFlags { VK_EVENT_CREATE_DEVICE_ONLY_BIT, VK_EVENT_CREATE_DEVICE_ONLY_BIT_KHR });

/// `VkEventCreateInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkEventCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    /// Event creation flags
    pub flags: VkEventCreateFlags,
}
impl_default_zeroed_with_s_type!(VkEventCreateInfo : VK_STRUCTURE_TYPE_EVENT_CREATE_INFO);

/// `VkExecutionGraphPipelineCreateInfoAMDX`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkExecutionGraphPipelineCreateInfoAMDX {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub flags: VkPipelineCreateFlags,
    pub stageCount: uint32_t,
    pub pStages: *const VkPipelineShaderStageCreateInfo,
    pub pLibraryInfo: *const VkPipelineLibraryCreateInfoKHR,
    /// Interface layout of the pipeline
    pub layout: VkPipelineLayout,
    pub basePipelineHandle: VkPipeline,
    pub basePipelineIndex: int32_t,
}
impl_default_zeroed_with_s_type!(VkExecutionGraphPipelineCreateInfoAMDX : VK_STRUCTURE_TYPE_EXECUTION_GRAPH_PIPELINE_CREATE_INFO_AMDX);

/// `VkExecutionGraphPipelineScratchSizeAMDX`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkExecutionGraphPipelineScratchSizeAMDX {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub minSize: VkDeviceSize,
    pub maxSize: VkDeviceSize,
    pub sizeGranularity: VkDeviceSize,
}
impl_default_zeroed_with_s_type!(VkExecutionGraphPipelineScratchSizeAMDX : VK_STRUCTURE_TYPE_EXECUTION_GRAPH_PIPELINE_SCRATCH_SIZE_AMDX);

/// `VkExportFenceCreateInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkExportFenceCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub handleTypes: VkExternalFenceHandleTypeFlags,
}
impl_default_zeroed_with_s_type!(VkExportFenceCreateInfo : VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO);
impl_extends!(VkExportFenceCreateInfo : VkFenceCreateInfo);

/// `VkExportFenceCreateInfo`
pub type VkExportFenceCreateInfoKHR = VkExportFenceCreateInfo;

/// `VkExportFenceSciSyncInfoNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkExportFenceSciSyncInfoNV {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub pAttributes: NvSciSyncAttrList,
}
impl_default_zeroed_with_s_type!(VkExportFenceSciSyncInfoNV : VK_STRUCTURE_TYPE_EXPORT_FENCE_SCI_SYNC_INFO_NV);
impl_extends!(VkExportFenceSciSyncInfoNV : VkFenceCreateInfo);

/// `VkExportFenceWin32HandleInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkExportFenceWin32HandleInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub pAttributes: *const SECURITY_ATTRIBUTES,
    pub dwAccess: DWORD,
    pub name: LPCWSTR,
}
impl_default_zeroed_with_s_type!(VkExportFenceWin32HandleInfoKHR : VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR);
impl_extends!(VkExportFenceWin32HandleInfoKHR : VkFenceCreateInfo);

/// `VkExportMemoryAllocateInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkExportMemoryAllocateInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub handleTypes: VkExternalMemoryHandleTypeFlags,
}
impl_default_zeroed_with_s_type!(VkExportMemoryAllocateInfo : VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO);
impl_extends!(VkExportMemoryAllocateInfo : VkMemoryAllocateInfo);

/// `VkExportMemoryAllocateInfo`
pub type VkExportMemoryAllocateInfoKHR = VkExportMemoryAllocateInfo;

/// `VkExportMemoryAllocateInfoNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkExportMemoryAllocateInfoNV {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub handleTypes: VkExternalMemoryHandleTypeFlagsNV,
}
impl_default_zeroed_with_s_type!(VkExportMemoryAllocateInfoNV : VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV);
impl_extends!(VkExportMemoryAllocateInfoNV : VkMemoryAllocateInfo);

/// `VkExportMemorySciBufInfoNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkExportMemorySciBufInfoNV {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub pAttributes: NvSciBufAttrList,
}
impl_default_zeroed_with_s_type!(VkExportMemorySciBufInfoNV : VK_STRUCTURE_TYPE_EXPORT_MEMORY_SCI_BUF_INFO_NV);
impl_extends!(VkExportMemorySciBufInfoNV : VkMemoryAllocateInfo);

/// `VkExportMemoryWin32HandleInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkExportMemoryWin32HandleInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub pAttributes: *const SECURITY_ATTRIBUTES,
    pub dwAccess: DWORD,
    pub name: LPCWSTR,
}
impl_default_zeroed_with_s_type!(VkExportMemoryWin32HandleInfoKHR : VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR);
impl_extends!(VkExportMemoryWin32HandleInfoKHR : VkMemoryAllocateInfo);

/// `VkExportMemoryWin32HandleInfoNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkExportMemoryWin32HandleInfoNV {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub pAttributes: *const SECURITY_ATTRIBUTES,
    pub dwAccess: DWORD,
}
impl_default_zeroed_with_s_type!(VkExportMemoryWin32HandleInfoNV : VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV);
impl_extends!(VkExportMemoryWin32HandleInfoNV : VkMemoryAllocateInfo);

/// `VkExportMetalBufferInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkExportMetalBufferInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub memory: VkDeviceMemory,
    pub mtlBuffer: MTLBuffer_id,
}
impl_default_zeroed_with_s_type!(VkExportMetalBufferInfoEXT : VK_STRUCTURE_TYPE_EXPORT_METAL_BUFFER_INFO_EXT);
impl_extends!(VkExportMetalBufferInfoEXT : VkExportMetalObjectsInfoEXT);

/// `VkExportMetalCommandQueueInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkExportMetalCommandQueueInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub queue: VkQueue,
    pub mtlCommandQueue: MTLCommandQueue_id,
}
impl_default_zeroed_with_s_type!(VkExportMetalCommandQueueInfoEXT : VK_STRUCTURE_TYPE_EXPORT_METAL_COMMAND_QUEUE_INFO_EXT);
impl_extends!(VkExportMetalCommandQueueInfoEXT : VkExportMetalObjectsInfoEXT);

/// `VkExportMetalDeviceInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkExportMetalDeviceInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub mtlDevice: MTLDevice_id,
}
impl_default_zeroed_with_s_type!(VkExportMetalDeviceInfoEXT : VK_STRUCTURE_TYPE_EXPORT_METAL_DEVICE_INFO_EXT);
impl_extends!(VkExportMetalDeviceInfoEXT : VkExportMetalObjectsInfoEXT);

/// `VkExportMetalIOSurfaceInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkExportMetalIOSurfaceInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub image: VkImage,
    pub ioSurface: IOSurfaceRef,
}
impl_default_zeroed_with_s_type!(VkExportMetalIOSurfaceInfoEXT : VK_STRUCTURE_TYPE_EXPORT_METAL_IO_SURFACE_INFO_EXT);
impl_extends!(VkExportMetalIOSurfaceInfoEXT : VkExportMetalObjectsInfoEXT);

/// `VkExportMetalObjectCreateInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkExportMetalObjectCreateInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub exportObjectType: VkExportMetalObjectTypeFlagsEXT,
}
impl_default_zeroed_with_s_type!(VkExportMetalObjectCreateInfoEXT : VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECT_CREATE_INFO_EXT);
impl_extends!(VkExportMetalObjectCreateInfoEXT : VkInstanceCreateInfo, VkMemoryAllocateInfo, VkImageCreateInfo, VkImageViewCreateInfo, VkBufferViewCreateInfo, VkSemaphoreCreateInfo, VkEventCreateInfo);

flags!(VkExportMetalObjectTypeFlagsEXT);
from_into_transparent!(VkExportMetalObjectTypeFlagsEXT: i32);
/// `VkExportMetalObjectTypeFlagsEXT`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkExportMetalObjectTypeFlagsEXT(pub i32);

/// `1 << 0`  
pub const VK_EXPORT_METAL_OBJECT_TYPE_METAL_DEVICE_BIT_EXT: VkExportMetalObjectTypeFlagsEXT = VkExportMetalObjectTypeFlagsEXT(1 << 0);
/// `1 << 1`  
pub const VK_EXPORT_METAL_OBJECT_TYPE_METAL_COMMAND_QUEUE_BIT_EXT: VkExportMetalObjectTypeFlagsEXT = VkExportMetalObjectTypeFlagsEXT(1 << 1);
/// `1 << 2`  
pub const VK_EXPORT_METAL_OBJECT_TYPE_METAL_BUFFER_BIT_EXT: VkExportMetalObjectTypeFlagsEXT = VkExportMetalObjectTypeFlagsEXT(1 << 2);
/// `1 << 3`  
pub const VK_EXPORT_METAL_OBJECT_TYPE_METAL_TEXTURE_BIT_EXT: VkExportMetalObjectTypeFlagsEXT = VkExportMetalObjectTypeFlagsEXT(1 << 3);
/// `1 << 4`  
pub const VK_EXPORT_METAL_OBJECT_TYPE_METAL_IOSURFACE_BIT_EXT: VkExportMetalObjectTypeFlagsEXT = VkExportMetalObjectTypeFlagsEXT(1 << 4);
/// `1 << 5`  
pub const VK_EXPORT_METAL_OBJECT_TYPE_METAL_SHARED_EVENT_BIT_EXT: VkExportMetalObjectTypeFlagsEXT = VkExportMetalObjectTypeFlagsEXT(1 << 5);

impl_flags_display!(VkExportMetalObjectTypeFlagsEXT { VK_EXPORT_METAL_OBJECT_TYPE_METAL_DEVICE_BIT_EXT, VK_EXPORT_METAL_OBJECT_TYPE_METAL_COMMAND_QUEUE_BIT_EXT, VK_EXPORT_METAL_OBJECT_TYPE_METAL_BUFFER_BIT_EXT, VK_EXPORT_METAL_OBJECT_TYPE_METAL_TEXTURE_BIT_EXT, VK_EXPORT_METAL_OBJECT_TYPE_METAL_IOSURFACE_BIT_EXT, VK_EXPORT_METAL_OBJECT_TYPE_METAL_SHARED_EVENT_BIT_EXT });

/// `VkExportMetalObjectsInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkExportMetalObjectsInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
}
impl_default_zeroed_with_s_type!(VkExportMetalObjectsInfoEXT : VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECTS_INFO_EXT);

/// `VkExportMetalSharedEventInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkExportMetalSharedEventInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub semaphore: VkSemaphore,
    pub event: VkEvent,
    pub mtlSharedEvent: MTLSharedEvent_id,
}
impl_default_zeroed_with_s_type!(VkExportMetalSharedEventInfoEXT : VK_STRUCTURE_TYPE_EXPORT_METAL_SHARED_EVENT_INFO_EXT);
impl_extends!(VkExportMetalSharedEventInfoEXT : VkExportMetalObjectsInfoEXT);

/// `VkExportMetalTextureInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkExportMetalTextureInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub image: VkImage,
    pub imageView: VkImageView,
    pub bufferView: VkBufferView,
    pub plane: VkImageAspectFlags,
    pub mtlTexture: MTLTexture_id,
}
impl_default_zeroed_with_s_type!(VkExportMetalTextureInfoEXT : VK_STRUCTURE_TYPE_EXPORT_METAL_TEXTURE_INFO_EXT);
impl_extends!(VkExportMetalTextureInfoEXT : VkExportMetalObjectsInfoEXT);

/// `VkExportSemaphoreCreateInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkExportSemaphoreCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub handleTypes: VkExternalSemaphoreHandleTypeFlags,
}
impl_default_zeroed_with_s_type!(VkExportSemaphoreCreateInfo : VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO);
impl_extends!(VkExportSemaphoreCreateInfo : VkSemaphoreCreateInfo);

/// `VkExportSemaphoreCreateInfo`
pub type VkExportSemaphoreCreateInfoKHR = VkExportSemaphoreCreateInfo;

/// `VkExportSemaphoreSciSyncInfoNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkExportSemaphoreSciSyncInfoNV {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub pAttributes: NvSciSyncAttrList,
}
impl_default_zeroed_with_s_type!(VkExportSemaphoreSciSyncInfoNV : VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_SCI_SYNC_INFO_NV);
impl_extends!(VkExportSemaphoreSciSyncInfoNV : VkSemaphoreCreateInfo);

/// `VkExportSemaphoreWin32HandleInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkExportSemaphoreWin32HandleInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub pAttributes: *const SECURITY_ATTRIBUTES,
    pub dwAccess: DWORD,
    pub name: LPCWSTR,
}
impl_default_zeroed_with_s_type!(VkExportSemaphoreWin32HandleInfoKHR : VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR);
impl_extends!(VkExportSemaphoreWin32HandleInfoKHR : VkSemaphoreCreateInfo);

/// `VkExtensionProperties`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkExtensionProperties {
    /// extension name
    pub extensionName: [c_char; VK_MAX_EXTENSION_NAME_SIZE as usize],
    /// version of the extension specification implemented
    pub specVersion: uint32_t,
}
impl_default_zeroed!(VkExtensionProperties);

/// `VkExtent2D`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkExtent2D {
    pub width: uint32_t,
    pub height: uint32_t,
}
impl_default_zeroed!(VkExtent2D);

/// `VkExtent3D`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkExtent3D {
    pub width: uint32_t,
    pub height: uint32_t,
    pub depth: uint32_t,
}
impl_default_zeroed!(VkExtent3D);

/// `VkExternalBufferProperties`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkExternalBufferProperties {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub externalMemoryProperties: VkExternalMemoryProperties,
}
impl_default_zeroed_with_s_type!(VkExternalBufferProperties : VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES);

/// `VkExternalBufferProperties`
pub type VkExternalBufferPropertiesKHR = VkExternalBufferProperties;

/// `VkExternalComputeQueueCreateInfoNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkExternalComputeQueueCreateInfoNV {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub preferredQueue: VkQueue,
}
impl_default_zeroed_with_s_type!(VkExternalComputeQueueCreateInfoNV : VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_CREATE_INFO_NV);

/// `VkExternalComputeQueueDataParamsNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkExternalComputeQueueDataParamsNV {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub deviceIndex: uint32_t,
}
impl_default_zeroed_with_s_type!(VkExternalComputeQueueDataParamsNV : VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_DATA_PARAMS_NV);

/// `VkExternalComputeQueueDeviceCreateInfoNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkExternalComputeQueueDeviceCreateInfoNV {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub reservedExternalQueues: uint32_t,
}
impl_default_zeroed_with_s_type!(VkExternalComputeQueueDeviceCreateInfoNV : VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_DEVICE_CREATE_INFO_NV);
impl_extends!(VkExternalComputeQueueDeviceCreateInfoNV : VkDeviceCreateInfo);

/// `VkExternalComputeQueueNV` : `VkDevice`
#[repr(transparent)]
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkExternalComputeQueueNV(pub *mut void);
from_into_transparent!(VkExternalComputeQueueNV: *mut void);
from_into_transparent!(VkExternalComputeQueueNV: u64);
impl_handle!(VkExternalComputeQueueNV: VK_OBJECT_TYPE_EXTERNAL_COMPUTE_QUEUE_NV; SubHandle = VkDevice);

flags!(VkExternalFenceFeatureFlags);
from_into_transparent!(VkExternalFenceFeatureFlags: i32);
/// `VkExternalFenceFeatureFlags`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkExternalFenceFeatureFlags(pub i32);

/// `1 << 0`  
pub const VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT: VkExternalFenceFeatureFlags = VkExternalFenceFeatureFlags(1 << 0);
/// `1 << 1`  
pub const VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT: VkExternalFenceFeatureFlags = VkExternalFenceFeatureFlags(1 << 1);
/// `VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT`  
pub const VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT_KHR: VkExternalFenceFeatureFlags = VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT;
/// `VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT`  
pub const VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT_KHR: VkExternalFenceFeatureFlags = VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT;

impl_flags_display!(VkExternalFenceFeatureFlags { VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT, VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT, VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT_KHR, VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT_KHR });

/// `VkExternalFenceFeatureFlags`
pub type VkExternalFenceFeatureFlagsKHR = VkExternalFenceFeatureFlags;

flags!(VkExternalFenceHandleTypeFlags);
from_into_transparent!(VkExternalFenceHandleTypeFlags: i32);
/// `VkExternalFenceHandleTypeFlags`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkExternalFenceHandleTypeFlags(pub i32);

/// `1 << 0`  
pub const VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT: VkExternalFenceHandleTypeFlags = VkExternalFenceHandleTypeFlags(1 << 0);
/// `1 << 1`  
pub const VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT: VkExternalFenceHandleTypeFlags = VkExternalFenceHandleTypeFlags(1 << 1);
/// `1 << 2`  
pub const VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT: VkExternalFenceHandleTypeFlags = VkExternalFenceHandleTypeFlags(1 << 2);
/// `1 << 3`  
pub const VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT: VkExternalFenceHandleTypeFlags = VkExternalFenceHandleTypeFlags(1 << 3);
/// `VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT`  
pub const VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR: VkExternalFenceHandleTypeFlags = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT;
/// `VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT`  
pub const VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR: VkExternalFenceHandleTypeFlags = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT;
/// `VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT`  
pub const VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR: VkExternalFenceHandleTypeFlags = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT;
/// `VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT`  
pub const VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT_KHR: VkExternalFenceHandleTypeFlags = VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT;
/// `1 << 4`  
pub const VK_EXTERNAL_FENCE_HANDLE_TYPE_SCI_SYNC_OBJ_BIT_NV: VkExternalFenceHandleTypeFlags = VkExternalFenceHandleTypeFlags(1 << 4);
/// `1 << 5`  
pub const VK_EXTERNAL_FENCE_HANDLE_TYPE_SCI_SYNC_FENCE_BIT_NV: VkExternalFenceHandleTypeFlags = VkExternalFenceHandleTypeFlags(1 << 5);

impl_flags_display!(VkExternalFenceHandleTypeFlags { VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT, VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT, VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT, VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT, VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR, VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR, VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR, VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT_KHR, VK_EXTERNAL_FENCE_HANDLE_TYPE_SCI_SYNC_OBJ_BIT_NV, VK_EXTERNAL_FENCE_HANDLE_TYPE_SCI_SYNC_FENCE_BIT_NV });

/// `VkExternalFenceHandleTypeFlags`
pub type VkExternalFenceHandleTypeFlagsKHR = VkExternalFenceHandleTypeFlags;

/// `VkExternalFenceProperties`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkExternalFenceProperties {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub exportFromImportedHandleTypes: VkExternalFenceHandleTypeFlags,
    pub compatibleHandleTypes: VkExternalFenceHandleTypeFlags,
    pub externalFenceFeatures: VkExternalFenceFeatureFlags,
}
impl_default_zeroed_with_s_type!(VkExternalFenceProperties : VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES);

/// `VkExternalFenceProperties`
pub type VkExternalFencePropertiesKHR = VkExternalFenceProperties;

/// `VkExternalFormatANDROID`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkExternalFormatANDROID {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub externalFormat: uint64_t,
}
impl_default_zeroed_with_s_type!(VkExternalFormatANDROID : VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID);
impl_extends!(VkExternalFormatANDROID : VkImageCreateInfo, VkSamplerYcbcrConversionCreateInfo, VkAttachmentDescription2, VkGraphicsPipelineCreateInfo, VkCommandBufferInheritanceInfo);

/// `VkExternalFormatOHOS`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkExternalFormatOHOS {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub externalFormat: uint64_t,
}
impl_default_zeroed_with_s_type!(VkExternalFormatOHOS : VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_OHOS);
impl_extends!(VkExternalFormatOHOS : VkImageCreateInfo, VkSamplerYcbcrConversionCreateInfo, VkAttachmentDescription2, VkGraphicsPipelineCreateInfo, VkCommandBufferInheritanceInfo);

/// `VkExternalFormatQNX`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkExternalFormatQNX {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub externalFormat: uint64_t,
}
impl_default_zeroed_with_s_type!(VkExternalFormatQNX : VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_QNX);
impl_extends!(VkExternalFormatQNX : VkImageCreateInfo, VkSamplerYcbcrConversionCreateInfo);

/// `VkExternalImageFormatProperties`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkExternalImageFormatProperties {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub externalMemoryProperties: VkExternalMemoryProperties,
}
impl_default_zeroed_with_s_type!(VkExternalImageFormatProperties : VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES);
impl_extends!(VkExternalImageFormatProperties : VkImageFormatProperties2);

/// `VkExternalImageFormatProperties`
pub type VkExternalImageFormatPropertiesKHR = VkExternalImageFormatProperties;

/// `VkExternalImageFormatPropertiesNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkExternalImageFormatPropertiesNV {
    pub imageFormatProperties: VkImageFormatProperties,
    pub externalMemoryFeatures: VkExternalMemoryFeatureFlagsNV,
    pub exportFromImportedHandleTypes: VkExternalMemoryHandleTypeFlagsNV,
    pub compatibleHandleTypes: VkExternalMemoryHandleTypeFlagsNV,
}
impl_default_zeroed!(VkExternalImageFormatPropertiesNV);

/// `VkExternalMemoryAcquireUnmodifiedEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkExternalMemoryAcquireUnmodifiedEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub acquireUnmodifiedMemory: VkBool32,
}
impl_default_zeroed_with_s_type!(VkExternalMemoryAcquireUnmodifiedEXT : VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT);
impl_extends!(VkExternalMemoryAcquireUnmodifiedEXT : VkBufferMemoryBarrier, VkBufferMemoryBarrier2, VkImageMemoryBarrier, VkImageMemoryBarrier2);

/// `VkExternalMemoryBufferCreateInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkExternalMemoryBufferCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub handleTypes: VkExternalMemoryHandleTypeFlags,
}
impl_default_zeroed_with_s_type!(VkExternalMemoryBufferCreateInfo : VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO);
impl_extends!(VkExternalMemoryBufferCreateInfo : VkBufferCreateInfo);

/// `VkExternalMemoryBufferCreateInfo`
pub type VkExternalMemoryBufferCreateInfoKHR = VkExternalMemoryBufferCreateInfo;

flags!(VkExternalMemoryFeatureFlags);
from_into_transparent!(VkExternalMemoryFeatureFlags: i32);
/// `VkExternalMemoryFeatureFlags`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkExternalMemoryFeatureFlags(pub i32);

/// `1 << 0`  
pub const VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT: VkExternalMemoryFeatureFlags = VkExternalMemoryFeatureFlags(1 << 0);
/// `1 << 1`  
pub const VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT: VkExternalMemoryFeatureFlags = VkExternalMemoryFeatureFlags(1 << 1);
/// `1 << 2`  
pub const VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT: VkExternalMemoryFeatureFlags = VkExternalMemoryFeatureFlags(1 << 2);
/// `VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT`  
pub const VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHR: VkExternalMemoryFeatureFlags = VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT;
/// `VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT`  
pub const VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHR: VkExternalMemoryFeatureFlags = VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT;
/// `VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT`  
pub const VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHR: VkExternalMemoryFeatureFlags = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT;

impl_flags_display!(VkExternalMemoryFeatureFlags { VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT, VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT, VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT, VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHR, VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHR, VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHR });

/// `VkExternalMemoryFeatureFlags`
pub type VkExternalMemoryFeatureFlagsKHR = VkExternalMemoryFeatureFlags;

flags!(VkExternalMemoryFeatureFlagsNV);
from_into_transparent!(VkExternalMemoryFeatureFlagsNV: i32);
/// `VkExternalMemoryFeatureFlagsNV`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkExternalMemoryFeatureFlagsNV(pub i32);

/// `1 << 0`  
pub const VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_NV: VkExternalMemoryFeatureFlagsNV = VkExternalMemoryFeatureFlagsNV(1 << 0);
/// `1 << 1`  
pub const VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_NV: VkExternalMemoryFeatureFlagsNV = VkExternalMemoryFeatureFlagsNV(1 << 1);
/// `1 << 2`  
pub const VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_NV: VkExternalMemoryFeatureFlagsNV = VkExternalMemoryFeatureFlagsNV(1 << 2);

impl_flags_display!(VkExternalMemoryFeatureFlagsNV { VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_NV, VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_NV, VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_NV });

flags!(VkExternalMemoryHandleTypeFlags);
from_into_transparent!(VkExternalMemoryHandleTypeFlags: i32);
/// `VkExternalMemoryHandleTypeFlags`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkExternalMemoryHandleTypeFlags(pub i32);

/// `1 << 0`  
pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT: VkExternalMemoryHandleTypeFlags = VkExternalMemoryHandleTypeFlags(1 << 0);
/// `1 << 1`  
pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT: VkExternalMemoryHandleTypeFlags = VkExternalMemoryHandleTypeFlags(1 << 1);
/// `1 << 2`  
pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT: VkExternalMemoryHandleTypeFlags = VkExternalMemoryHandleTypeFlags(1 << 2);
/// `1 << 3`  
pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT: VkExternalMemoryHandleTypeFlags = VkExternalMemoryHandleTypeFlags(1 << 3);
/// `1 << 4`  
pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT: VkExternalMemoryHandleTypeFlags = VkExternalMemoryHandleTypeFlags(1 << 4);
/// `1 << 5`  
pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT: VkExternalMemoryHandleTypeFlags = VkExternalMemoryHandleTypeFlags(1 << 5);
/// `1 << 6`  
pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT: VkExternalMemoryHandleTypeFlags = VkExternalMemoryHandleTypeFlags(1 << 6);
/// `VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT`  
pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR: VkExternalMemoryHandleTypeFlags = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT;
/// `VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT`  
pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR: VkExternalMemoryHandleTypeFlags = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT;
/// `VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT`  
pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR: VkExternalMemoryHandleTypeFlags = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT;
/// `VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT`  
pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT_KHR: VkExternalMemoryHandleTypeFlags = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT;
/// `VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT`  
pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT_KHR: VkExternalMemoryHandleTypeFlags = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT;
/// `VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT`  
pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT_KHR: VkExternalMemoryHandleTypeFlags = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT;
/// `VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT`  
pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT_KHR: VkExternalMemoryHandleTypeFlags = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT;
/// `1 << 9`  
pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT: VkExternalMemoryHandleTypeFlags = VkExternalMemoryHandleTypeFlags(1 << 9);
/// `1 << 10`  
pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID: VkExternalMemoryHandleTypeFlags = VkExternalMemoryHandleTypeFlags(1 << 10);
/// `1 << 7`  
pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT: VkExternalMemoryHandleTypeFlags = VkExternalMemoryHandleTypeFlags(1 << 7);
/// `1 << 8`  
pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT: VkExternalMemoryHandleTypeFlags = VkExternalMemoryHandleTypeFlags(1 << 8);
/// `1 << 11`  
pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_ZIRCON_VMO_BIT_FUCHSIA: VkExternalMemoryHandleTypeFlags = VkExternalMemoryHandleTypeFlags(1 << 11);
/// `1 << 12`  
pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_RDMA_ADDRESS_BIT_NV: VkExternalMemoryHandleTypeFlags = VkExternalMemoryHandleTypeFlags(1 << 12);
/// `1 << 13`  
pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_SCI_BUF_BIT_NV: VkExternalMemoryHandleTypeFlags = VkExternalMemoryHandleTypeFlags(1 << 13);
/// `1 << 15`  
pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_OH_NATIVE_BUFFER_BIT_OHOS: VkExternalMemoryHandleTypeFlags = VkExternalMemoryHandleTypeFlags(1 << 15);
/// `1 << 14`  
pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_SCREEN_BUFFER_BIT_QNX: VkExternalMemoryHandleTypeFlags = VkExternalMemoryHandleTypeFlags(1 << 14);
/// `1 << 16`  
pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_MTLBUFFER_BIT_EXT: VkExternalMemoryHandleTypeFlags = VkExternalMemoryHandleTypeFlags(1 << 16);
/// `1 << 17`  
pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_MTLTEXTURE_BIT_EXT: VkExternalMemoryHandleTypeFlags = VkExternalMemoryHandleTypeFlags(1 << 17);
/// `1 << 18`  
pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_MTLHEAP_BIT_EXT: VkExternalMemoryHandleTypeFlags = VkExternalMemoryHandleTypeFlags(1 << 18);

impl_flags_display!(VkExternalMemoryHandleTypeFlags { VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT, VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT, VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT, VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT, VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT, VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT, VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT, VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR, VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR, VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR, VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT_KHR, VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT_KHR, VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT_KHR, VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT_KHR, VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT, VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID, VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT, VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT, VK_EXTERNAL_MEMORY_HANDLE_TYPE_ZIRCON_VMO_BIT_FUCHSIA, VK_EXTERNAL_MEMORY_HANDLE_TYPE_RDMA_ADDRESS_BIT_NV, VK_EXTERNAL_MEMORY_HANDLE_TYPE_SCI_BUF_BIT_NV, VK_EXTERNAL_MEMORY_HANDLE_TYPE_OH_NATIVE_BUFFER_BIT_OHOS, VK_EXTERNAL_MEMORY_HANDLE_TYPE_SCREEN_BUFFER_BIT_QNX, VK_EXTERNAL_MEMORY_HANDLE_TYPE_MTLBUFFER_BIT_EXT, VK_EXTERNAL_MEMORY_HANDLE_TYPE_MTLTEXTURE_BIT_EXT, VK_EXTERNAL_MEMORY_HANDLE_TYPE_MTLHEAP_BIT_EXT });

/// `VkExternalMemoryHandleTypeFlags`
pub type VkExternalMemoryHandleTypeFlagsKHR = VkExternalMemoryHandleTypeFlags;

flags!(VkExternalMemoryHandleTypeFlagsNV);
from_into_transparent!(VkExternalMemoryHandleTypeFlagsNV: i32);
/// `VkExternalMemoryHandleTypeFlagsNV`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkExternalMemoryHandleTypeFlagsNV(pub i32);

/// `1 << 0`  
pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV: VkExternalMemoryHandleTypeFlagsNV = VkExternalMemoryHandleTypeFlagsNV(1 << 0);
/// `1 << 1`  
pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_NV: VkExternalMemoryHandleTypeFlagsNV = VkExternalMemoryHandleTypeFlagsNV(1 << 1);
/// `1 << 2`  
pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_BIT_NV: VkExternalMemoryHandleTypeFlagsNV = VkExternalMemoryHandleTypeFlagsNV(1 << 2);
/// `1 << 3`  
pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_BIT_NV: VkExternalMemoryHandleTypeFlagsNV = VkExternalMemoryHandleTypeFlagsNV(1 << 3);

impl_flags_display!(VkExternalMemoryHandleTypeFlagsNV { VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV, VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_NV, VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_BIT_NV, VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_BIT_NV });

/// `VkExternalMemoryImageCreateInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkExternalMemoryImageCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub handleTypes: VkExternalMemoryHandleTypeFlags,
}
impl_default_zeroed_with_s_type!(VkExternalMemoryImageCreateInfo : VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO);
impl_extends!(VkExternalMemoryImageCreateInfo : VkImageCreateInfo);

/// `VkExternalMemoryImageCreateInfo`
pub type VkExternalMemoryImageCreateInfoKHR = VkExternalMemoryImageCreateInfo;

/// `VkExternalMemoryImageCreateInfoNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkExternalMemoryImageCreateInfoNV {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub handleTypes: VkExternalMemoryHandleTypeFlagsNV,
}
impl_default_zeroed_with_s_type!(VkExternalMemoryImageCreateInfoNV : VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV);
impl_extends!(VkExternalMemoryImageCreateInfoNV : VkImageCreateInfo);

/// `VkExternalMemoryProperties`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkExternalMemoryProperties {
    pub externalMemoryFeatures: VkExternalMemoryFeatureFlags,
    pub exportFromImportedHandleTypes: VkExternalMemoryHandleTypeFlags,
    pub compatibleHandleTypes: VkExternalMemoryHandleTypeFlags,
}
impl_default_zeroed!(VkExternalMemoryProperties);

/// `VkExternalMemoryProperties`
pub type VkExternalMemoryPropertiesKHR = VkExternalMemoryProperties;

/// `VkExternalMemoryTensorCreateInfoARM`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkExternalMemoryTensorCreateInfoARM {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub handleTypes: VkExternalMemoryHandleTypeFlags,
}
impl_default_zeroed_with_s_type!(VkExternalMemoryTensorCreateInfoARM : VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_TENSOR_CREATE_INFO_ARM);
impl_extends!(VkExternalMemoryTensorCreateInfoARM : VkTensorCreateInfoARM);

flags!(VkExternalSemaphoreFeatureFlags);
from_into_transparent!(VkExternalSemaphoreFeatureFlags: i32);
/// `VkExternalSemaphoreFeatureFlags`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkExternalSemaphoreFeatureFlags(pub i32);

/// `1 << 0`  
pub const VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT: VkExternalSemaphoreFeatureFlags = VkExternalSemaphoreFeatureFlags(1 << 0);
/// `1 << 1`  
pub const VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT: VkExternalSemaphoreFeatureFlags = VkExternalSemaphoreFeatureFlags(1 << 1);
/// `VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT`  
pub const VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT_KHR: VkExternalSemaphoreFeatureFlags = VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT;
/// `VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT`  
pub const VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT_KHR: VkExternalSemaphoreFeatureFlags = VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT;

impl_flags_display!(VkExternalSemaphoreFeatureFlags { VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT, VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT, VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT_KHR, VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT_KHR });

/// `VkExternalSemaphoreFeatureFlags`
pub type VkExternalSemaphoreFeatureFlagsKHR = VkExternalSemaphoreFeatureFlags;

flags!(VkExternalSemaphoreHandleTypeFlags);
from_into_transparent!(VkExternalSemaphoreHandleTypeFlags: i32);
/// `VkExternalSemaphoreHandleTypeFlags`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkExternalSemaphoreHandleTypeFlags(pub i32);

/// `1 << 0`  
pub const VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT: VkExternalSemaphoreHandleTypeFlags = VkExternalSemaphoreHandleTypeFlags(1 << 0);
/// `1 << 1`  
pub const VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT: VkExternalSemaphoreHandleTypeFlags = VkExternalSemaphoreHandleTypeFlags(1 << 1);
/// `1 << 2`  
pub const VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT: VkExternalSemaphoreHandleTypeFlags = VkExternalSemaphoreHandleTypeFlags(1 << 2);
/// `1 << 3`  
pub const VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT: VkExternalSemaphoreHandleTypeFlags = VkExternalSemaphoreHandleTypeFlags(1 << 3);
/// `VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT`  
pub const VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_FENCE_BIT: VkExternalSemaphoreHandleTypeFlags = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT;
/// `1 << 4`  
pub const VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT: VkExternalSemaphoreHandleTypeFlags = VkExternalSemaphoreHandleTypeFlags(1 << 4);
/// `VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT`  
pub const VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR: VkExternalSemaphoreHandleTypeFlags = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT;
/// `VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT`  
pub const VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR: VkExternalSemaphoreHandleTypeFlags = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT;
/// `VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT`  
pub const VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR: VkExternalSemaphoreHandleTypeFlags = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT;
/// `VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT`  
pub const VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT_KHR: VkExternalSemaphoreHandleTypeFlags = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT;
/// `VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT`  
pub const VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT_KHR: VkExternalSemaphoreHandleTypeFlags = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT;
/// `1 << 7`  
pub const VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_ZIRCON_EVENT_BIT_FUCHSIA: VkExternalSemaphoreHandleTypeFlags = VkExternalSemaphoreHandleTypeFlags(1 << 7);
/// `1 << 5`  
pub const VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SCI_SYNC_OBJ_BIT_NV: VkExternalSemaphoreHandleTypeFlags = VkExternalSemaphoreHandleTypeFlags(1 << 5);

impl_flags_display!(VkExternalSemaphoreHandleTypeFlags { VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT, VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT, VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT, VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT, VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_FENCE_BIT, VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT, VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR, VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR, VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR, VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT_KHR, VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT_KHR, VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_ZIRCON_EVENT_BIT_FUCHSIA, VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SCI_SYNC_OBJ_BIT_NV });

/// `VkExternalSemaphoreHandleTypeFlags`
pub type VkExternalSemaphoreHandleTypeFlagsKHR = VkExternalSemaphoreHandleTypeFlags;

/// `VkExternalSemaphoreProperties`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkExternalSemaphoreProperties {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub exportFromImportedHandleTypes: VkExternalSemaphoreHandleTypeFlags,
    pub compatibleHandleTypes: VkExternalSemaphoreHandleTypeFlags,
    pub externalSemaphoreFeatures: VkExternalSemaphoreFeatureFlags,
}
impl_default_zeroed_with_s_type!(VkExternalSemaphoreProperties : VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES);

/// `VkExternalSemaphoreProperties`
pub type VkExternalSemaphorePropertiesKHR = VkExternalSemaphoreProperties;

/// `VkExternalTensorPropertiesARM`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkExternalTensorPropertiesARM {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub externalMemoryProperties: VkExternalMemoryProperties,
}
impl_default_zeroed_with_s_type!(VkExternalTensorPropertiesARM : VK_STRUCTURE_TYPE_EXTERNAL_TENSOR_PROPERTIES_ARM);

/// `VkFaultCallbackInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkFaultCallbackInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub faultCount: uint32_t,
    pub pFaults: *mut VkFaultData,
    pub pfnFaultCallback: PFN_vkFaultCallbackFunction,
}
impl_default_zeroed_with_s_type!(VkFaultCallbackInfo : VK_STRUCTURE_TYPE_FAULT_CALLBACK_INFO);
impl_extends!(VkFaultCallbackInfo : VkDeviceCreateInfo);

/// `VkFaultData`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkFaultData {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub faultLevel: VkFaultLevel,
    pub faultType: VkFaultType,
}
impl_default_zeroed_with_s_type!(VkFaultData : VK_STRUCTURE_TYPE_FAULT_DATA);

from_into_transparent!(VkFaultLevel: i32);
/// `VkFaultLevel`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkFaultLevel(pub i32);

/// `0`  
pub const VK_FAULT_LEVEL_UNASSIGNED: VkFaultLevel = VkFaultLevel(0);
/// `1`  
pub const VK_FAULT_LEVEL_CRITICAL: VkFaultLevel = VkFaultLevel(1);
/// `2`  
pub const VK_FAULT_LEVEL_RECOVERABLE: VkFaultLevel = VkFaultLevel(2);
/// `3`  
pub const VK_FAULT_LEVEL_WARNING: VkFaultLevel = VkFaultLevel(3);

impl_enum_display!(VkFaultLevel { VK_FAULT_LEVEL_UNASSIGNED, VK_FAULT_LEVEL_CRITICAL, VK_FAULT_LEVEL_RECOVERABLE, VK_FAULT_LEVEL_WARNING });

from_into_transparent!(VkFaultQueryBehavior: i32);
/// `VkFaultQueryBehavior`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkFaultQueryBehavior(pub i32);

/// `0`  
pub const VK_FAULT_QUERY_BEHAVIOR_GET_AND_CLEAR_ALL_FAULTS: VkFaultQueryBehavior = VkFaultQueryBehavior(0);

impl_enum_display!(VkFaultQueryBehavior { VK_FAULT_QUERY_BEHAVIOR_GET_AND_CLEAR_ALL_FAULTS });

from_into_transparent!(VkFaultType: i32);
/// `VkFaultType`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkFaultType(pub i32);

/// `0`  
pub const VK_FAULT_TYPE_INVALID: VkFaultType = VkFaultType(0);
/// `1`  
pub const VK_FAULT_TYPE_UNASSIGNED: VkFaultType = VkFaultType(1);
/// `2`  
pub const VK_FAULT_TYPE_IMPLEMENTATION: VkFaultType = VkFaultType(2);
/// `3`  
pub const VK_FAULT_TYPE_SYSTEM: VkFaultType = VkFaultType(3);
/// `4`  
pub const VK_FAULT_TYPE_PHYSICAL_DEVICE: VkFaultType = VkFaultType(4);
/// `5`  
pub const VK_FAULT_TYPE_COMMAND_BUFFER_FULL: VkFaultType = VkFaultType(5);
/// `6`  
pub const VK_FAULT_TYPE_INVALID_API_USAGE: VkFaultType = VkFaultType(6);

impl_enum_display!(VkFaultType { VK_FAULT_TYPE_INVALID, VK_FAULT_TYPE_UNASSIGNED, VK_FAULT_TYPE_IMPLEMENTATION, VK_FAULT_TYPE_SYSTEM, VK_FAULT_TYPE_PHYSICAL_DEVICE, VK_FAULT_TYPE_COMMAND_BUFFER_FULL, VK_FAULT_TYPE_INVALID_API_USAGE });

/// `VkFence` : `VkDevice`
#[repr(transparent)]
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkFence(pub u64);
from_into_transparent!(VkFence: u64);
impl_handle!(VkFence: VK_OBJECT_TYPE_FENCE; SubHandle = VkDevice);

flags!(VkFenceCreateFlags);
from_into_transparent!(VkFenceCreateFlags: i32);
/// `VkFenceCreateFlags`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkFenceCreateFlags(pub i32);

/// `1 << 0`  
pub const VK_FENCE_CREATE_SIGNALED_BIT: VkFenceCreateFlags = VkFenceCreateFlags(1 << 0);

impl_flags_display!(VkFenceCreateFlags { VK_FENCE_CREATE_SIGNALED_BIT });

/// `VkFenceCreateInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkFenceCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    /// Fence creation flags
    pub flags: VkFenceCreateFlags,
}
impl_default_zeroed_with_s_type!(VkFenceCreateInfo : VK_STRUCTURE_TYPE_FENCE_CREATE_INFO);

/// `VkFenceGetFdInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkFenceGetFdInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub fence: VkFence,
    pub handleType: VkExternalFenceHandleTypeFlags,
}
impl_default_zeroed_with_s_type!(VkFenceGetFdInfoKHR : VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR);

/// `VkFenceGetSciSyncInfoNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkFenceGetSciSyncInfoNV {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub fence: VkFence,
    pub handleType: VkExternalFenceHandleTypeFlags,
}
impl_default_zeroed_with_s_type!(VkFenceGetSciSyncInfoNV : VK_STRUCTURE_TYPE_FENCE_GET_SCI_SYNC_INFO_NV);

/// `VkFenceGetWin32HandleInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkFenceGetWin32HandleInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub fence: VkFence,
    pub handleType: VkExternalFenceHandleTypeFlags,
}
impl_default_zeroed_with_s_type!(VkFenceGetWin32HandleInfoKHR : VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR);

flags!(VkFenceImportFlags);
from_into_transparent!(VkFenceImportFlags: i32);
/// `VkFenceImportFlags`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkFenceImportFlags(pub i32);

/// `1 << 0`  
pub const VK_FENCE_IMPORT_TEMPORARY_BIT: VkFenceImportFlags = VkFenceImportFlags(1 << 0);
/// `VK_FENCE_IMPORT_TEMPORARY_BIT`  
pub const VK_FENCE_IMPORT_TEMPORARY_BIT_KHR: VkFenceImportFlags = VK_FENCE_IMPORT_TEMPORARY_BIT;

impl_flags_display!(VkFenceImportFlags { VK_FENCE_IMPORT_TEMPORARY_BIT, VK_FENCE_IMPORT_TEMPORARY_BIT_KHR });

/// `VkFenceImportFlags`
pub type VkFenceImportFlagsKHR = VkFenceImportFlags;

from_into_transparent!(VkFilter: i32);
/// `VkFilter`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkFilter(pub i32);

/// `0`  
pub const VK_FILTER_NEAREST: VkFilter = VkFilter(0);
/// `1`  
pub const VK_FILTER_LINEAR: VkFilter = VkFilter(1);
/// `VK_FILTER_CUBIC_EXT`  
pub const VK_FILTER_CUBIC_IMG: VkFilter = VK_FILTER_CUBIC_EXT;
/// `1000015000`  
pub const VK_FILTER_CUBIC_EXT: VkFilter = VkFilter(1000015000);

impl_enum_display!(VkFilter { VK_FILTER_NEAREST, VK_FILTER_LINEAR, VK_FILTER_CUBIC_IMG, VK_FILTER_CUBIC_EXT });

/// `VkFilterCubicImageViewImageFormatPropertiesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkFilterCubicImageViewImageFormatPropertiesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    /// The combinations of format, image type (and image view type if provided) can be filtered with VK_FILTER_CUBIC_EXT
    pub filterCubic: VkBool32,
    /// 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 filterCubicMinmax: VkBool32,
}
impl_default_zeroed_with_s_type!(VkFilterCubicImageViewImageFormatPropertiesEXT : VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT);
impl_extends!(VkFilterCubicImageViewImageFormatPropertiesEXT : VkImageFormatProperties2);

from_into_transparent!(VkFormat: i32);
/// `VkFormat`
/// 
/// Vulkan format definitions
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkFormat(pub i32);

/// `0`  
pub const VK_FORMAT_UNDEFINED: VkFormat = VkFormat(0);
/// `1`  
pub const VK_FORMAT_R4G4_UNORM_PACK8: VkFormat = VkFormat(1);
/// `2`  
pub const VK_FORMAT_R4G4B4A4_UNORM_PACK16: VkFormat = VkFormat(2);
/// `3`  
pub const VK_FORMAT_B4G4R4A4_UNORM_PACK16: VkFormat = VkFormat(3);
/// `4`  
pub const VK_FORMAT_R5G6B5_UNORM_PACK16: VkFormat = VkFormat(4);
/// `5`  
pub const VK_FORMAT_B5G6R5_UNORM_PACK16: VkFormat = VkFormat(5);
/// `6`  
pub const VK_FORMAT_R5G5B5A1_UNORM_PACK16: VkFormat = VkFormat(6);
/// `7`  
pub const VK_FORMAT_B5G5R5A1_UNORM_PACK16: VkFormat = VkFormat(7);
/// `8`  
pub const VK_FORMAT_A1R5G5B5_UNORM_PACK16: VkFormat = VkFormat(8);
/// `9`  
pub const VK_FORMAT_R8_UNORM: VkFormat = VkFormat(9);
/// `10`  
pub const VK_FORMAT_R8_SNORM: VkFormat = VkFormat(10);
/// `11`  
pub const VK_FORMAT_R8_USCALED: VkFormat = VkFormat(11);
/// `12`  
pub const VK_FORMAT_R8_SSCALED: VkFormat = VkFormat(12);
/// `13`  
pub const VK_FORMAT_R8_UINT: VkFormat = VkFormat(13);
/// `14`  
pub const VK_FORMAT_R8_SINT: VkFormat = VkFormat(14);
/// `15`  
pub const VK_FORMAT_R8_SRGB: VkFormat = VkFormat(15);
/// `16`  
pub const VK_FORMAT_R8G8_UNORM: VkFormat = VkFormat(16);
/// `17`  
pub const VK_FORMAT_R8G8_SNORM: VkFormat = VkFormat(17);
/// `18`  
pub const VK_FORMAT_R8G8_USCALED: VkFormat = VkFormat(18);
/// `19`  
pub const VK_FORMAT_R8G8_SSCALED: VkFormat = VkFormat(19);
/// `20`  
pub const VK_FORMAT_R8G8_UINT: VkFormat = VkFormat(20);
/// `21`  
pub const VK_FORMAT_R8G8_SINT: VkFormat = VkFormat(21);
/// `22`  
pub const VK_FORMAT_R8G8_SRGB: VkFormat = VkFormat(22);
/// `23`  
pub const VK_FORMAT_R8G8B8_UNORM: VkFormat = VkFormat(23);
/// `24`  
pub const VK_FORMAT_R8G8B8_SNORM: VkFormat = VkFormat(24);
/// `25`  
pub const VK_FORMAT_R8G8B8_USCALED: VkFormat = VkFormat(25);
/// `26`  
pub const VK_FORMAT_R8G8B8_SSCALED: VkFormat = VkFormat(26);
/// `27`  
pub const VK_FORMAT_R8G8B8_UINT: VkFormat = VkFormat(27);
/// `28`  
pub const VK_FORMAT_R8G8B8_SINT: VkFormat = VkFormat(28);
/// `29`  
pub const VK_FORMAT_R8G8B8_SRGB: VkFormat = VkFormat(29);
/// `30`  
pub const VK_FORMAT_B8G8R8_UNORM: VkFormat = VkFormat(30);
/// `31`  
pub const VK_FORMAT_B8G8R8_SNORM: VkFormat = VkFormat(31);
/// `32`  
pub const VK_FORMAT_B8G8R8_USCALED: VkFormat = VkFormat(32);
/// `33`  
pub const VK_FORMAT_B8G8R8_SSCALED: VkFormat = VkFormat(33);
/// `34`  
pub const VK_FORMAT_B8G8R8_UINT: VkFormat = VkFormat(34);
/// `35`  
pub const VK_FORMAT_B8G8R8_SINT: VkFormat = VkFormat(35);
/// `36`  
pub const VK_FORMAT_B8G8R8_SRGB: VkFormat = VkFormat(36);
/// `37`  
pub const VK_FORMAT_R8G8B8A8_UNORM: VkFormat = VkFormat(37);
/// `38`  
pub const VK_FORMAT_R8G8B8A8_SNORM: VkFormat = VkFormat(38);
/// `39`  
pub const VK_FORMAT_R8G8B8A8_USCALED: VkFormat = VkFormat(39);
/// `40`  
pub const VK_FORMAT_R8G8B8A8_SSCALED: VkFormat = VkFormat(40);
/// `41`  
pub const VK_FORMAT_R8G8B8A8_UINT: VkFormat = VkFormat(41);
/// `42`  
pub const VK_FORMAT_R8G8B8A8_SINT: VkFormat = VkFormat(42);
/// `43`  
pub const VK_FORMAT_R8G8B8A8_SRGB: VkFormat = VkFormat(43);
/// `44`  
pub const VK_FORMAT_B8G8R8A8_UNORM: VkFormat = VkFormat(44);
/// `45`  
pub const VK_FORMAT_B8G8R8A8_SNORM: VkFormat = VkFormat(45);
/// `46`  
pub const VK_FORMAT_B8G8R8A8_USCALED: VkFormat = VkFormat(46);
/// `47`  
pub const VK_FORMAT_B8G8R8A8_SSCALED: VkFormat = VkFormat(47);
/// `48`  
pub const VK_FORMAT_B8G8R8A8_UINT: VkFormat = VkFormat(48);
/// `49`  
pub const VK_FORMAT_B8G8R8A8_SINT: VkFormat = VkFormat(49);
/// `50`  
pub const VK_FORMAT_B8G8R8A8_SRGB: VkFormat = VkFormat(50);
/// `51`  
pub const VK_FORMAT_A8B8G8R8_UNORM_PACK32: VkFormat = VkFormat(51);
/// `52`  
pub const VK_FORMAT_A8B8G8R8_SNORM_PACK32: VkFormat = VkFormat(52);
/// `53`  
pub const VK_FORMAT_A8B8G8R8_USCALED_PACK32: VkFormat = VkFormat(53);
/// `54`  
pub const VK_FORMAT_A8B8G8R8_SSCALED_PACK32: VkFormat = VkFormat(54);
/// `55`  
pub const VK_FORMAT_A8B8G8R8_UINT_PACK32: VkFormat = VkFormat(55);
/// `56`  
pub const VK_FORMAT_A8B8G8R8_SINT_PACK32: VkFormat = VkFormat(56);
/// `57`  
pub const VK_FORMAT_A8B8G8R8_SRGB_PACK32: VkFormat = VkFormat(57);
/// `58`  
pub const VK_FORMAT_A2R10G10B10_UNORM_PACK32: VkFormat = VkFormat(58);
/// `59`  
pub const VK_FORMAT_A2R10G10B10_SNORM_PACK32: VkFormat = VkFormat(59);
/// `60`  
pub const VK_FORMAT_A2R10G10B10_USCALED_PACK32: VkFormat = VkFormat(60);
/// `61`  
pub const VK_FORMAT_A2R10G10B10_SSCALED_PACK32: VkFormat = VkFormat(61);
/// `62`  
pub const VK_FORMAT_A2R10G10B10_UINT_PACK32: VkFormat = VkFormat(62);
/// `63`  
pub const VK_FORMAT_A2R10G10B10_SINT_PACK32: VkFormat = VkFormat(63);
/// `64`  
pub const VK_FORMAT_A2B10G10R10_UNORM_PACK32: VkFormat = VkFormat(64);
/// `65`  
pub const VK_FORMAT_A2B10G10R10_SNORM_PACK32: VkFormat = VkFormat(65);
/// `66`  
pub const VK_FORMAT_A2B10G10R10_USCALED_PACK32: VkFormat = VkFormat(66);
/// `67`  
pub const VK_FORMAT_A2B10G10R10_SSCALED_PACK32: VkFormat = VkFormat(67);
/// `68`  
pub const VK_FORMAT_A2B10G10R10_UINT_PACK32: VkFormat = VkFormat(68);
/// `69`  
pub const VK_FORMAT_A2B10G10R10_SINT_PACK32: VkFormat = VkFormat(69);
/// `70`  
pub const VK_FORMAT_R16_UNORM: VkFormat = VkFormat(70);
/// `71`  
pub const VK_FORMAT_R16_SNORM: VkFormat = VkFormat(71);
/// `72`  
pub const VK_FORMAT_R16_USCALED: VkFormat = VkFormat(72);
/// `73`  
pub const VK_FORMAT_R16_SSCALED: VkFormat = VkFormat(73);
/// `74`  
pub const VK_FORMAT_R16_UINT: VkFormat = VkFormat(74);
/// `75`  
pub const VK_FORMAT_R16_SINT: VkFormat = VkFormat(75);
/// `76`  
pub const VK_FORMAT_R16_SFLOAT: VkFormat = VkFormat(76);
/// `77`  
pub const VK_FORMAT_R16G16_UNORM: VkFormat = VkFormat(77);
/// `78`  
pub const VK_FORMAT_R16G16_SNORM: VkFormat = VkFormat(78);
/// `79`  
pub const VK_FORMAT_R16G16_USCALED: VkFormat = VkFormat(79);
/// `80`  
pub const VK_FORMAT_R16G16_SSCALED: VkFormat = VkFormat(80);
/// `81`  
pub const VK_FORMAT_R16G16_UINT: VkFormat = VkFormat(81);
/// `82`  
pub const VK_FORMAT_R16G16_SINT: VkFormat = VkFormat(82);
/// `83`  
pub const VK_FORMAT_R16G16_SFLOAT: VkFormat = VkFormat(83);
/// `84`  
pub const VK_FORMAT_R16G16B16_UNORM: VkFormat = VkFormat(84);
/// `85`  
pub const VK_FORMAT_R16G16B16_SNORM: VkFormat = VkFormat(85);
/// `86`  
pub const VK_FORMAT_R16G16B16_USCALED: VkFormat = VkFormat(86);
/// `87`  
pub const VK_FORMAT_R16G16B16_SSCALED: VkFormat = VkFormat(87);
/// `88`  
pub const VK_FORMAT_R16G16B16_UINT: VkFormat = VkFormat(88);
/// `89`  
pub const VK_FORMAT_R16G16B16_SINT: VkFormat = VkFormat(89);
/// `90`  
pub const VK_FORMAT_R16G16B16_SFLOAT: VkFormat = VkFormat(90);
/// `91`  
pub const VK_FORMAT_R16G16B16A16_UNORM: VkFormat = VkFormat(91);
/// `92`  
pub const VK_FORMAT_R16G16B16A16_SNORM: VkFormat = VkFormat(92);
/// `93`  
pub const VK_FORMAT_R16G16B16A16_USCALED: VkFormat = VkFormat(93);
/// `94`  
pub const VK_FORMAT_R16G16B16A16_SSCALED: VkFormat = VkFormat(94);
/// `95`  
pub const VK_FORMAT_R16G16B16A16_UINT: VkFormat = VkFormat(95);
/// `96`  
pub const VK_FORMAT_R16G16B16A16_SINT: VkFormat = VkFormat(96);
/// `97`  
pub const VK_FORMAT_R16G16B16A16_SFLOAT: VkFormat = VkFormat(97);
/// `98`  
pub const VK_FORMAT_R32_UINT: VkFormat = VkFormat(98);
/// `99`  
pub const VK_FORMAT_R32_SINT: VkFormat = VkFormat(99);
/// `100`  
pub const VK_FORMAT_R32_SFLOAT: VkFormat = VkFormat(100);
/// `101`  
pub const VK_FORMAT_R32G32_UINT: VkFormat = VkFormat(101);
/// `102`  
pub const VK_FORMAT_R32G32_SINT: VkFormat = VkFormat(102);
/// `103`  
pub const VK_FORMAT_R32G32_SFLOAT: VkFormat = VkFormat(103);
/// `104`  
pub const VK_FORMAT_R32G32B32_UINT: VkFormat = VkFormat(104);
/// `105`  
pub const VK_FORMAT_R32G32B32_SINT: VkFormat = VkFormat(105);
/// `106`  
pub const VK_FORMAT_R32G32B32_SFLOAT: VkFormat = VkFormat(106);
/// `107`  
pub const VK_FORMAT_R32G32B32A32_UINT: VkFormat = VkFormat(107);
/// `108`  
pub const VK_FORMAT_R32G32B32A32_SINT: VkFormat = VkFormat(108);
/// `109`  
pub const VK_FORMAT_R32G32B32A32_SFLOAT: VkFormat = VkFormat(109);
/// `110`  
pub const VK_FORMAT_R64_UINT: VkFormat = VkFormat(110);
/// `111`  
pub const VK_FORMAT_R64_SINT: VkFormat = VkFormat(111);
/// `112`  
pub const VK_FORMAT_R64_SFLOAT: VkFormat = VkFormat(112);
/// `113`  
pub const VK_FORMAT_R64G64_UINT: VkFormat = VkFormat(113);
/// `114`  
pub const VK_FORMAT_R64G64_SINT: VkFormat = VkFormat(114);
/// `115`  
pub const VK_FORMAT_R64G64_SFLOAT: VkFormat = VkFormat(115);
/// `116`  
pub const VK_FORMAT_R64G64B64_UINT: VkFormat = VkFormat(116);
/// `117`  
pub const VK_FORMAT_R64G64B64_SINT: VkFormat = VkFormat(117);
/// `118`  
pub const VK_FORMAT_R64G64B64_SFLOAT: VkFormat = VkFormat(118);
/// `119`  
pub const VK_FORMAT_R64G64B64A64_UINT: VkFormat = VkFormat(119);
/// `120`  
pub const VK_FORMAT_R64G64B64A64_SINT: VkFormat = VkFormat(120);
/// `121`  
pub const VK_FORMAT_R64G64B64A64_SFLOAT: VkFormat = VkFormat(121);
/// `122`  
pub const VK_FORMAT_B10G11R11_UFLOAT_PACK32: VkFormat = VkFormat(122);
/// `123`  
pub const VK_FORMAT_E5B9G9R9_UFLOAT_PACK32: VkFormat = VkFormat(123);
/// `124`  
pub const VK_FORMAT_D16_UNORM: VkFormat = VkFormat(124);
/// `125`  
pub const VK_FORMAT_X8_D24_UNORM_PACK32: VkFormat = VkFormat(125);
/// `126`  
pub const VK_FORMAT_D32_SFLOAT: VkFormat = VkFormat(126);
/// `127`  
pub const VK_FORMAT_S8_UINT: VkFormat = VkFormat(127);
/// `128`  
pub const VK_FORMAT_D16_UNORM_S8_UINT: VkFormat = VkFormat(128);
/// `129`  
pub const VK_FORMAT_D24_UNORM_S8_UINT: VkFormat = VkFormat(129);
/// `130`  
pub const VK_FORMAT_D32_SFLOAT_S8_UINT: VkFormat = VkFormat(130);
/// `131`  
pub const VK_FORMAT_BC1_RGB_UNORM_BLOCK: VkFormat = VkFormat(131);
/// `132`  
pub const VK_FORMAT_BC1_RGB_SRGB_BLOCK: VkFormat = VkFormat(132);
/// `133`  
pub const VK_FORMAT_BC1_RGBA_UNORM_BLOCK: VkFormat = VkFormat(133);
/// `134`  
pub const VK_FORMAT_BC1_RGBA_SRGB_BLOCK: VkFormat = VkFormat(134);
/// `135`  
pub const VK_FORMAT_BC2_UNORM_BLOCK: VkFormat = VkFormat(135);
/// `136`  
pub const VK_FORMAT_BC2_SRGB_BLOCK: VkFormat = VkFormat(136);
/// `137`  
pub const VK_FORMAT_BC3_UNORM_BLOCK: VkFormat = VkFormat(137);
/// `138`  
pub const VK_FORMAT_BC3_SRGB_BLOCK: VkFormat = VkFormat(138);
/// `139`  
pub const VK_FORMAT_BC4_UNORM_BLOCK: VkFormat = VkFormat(139);
/// `140`  
pub const VK_FORMAT_BC4_SNORM_BLOCK: VkFormat = VkFormat(140);
/// `141`  
pub const VK_FORMAT_BC5_UNORM_BLOCK: VkFormat = VkFormat(141);
/// `142`  
pub const VK_FORMAT_BC5_SNORM_BLOCK: VkFormat = VkFormat(142);
/// `143`  
pub const VK_FORMAT_BC6H_UFLOAT_BLOCK: VkFormat = VkFormat(143);
/// `144`  
pub const VK_FORMAT_BC6H_SFLOAT_BLOCK: VkFormat = VkFormat(144);
/// `145`  
pub const VK_FORMAT_BC7_UNORM_BLOCK: VkFormat = VkFormat(145);
/// `146`  
pub const VK_FORMAT_BC7_SRGB_BLOCK: VkFormat = VkFormat(146);
/// `147`  
pub const VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK: VkFormat = VkFormat(147);
/// `148`  
pub const VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK: VkFormat = VkFormat(148);
/// `149`  
pub const VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK: VkFormat = VkFormat(149);
/// `150`  
pub const VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK: VkFormat = VkFormat(150);
/// `151`  
pub const VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK: VkFormat = VkFormat(151);
/// `152`  
pub const VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK: VkFormat = VkFormat(152);
/// `153`  
pub const VK_FORMAT_EAC_R11_UNORM_BLOCK: VkFormat = VkFormat(153);
/// `154`  
pub const VK_FORMAT_EAC_R11_SNORM_BLOCK: VkFormat = VkFormat(154);
/// `155`  
pub const VK_FORMAT_EAC_R11G11_UNORM_BLOCK: VkFormat = VkFormat(155);
/// `156`  
pub const VK_FORMAT_EAC_R11G11_SNORM_BLOCK: VkFormat = VkFormat(156);
/// `157`  
pub const VK_FORMAT_ASTC_4x4_UNORM_BLOCK: VkFormat = VkFormat(157);
/// `158`  
pub const VK_FORMAT_ASTC_4x4_SRGB_BLOCK: VkFormat = VkFormat(158);
/// `159`  
pub const VK_FORMAT_ASTC_5x4_UNORM_BLOCK: VkFormat = VkFormat(159);
/// `160`  
pub const VK_FORMAT_ASTC_5x4_SRGB_BLOCK: VkFormat = VkFormat(160);
/// `161`  
pub const VK_FORMAT_ASTC_5x5_UNORM_BLOCK: VkFormat = VkFormat(161);
/// `162`  
pub const VK_FORMAT_ASTC_5x5_SRGB_BLOCK: VkFormat = VkFormat(162);
/// `163`  
pub const VK_FORMAT_ASTC_6x5_UNORM_BLOCK: VkFormat = VkFormat(163);
/// `164`  
pub const VK_FORMAT_ASTC_6x5_SRGB_BLOCK: VkFormat = VkFormat(164);
/// `165`  
pub const VK_FORMAT_ASTC_6x6_UNORM_BLOCK: VkFormat = VkFormat(165);
/// `166`  
pub const VK_FORMAT_ASTC_6x6_SRGB_BLOCK: VkFormat = VkFormat(166);
/// `167`  
pub const VK_FORMAT_ASTC_8x5_UNORM_BLOCK: VkFormat = VkFormat(167);
/// `168`  
pub const VK_FORMAT_ASTC_8x5_SRGB_BLOCK: VkFormat = VkFormat(168);
/// `169`  
pub const VK_FORMAT_ASTC_8x6_UNORM_BLOCK: VkFormat = VkFormat(169);
/// `170`  
pub const VK_FORMAT_ASTC_8x6_SRGB_BLOCK: VkFormat = VkFormat(170);
/// `171`  
pub const VK_FORMAT_ASTC_8x8_UNORM_BLOCK: VkFormat = VkFormat(171);
/// `172`  
pub const VK_FORMAT_ASTC_8x8_SRGB_BLOCK: VkFormat = VkFormat(172);
/// `173`  
pub const VK_FORMAT_ASTC_10x5_UNORM_BLOCK: VkFormat = VkFormat(173);
/// `174`  
pub const VK_FORMAT_ASTC_10x5_SRGB_BLOCK: VkFormat = VkFormat(174);
/// `175`  
pub const VK_FORMAT_ASTC_10x6_UNORM_BLOCK: VkFormat = VkFormat(175);
/// `176`  
pub const VK_FORMAT_ASTC_10x6_SRGB_BLOCK: VkFormat = VkFormat(176);
/// `177`  
pub const VK_FORMAT_ASTC_10x8_UNORM_BLOCK: VkFormat = VkFormat(177);
/// `178`  
pub const VK_FORMAT_ASTC_10x8_SRGB_BLOCK: VkFormat = VkFormat(178);
/// `179`  
pub const VK_FORMAT_ASTC_10x10_UNORM_BLOCK: VkFormat = VkFormat(179);
/// `180`  
pub const VK_FORMAT_ASTC_10x10_SRGB_BLOCK: VkFormat = VkFormat(180);
/// `181`  
pub const VK_FORMAT_ASTC_12x10_UNORM_BLOCK: VkFormat = VkFormat(181);
/// `182`  
pub const VK_FORMAT_ASTC_12x10_SRGB_BLOCK: VkFormat = VkFormat(182);
/// `183`  
pub const VK_FORMAT_ASTC_12x12_UNORM_BLOCK: VkFormat = VkFormat(183);
/// `184`  
pub const VK_FORMAT_ASTC_12x12_SRGB_BLOCK: VkFormat = VkFormat(184);
/// `1000156000`  
pub const VK_FORMAT_G8B8G8R8_422_UNORM: VkFormat = VkFormat(1000156000);
/// `1000156001`  
pub const VK_FORMAT_B8G8R8G8_422_UNORM: VkFormat = VkFormat(1000156001);
/// `1000156002`  
pub const VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM: VkFormat = VkFormat(1000156002);
/// `1000156003`  
pub const VK_FORMAT_G8_B8R8_2PLANE_420_UNORM: VkFormat = VkFormat(1000156003);
/// `1000156004`  
pub const VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM: VkFormat = VkFormat(1000156004);
/// `1000156005`  
pub const VK_FORMAT_G8_B8R8_2PLANE_422_UNORM: VkFormat = VkFormat(1000156005);
/// `1000156006`  
pub const VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM: VkFormat = VkFormat(1000156006);
/// `1000156007`  
pub const VK_FORMAT_R10X6_UNORM_PACK16: VkFormat = VkFormat(1000156007);
/// `1000156008`  
pub const VK_FORMAT_R10X6G10X6_UNORM_2PACK16: VkFormat = VkFormat(1000156008);
/// `1000156009`  
pub const VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16: VkFormat = VkFormat(1000156009);
/// `1000156010`  
pub const VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16: VkFormat = VkFormat(1000156010);
/// `1000156011`  
pub const VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16: VkFormat = VkFormat(1000156011);
/// `1000156012`  
pub const VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16: VkFormat = VkFormat(1000156012);
/// `1000156013`  
pub const VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16: VkFormat = VkFormat(1000156013);
/// `1000156014`  
pub const VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16: VkFormat = VkFormat(1000156014);
/// `1000156015`  
pub const VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16: VkFormat = VkFormat(1000156015);
/// `1000156016`  
pub const VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16: VkFormat = VkFormat(1000156016);
/// `1000156017`  
pub const VK_FORMAT_R12X4_UNORM_PACK16: VkFormat = VkFormat(1000156017);
/// `1000156018`  
pub const VK_FORMAT_R12X4G12X4_UNORM_2PACK16: VkFormat = VkFormat(1000156018);
/// `1000156019`  
pub const VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16: VkFormat = VkFormat(1000156019);
/// `1000156020`  
pub const VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16: VkFormat = VkFormat(1000156020);
/// `1000156021`  
pub const VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16: VkFormat = VkFormat(1000156021);
/// `1000156022`  
pub const VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16: VkFormat = VkFormat(1000156022);
/// `1000156023`  
pub const VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16: VkFormat = VkFormat(1000156023);
/// `1000156024`  
pub const VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16: VkFormat = VkFormat(1000156024);
/// `1000156025`  
pub const VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16: VkFormat = VkFormat(1000156025);
/// `1000156026`  
pub const VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16: VkFormat = VkFormat(1000156026);
/// `1000156027`  
pub const VK_FORMAT_G16B16G16R16_422_UNORM: VkFormat = VkFormat(1000156027);
/// `1000156028`  
pub const VK_FORMAT_B16G16R16G16_422_UNORM: VkFormat = VkFormat(1000156028);
/// `1000156029`  
pub const VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM: VkFormat = VkFormat(1000156029);
/// `1000156030`  
pub const VK_FORMAT_G16_B16R16_2PLANE_420_UNORM: VkFormat = VkFormat(1000156030);
/// `1000156031`  
pub const VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM: VkFormat = VkFormat(1000156031);
/// `1000156032`  
pub const VK_FORMAT_G16_B16R16_2PLANE_422_UNORM: VkFormat = VkFormat(1000156032);
/// `1000156033`  
pub const VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM: VkFormat = VkFormat(1000156033);
/// `1000330000`  
pub const VK_FORMAT_G8_B8R8_2PLANE_444_UNORM: VkFormat = VkFormat(1000330000);
/// `1000330001`  
pub const VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16: VkFormat = VkFormat(1000330001);
/// `1000330002`  
pub const VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16: VkFormat = VkFormat(1000330002);
/// `1000330003`  
pub const VK_FORMAT_G16_B16R16_2PLANE_444_UNORM: VkFormat = VkFormat(1000330003);
/// `1000340000`  
pub const VK_FORMAT_A4R4G4B4_UNORM_PACK16: VkFormat = VkFormat(1000340000);
/// `1000340001`  
pub const VK_FORMAT_A4B4G4R4_UNORM_PACK16: VkFormat = VkFormat(1000340001);
/// `1000066000`  
pub const VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK: VkFormat = VkFormat(1000066000);
/// `1000066001`  
pub const VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK: VkFormat = VkFormat(1000066001);
/// `1000066002`  
pub const VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK: VkFormat = VkFormat(1000066002);
/// `1000066003`  
pub const VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK: VkFormat = VkFormat(1000066003);
/// `1000066004`  
pub const VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK: VkFormat = VkFormat(1000066004);
/// `1000066005`  
pub const VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK: VkFormat = VkFormat(1000066005);
/// `1000066006`  
pub const VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK: VkFormat = VkFormat(1000066006);
/// `1000066007`  
pub const VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK: VkFormat = VkFormat(1000066007);
/// `1000066008`  
pub const VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK: VkFormat = VkFormat(1000066008);
/// `1000066009`  
pub const VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK: VkFormat = VkFormat(1000066009);
/// `1000066010`  
pub const VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK: VkFormat = VkFormat(1000066010);
/// `1000066011`  
pub const VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK: VkFormat = VkFormat(1000066011);
/// `1000066012`  
pub const VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK: VkFormat = VkFormat(1000066012);
/// `1000066013`  
pub const VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK: VkFormat = VkFormat(1000066013);
/// `1000470000`  
pub const VK_FORMAT_A1B5G5R5_UNORM_PACK16: VkFormat = VkFormat(1000470000);
/// `1000470001`  
pub const VK_FORMAT_A8_UNORM: VkFormat = VkFormat(1000470001);
/// `1000054000`  
pub const VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG: VkFormat = VkFormat(1000054000);
/// `1000054001`  
pub const VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG: VkFormat = VkFormat(1000054001);
/// `1000054002`  
pub const VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG: VkFormat = VkFormat(1000054002);
/// `1000054003`  
pub const VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG: VkFormat = VkFormat(1000054003);
/// `1000054004`  
pub const VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG: VkFormat = VkFormat(1000054004);
/// `1000054005`  
pub const VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG: VkFormat = VkFormat(1000054005);
/// `1000054006`  
pub const VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG: VkFormat = VkFormat(1000054006);
/// `1000054007`  
pub const VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG: VkFormat = VkFormat(1000054007);
/// `VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK`  
pub const VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK_EXT: VkFormat = VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK;
/// `VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK`  
pub const VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK_EXT: VkFormat = VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK;
/// `VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK`  
pub const VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK_EXT: VkFormat = VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK;
/// `VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK`  
pub const VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK_EXT: VkFormat = VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK;
/// `VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK`  
pub const VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK_EXT: VkFormat = VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK;
/// `VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK`  
pub const VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK_EXT: VkFormat = VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK;
/// `VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK`  
pub const VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK_EXT: VkFormat = VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK;
/// `VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK`  
pub const VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK_EXT: VkFormat = VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK;
/// `VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK`  
pub const VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK_EXT: VkFormat = VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK;
/// `VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK`  
pub const VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK_EXT: VkFormat = VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK;
/// `VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK`  
pub const VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK_EXT: VkFormat = VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK;
/// `VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK`  
pub const VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK_EXT: VkFormat = VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK;
/// `VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK`  
pub const VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK_EXT: VkFormat = VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK;
/// `VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK`  
pub const VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK_EXT: VkFormat = VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK;
/// `VK_FORMAT_G8B8G8R8_422_UNORM`  
pub const VK_FORMAT_G8B8G8R8_422_UNORM_KHR: VkFormat = VK_FORMAT_G8B8G8R8_422_UNORM;
/// `VK_FORMAT_B8G8R8G8_422_UNORM`  
pub const VK_FORMAT_B8G8R8G8_422_UNORM_KHR: VkFormat = VK_FORMAT_B8G8R8G8_422_UNORM;
/// `VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM`  
pub const VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM_KHR: VkFormat = VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM;
/// `VK_FORMAT_G8_B8R8_2PLANE_420_UNORM`  
pub const VK_FORMAT_G8_B8R8_2PLANE_420_UNORM_KHR: VkFormat = VK_FORMAT_G8_B8R8_2PLANE_420_UNORM;
/// `VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM`  
pub const VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM_KHR: VkFormat = VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM;
/// `VK_FORMAT_G8_B8R8_2PLANE_422_UNORM`  
pub const VK_FORMAT_G8_B8R8_2PLANE_422_UNORM_KHR: VkFormat = VK_FORMAT_G8_B8R8_2PLANE_422_UNORM;
/// `VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM`  
pub const VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM_KHR: VkFormat = VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM;
/// `VK_FORMAT_R10X6_UNORM_PACK16`  
pub const VK_FORMAT_R10X6_UNORM_PACK16_KHR: VkFormat = VK_FORMAT_R10X6_UNORM_PACK16;
/// `VK_FORMAT_R10X6G10X6_UNORM_2PACK16`  
pub const VK_FORMAT_R10X6G10X6_UNORM_2PACK16_KHR: VkFormat = VK_FORMAT_R10X6G10X6_UNORM_2PACK16;
/// `VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16`  
pub const VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16_KHR: VkFormat = VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16;
/// `VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16`  
pub const VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16_KHR: VkFormat = VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16;
/// `VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16`  
pub const VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16_KHR: VkFormat = VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16;
/// `VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16`  
pub const VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16_KHR: VkFormat = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16;
/// `VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16`  
pub const VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16_KHR: VkFormat = VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16;
/// `VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16`  
pub const VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16_KHR: VkFormat = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16;
/// `VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16`  
pub const VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16_KHR: VkFormat = VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16;
/// `VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16`  
pub const VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16_KHR: VkFormat = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16;
/// `VK_FORMAT_R12X4_UNORM_PACK16`  
pub const VK_FORMAT_R12X4_UNORM_PACK16_KHR: VkFormat = VK_FORMAT_R12X4_UNORM_PACK16;
/// `VK_FORMAT_R12X4G12X4_UNORM_2PACK16`  
pub const VK_FORMAT_R12X4G12X4_UNORM_2PACK16_KHR: VkFormat = VK_FORMAT_R12X4G12X4_UNORM_2PACK16;
/// `VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16`  
pub const VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16_KHR: VkFormat = VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16;
/// `VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16`  
pub const VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16_KHR: VkFormat = VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16;
/// `VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16`  
pub const VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16_KHR: VkFormat = VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16;
/// `VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16`  
pub const VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16_KHR: VkFormat = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16;
/// `VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16`  
pub const VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16_KHR: VkFormat = VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16;
/// `VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16`  
pub const VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16_KHR: VkFormat = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16;
/// `VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16`  
pub const VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16_KHR: VkFormat = VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16;
/// `VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16`  
pub const VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16_KHR: VkFormat = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16;
/// `VK_FORMAT_G16B16G16R16_422_UNORM`  
pub const VK_FORMAT_G16B16G16R16_422_UNORM_KHR: VkFormat = VK_FORMAT_G16B16G16R16_422_UNORM;
/// `VK_FORMAT_B16G16R16G16_422_UNORM`  
pub const VK_FORMAT_B16G16R16G16_422_UNORM_KHR: VkFormat = VK_FORMAT_B16G16R16G16_422_UNORM;
/// `VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM`  
pub const VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM_KHR: VkFormat = VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM;
/// `VK_FORMAT_G16_B16R16_2PLANE_420_UNORM`  
pub const VK_FORMAT_G16_B16R16_2PLANE_420_UNORM_KHR: VkFormat = VK_FORMAT_G16_B16R16_2PLANE_420_UNORM;
/// `VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM`  
pub const VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM_KHR: VkFormat = VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM;
/// `VK_FORMAT_G16_B16R16_2PLANE_422_UNORM`  
pub const VK_FORMAT_G16_B16R16_2PLANE_422_UNORM_KHR: VkFormat = VK_FORMAT_G16_B16R16_2PLANE_422_UNORM;
/// `VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM`  
pub const VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM_KHR: VkFormat = VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM;
/// `1000288000`  
pub const VK_FORMAT_ASTC_3x3x3_UNORM_BLOCK_EXT: VkFormat = VkFormat(1000288000);
/// `1000288001`  
pub const VK_FORMAT_ASTC_3x3x3_SRGB_BLOCK_EXT: VkFormat = VkFormat(1000288001);
/// `1000288002`  
pub const VK_FORMAT_ASTC_3x3x3_SFLOAT_BLOCK_EXT: VkFormat = VkFormat(1000288002);
/// `1000288003`  
pub const VK_FORMAT_ASTC_4x3x3_UNORM_BLOCK_EXT: VkFormat = VkFormat(1000288003);
/// `1000288004`  
pub const VK_FORMAT_ASTC_4x3x3_SRGB_BLOCK_EXT: VkFormat = VkFormat(1000288004);
/// `1000288005`  
pub const VK_FORMAT_ASTC_4x3x3_SFLOAT_BLOCK_EXT: VkFormat = VkFormat(1000288005);
/// `1000288006`  
pub const VK_FORMAT_ASTC_4x4x3_UNORM_BLOCK_EXT: VkFormat = VkFormat(1000288006);
/// `1000288007`  
pub const VK_FORMAT_ASTC_4x4x3_SRGB_BLOCK_EXT: VkFormat = VkFormat(1000288007);
/// `1000288008`  
pub const VK_FORMAT_ASTC_4x4x3_SFLOAT_BLOCK_EXT: VkFormat = VkFormat(1000288008);
/// `1000288009`  
pub const VK_FORMAT_ASTC_4x4x4_UNORM_BLOCK_EXT: VkFormat = VkFormat(1000288009);
/// `1000288010`  
pub const VK_FORMAT_ASTC_4x4x4_SRGB_BLOCK_EXT: VkFormat = VkFormat(1000288010);
/// `1000288011`  
pub const VK_FORMAT_ASTC_4x4x4_SFLOAT_BLOCK_EXT: VkFormat = VkFormat(1000288011);
/// `1000288012`  
pub const VK_FORMAT_ASTC_5x4x4_UNORM_BLOCK_EXT: VkFormat = VkFormat(1000288012);
/// `1000288013`  
pub const VK_FORMAT_ASTC_5x4x4_SRGB_BLOCK_EXT: VkFormat = VkFormat(1000288013);
/// `1000288014`  
pub const VK_FORMAT_ASTC_5x4x4_SFLOAT_BLOCK_EXT: VkFormat = VkFormat(1000288014);
/// `1000288015`  
pub const VK_FORMAT_ASTC_5x5x4_UNORM_BLOCK_EXT: VkFormat = VkFormat(1000288015);
/// `1000288016`  
pub const VK_FORMAT_ASTC_5x5x4_SRGB_BLOCK_EXT: VkFormat = VkFormat(1000288016);
/// `1000288017`  
pub const VK_FORMAT_ASTC_5x5x4_SFLOAT_BLOCK_EXT: VkFormat = VkFormat(1000288017);
/// `1000288018`  
pub const VK_FORMAT_ASTC_5x5x5_UNORM_BLOCK_EXT: VkFormat = VkFormat(1000288018);
/// `1000288019`  
pub const VK_FORMAT_ASTC_5x5x5_SRGB_BLOCK_EXT: VkFormat = VkFormat(1000288019);
/// `1000288020`  
pub const VK_FORMAT_ASTC_5x5x5_SFLOAT_BLOCK_EXT: VkFormat = VkFormat(1000288020);
/// `1000288021`  
pub const VK_FORMAT_ASTC_6x5x5_UNORM_BLOCK_EXT: VkFormat = VkFormat(1000288021);
/// `1000288022`  
pub const VK_FORMAT_ASTC_6x5x5_SRGB_BLOCK_EXT: VkFormat = VkFormat(1000288022);
/// `1000288023`  
pub const VK_FORMAT_ASTC_6x5x5_SFLOAT_BLOCK_EXT: VkFormat = VkFormat(1000288023);
/// `1000288024`  
pub const VK_FORMAT_ASTC_6x6x5_UNORM_BLOCK_EXT: VkFormat = VkFormat(1000288024);
/// `1000288025`  
pub const VK_FORMAT_ASTC_6x6x5_SRGB_BLOCK_EXT: VkFormat = VkFormat(1000288025);
/// `1000288026`  
pub const VK_FORMAT_ASTC_6x6x5_SFLOAT_BLOCK_EXT: VkFormat = VkFormat(1000288026);
/// `1000288027`  
pub const VK_FORMAT_ASTC_6x6x6_UNORM_BLOCK_EXT: VkFormat = VkFormat(1000288027);
/// `1000288028`  
pub const VK_FORMAT_ASTC_6x6x6_SRGB_BLOCK_EXT: VkFormat = VkFormat(1000288028);
/// `1000288029`  
pub const VK_FORMAT_ASTC_6x6x6_SFLOAT_BLOCK_EXT: VkFormat = VkFormat(1000288029);
/// `VK_FORMAT_G8_B8R8_2PLANE_444_UNORM`  
pub const VK_FORMAT_G8_B8R8_2PLANE_444_UNORM_EXT: VkFormat = VK_FORMAT_G8_B8R8_2PLANE_444_UNORM;
/// `VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16`  
pub const VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16_EXT: VkFormat = VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16;
/// `VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16`  
pub const VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16_EXT: VkFormat = VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16;
/// `VK_FORMAT_G16_B16R16_2PLANE_444_UNORM`  
pub const VK_FORMAT_G16_B16R16_2PLANE_444_UNORM_EXT: VkFormat = VK_FORMAT_G16_B16R16_2PLANE_444_UNORM;
/// `VK_FORMAT_A4R4G4B4_UNORM_PACK16`  
pub const VK_FORMAT_A4R4G4B4_UNORM_PACK16_EXT: VkFormat = VK_FORMAT_A4R4G4B4_UNORM_PACK16;
/// `VK_FORMAT_A4B4G4R4_UNORM_PACK16`  
pub const VK_FORMAT_A4B4G4R4_UNORM_PACK16_EXT: VkFormat = VK_FORMAT_A4B4G4R4_UNORM_PACK16;
/// `1000460000`  
pub const VK_FORMAT_R8_BOOL_ARM: VkFormat = VkFormat(1000460000);
/// `1000460001`  
pub const VK_FORMAT_R16_SFLOAT_FPENCODING_BFLOAT16_ARM: VkFormat = VkFormat(1000460001);
/// `1000460002`  
pub const VK_FORMAT_R8_SFLOAT_FPENCODING_FLOAT8E4M3_ARM: VkFormat = VkFormat(1000460002);
/// `1000460003`  
pub const VK_FORMAT_R8_SFLOAT_FPENCODING_FLOAT8E5M2_ARM: VkFormat = VkFormat(1000460003);
/// `1000464000`  
pub const VK_FORMAT_R16G16_SFIXED5_NV: VkFormat = VkFormat(1000464000);
/// `VK_FORMAT_R16G16_SFIXED5_NV`  
pub const VK_FORMAT_R16G16_S10_5_NV: VkFormat = VK_FORMAT_R16G16_SFIXED5_NV;
/// `VK_FORMAT_A1B5G5R5_UNORM_PACK16`  
pub const VK_FORMAT_A1B5G5R5_UNORM_PACK16_KHR: VkFormat = VK_FORMAT_A1B5G5R5_UNORM_PACK16;
/// `VK_FORMAT_A8_UNORM`  
pub const VK_FORMAT_A8_UNORM_KHR: VkFormat = VK_FORMAT_A8_UNORM;
/// `1000609000`  
pub const VK_FORMAT_R10X6_UINT_PACK16_ARM: VkFormat = VkFormat(1000609000);
/// `1000609001`  
pub const VK_FORMAT_R10X6G10X6_UINT_2PACK16_ARM: VkFormat = VkFormat(1000609001);
/// `1000609002`  
pub const VK_FORMAT_R10X6G10X6B10X6A10X6_UINT_4PACK16_ARM: VkFormat = VkFormat(1000609002);
/// `1000609003`  
pub const VK_FORMAT_R12X4_UINT_PACK16_ARM: VkFormat = VkFormat(1000609003);
/// `1000609004`  
pub const VK_FORMAT_R12X4G12X4_UINT_2PACK16_ARM: VkFormat = VkFormat(1000609004);
/// `1000609005`  
pub const VK_FORMAT_R12X4G12X4B12X4A12X4_UINT_4PACK16_ARM: VkFormat = VkFormat(1000609005);
/// `1000609006`  
pub const VK_FORMAT_R14X2_UINT_PACK16_ARM: VkFormat = VkFormat(1000609006);
/// `1000609007`  
pub const VK_FORMAT_R14X2G14X2_UINT_2PACK16_ARM: VkFormat = VkFormat(1000609007);
/// `1000609008`  
pub const VK_FORMAT_R14X2G14X2B14X2A14X2_UINT_4PACK16_ARM: VkFormat = VkFormat(1000609008);
/// `1000609009`  
pub const VK_FORMAT_R14X2_UNORM_PACK16_ARM: VkFormat = VkFormat(1000609009);
/// `1000609010`  
pub const VK_FORMAT_R14X2G14X2_UNORM_2PACK16_ARM: VkFormat = VkFormat(1000609010);
/// `1000609011`  
pub const VK_FORMAT_R14X2G14X2B14X2A14X2_UNORM_4PACK16_ARM: VkFormat = VkFormat(1000609011);
/// `1000609012`  
pub const VK_FORMAT_G14X2_B14X2R14X2_2PLANE_420_UNORM_3PACK16_ARM: VkFormat = VkFormat(1000609012);
/// `1000609013`  
pub const VK_FORMAT_G14X2_B14X2R14X2_2PLANE_422_UNORM_3PACK16_ARM: VkFormat = VkFormat(1000609013);

impl_enum_display!(VkFormat { VK_FORMAT_UNDEFINED, VK_FORMAT_R4G4_UNORM_PACK8, VK_FORMAT_R4G4B4A4_UNORM_PACK16, VK_FORMAT_B4G4R4A4_UNORM_PACK16, VK_FORMAT_R5G6B5_UNORM_PACK16, VK_FORMAT_B5G6R5_UNORM_PACK16, VK_FORMAT_R5G5B5A1_UNORM_PACK16, VK_FORMAT_B5G5R5A1_UNORM_PACK16, VK_FORMAT_A1R5G5B5_UNORM_PACK16, VK_FORMAT_R8_UNORM, VK_FORMAT_R8_SNORM, VK_FORMAT_R8_USCALED, VK_FORMAT_R8_SSCALED, VK_FORMAT_R8_UINT, VK_FORMAT_R8_SINT, VK_FORMAT_R8_SRGB, VK_FORMAT_R8G8_UNORM, VK_FORMAT_R8G8_SNORM, VK_FORMAT_R8G8_USCALED, VK_FORMAT_R8G8_SSCALED, VK_FORMAT_R8G8_UINT, VK_FORMAT_R8G8_SINT, VK_FORMAT_R8G8_SRGB, VK_FORMAT_R8G8B8_UNORM, VK_FORMAT_R8G8B8_SNORM, VK_FORMAT_R8G8B8_USCALED, VK_FORMAT_R8G8B8_SSCALED, VK_FORMAT_R8G8B8_UINT, VK_FORMAT_R8G8B8_SINT, VK_FORMAT_R8G8B8_SRGB, VK_FORMAT_B8G8R8_UNORM, VK_FORMAT_B8G8R8_SNORM, VK_FORMAT_B8G8R8_USCALED, VK_FORMAT_B8G8R8_SSCALED, VK_FORMAT_B8G8R8_UINT, VK_FORMAT_B8G8R8_SINT, VK_FORMAT_B8G8R8_SRGB, VK_FORMAT_R8G8B8A8_UNORM, VK_FORMAT_R8G8B8A8_SNORM, VK_FORMAT_R8G8B8A8_USCALED, VK_FORMAT_R8G8B8A8_SSCALED, VK_FORMAT_R8G8B8A8_UINT, VK_FORMAT_R8G8B8A8_SINT, VK_FORMAT_R8G8B8A8_SRGB, VK_FORMAT_B8G8R8A8_UNORM, VK_FORMAT_B8G8R8A8_SNORM, VK_FORMAT_B8G8R8A8_USCALED, VK_FORMAT_B8G8R8A8_SSCALED, VK_FORMAT_B8G8R8A8_UINT, VK_FORMAT_B8G8R8A8_SINT, VK_FORMAT_B8G8R8A8_SRGB, VK_FORMAT_A8B8G8R8_UNORM_PACK32, VK_FORMAT_A8B8G8R8_SNORM_PACK32, VK_FORMAT_A8B8G8R8_USCALED_PACK32, VK_FORMAT_A8B8G8R8_SSCALED_PACK32, VK_FORMAT_A8B8G8R8_UINT_PACK32, VK_FORMAT_A8B8G8R8_SINT_PACK32, VK_FORMAT_A8B8G8R8_SRGB_PACK32, VK_FORMAT_A2R10G10B10_UNORM_PACK32, VK_FORMAT_A2R10G10B10_SNORM_PACK32, VK_FORMAT_A2R10G10B10_USCALED_PACK32, VK_FORMAT_A2R10G10B10_SSCALED_PACK32, VK_FORMAT_A2R10G10B10_UINT_PACK32, VK_FORMAT_A2R10G10B10_SINT_PACK32, VK_FORMAT_A2B10G10R10_UNORM_PACK32, VK_FORMAT_A2B10G10R10_SNORM_PACK32, VK_FORMAT_A2B10G10R10_USCALED_PACK32, VK_FORMAT_A2B10G10R10_SSCALED_PACK32, VK_FORMAT_A2B10G10R10_UINT_PACK32, VK_FORMAT_A2B10G10R10_SINT_PACK32, VK_FORMAT_R16_UNORM, VK_FORMAT_R16_SNORM, VK_FORMAT_R16_USCALED, VK_FORMAT_R16_SSCALED, VK_FORMAT_R16_UINT, VK_FORMAT_R16_SINT, VK_FORMAT_R16_SFLOAT, VK_FORMAT_R16G16_UNORM, VK_FORMAT_R16G16_SNORM, VK_FORMAT_R16G16_USCALED, VK_FORMAT_R16G16_SSCALED, VK_FORMAT_R16G16_UINT, VK_FORMAT_R16G16_SINT, VK_FORMAT_R16G16_SFLOAT, VK_FORMAT_R16G16B16_UNORM, VK_FORMAT_R16G16B16_SNORM, VK_FORMAT_R16G16B16_USCALED, VK_FORMAT_R16G16B16_SSCALED, VK_FORMAT_R16G16B16_UINT, VK_FORMAT_R16G16B16_SINT, VK_FORMAT_R16G16B16_SFLOAT, VK_FORMAT_R16G16B16A16_UNORM, VK_FORMAT_R16G16B16A16_SNORM, VK_FORMAT_R16G16B16A16_USCALED, VK_FORMAT_R16G16B16A16_SSCALED, VK_FORMAT_R16G16B16A16_UINT, VK_FORMAT_R16G16B16A16_SINT, VK_FORMAT_R16G16B16A16_SFLOAT, VK_FORMAT_R32_UINT, VK_FORMAT_R32_SINT, VK_FORMAT_R32_SFLOAT, VK_FORMAT_R32G32_UINT, VK_FORMAT_R32G32_SINT, VK_FORMAT_R32G32_SFLOAT, VK_FORMAT_R32G32B32_UINT, VK_FORMAT_R32G32B32_SINT, VK_FORMAT_R32G32B32_SFLOAT, VK_FORMAT_R32G32B32A32_UINT, VK_FORMAT_R32G32B32A32_SINT, VK_FORMAT_R32G32B32A32_SFLOAT, VK_FORMAT_R64_UINT, VK_FORMAT_R64_SINT, VK_FORMAT_R64_SFLOAT, VK_FORMAT_R64G64_UINT, VK_FORMAT_R64G64_SINT, VK_FORMAT_R64G64_SFLOAT, VK_FORMAT_R64G64B64_UINT, VK_FORMAT_R64G64B64_SINT, VK_FORMAT_R64G64B64_SFLOAT, VK_FORMAT_R64G64B64A64_UINT, VK_FORMAT_R64G64B64A64_SINT, VK_FORMAT_R64G64B64A64_SFLOAT, VK_FORMAT_B10G11R11_UFLOAT_PACK32, VK_FORMAT_E5B9G9R9_UFLOAT_PACK32, VK_FORMAT_D16_UNORM, VK_FORMAT_X8_D24_UNORM_PACK32, VK_FORMAT_D32_SFLOAT, VK_FORMAT_S8_UINT, VK_FORMAT_D16_UNORM_S8_UINT, VK_FORMAT_D24_UNORM_S8_UINT, VK_FORMAT_D32_SFLOAT_S8_UINT, VK_FORMAT_BC1_RGB_UNORM_BLOCK, VK_FORMAT_BC1_RGB_SRGB_BLOCK, VK_FORMAT_BC1_RGBA_UNORM_BLOCK, VK_FORMAT_BC1_RGBA_SRGB_BLOCK, VK_FORMAT_BC2_UNORM_BLOCK, VK_FORMAT_BC2_SRGB_BLOCK, VK_FORMAT_BC3_UNORM_BLOCK, VK_FORMAT_BC3_SRGB_BLOCK, VK_FORMAT_BC4_UNORM_BLOCK, VK_FORMAT_BC4_SNORM_BLOCK, VK_FORMAT_BC5_UNORM_BLOCK, VK_FORMAT_BC5_SNORM_BLOCK, VK_FORMAT_BC6H_UFLOAT_BLOCK, VK_FORMAT_BC6H_SFLOAT_BLOCK, VK_FORMAT_BC7_UNORM_BLOCK, VK_FORMAT_BC7_SRGB_BLOCK, VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK, VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK, VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK, VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK, VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK, VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK, VK_FORMAT_EAC_R11_UNORM_BLOCK, VK_FORMAT_EAC_R11_SNORM_BLOCK, VK_FORMAT_EAC_R11G11_UNORM_BLOCK, VK_FORMAT_EAC_R11G11_SNORM_BLOCK, VK_FORMAT_ASTC_4x4_UNORM_BLOCK, VK_FORMAT_ASTC_4x4_SRGB_BLOCK, VK_FORMAT_ASTC_5x4_UNORM_BLOCK, VK_FORMAT_ASTC_5x4_SRGB_BLOCK, VK_FORMAT_ASTC_5x5_UNORM_BLOCK, VK_FORMAT_ASTC_5x5_SRGB_BLOCK, VK_FORMAT_ASTC_6x5_UNORM_BLOCK, VK_FORMAT_ASTC_6x5_SRGB_BLOCK, VK_FORMAT_ASTC_6x6_UNORM_BLOCK, VK_FORMAT_ASTC_6x6_SRGB_BLOCK, VK_FORMAT_ASTC_8x5_UNORM_BLOCK, VK_FORMAT_ASTC_8x5_SRGB_BLOCK, VK_FORMAT_ASTC_8x6_UNORM_BLOCK, VK_FORMAT_ASTC_8x6_SRGB_BLOCK, VK_FORMAT_ASTC_8x8_UNORM_BLOCK, VK_FORMAT_ASTC_8x8_SRGB_BLOCK, VK_FORMAT_ASTC_10x5_UNORM_BLOCK, VK_FORMAT_ASTC_10x5_SRGB_BLOCK, VK_FORMAT_ASTC_10x6_UNORM_BLOCK, VK_FORMAT_ASTC_10x6_SRGB_BLOCK, VK_FORMAT_ASTC_10x8_UNORM_BLOCK, VK_FORMAT_ASTC_10x8_SRGB_BLOCK, VK_FORMAT_ASTC_10x10_UNORM_BLOCK, VK_FORMAT_ASTC_10x10_SRGB_BLOCK, VK_FORMAT_ASTC_12x10_UNORM_BLOCK, VK_FORMAT_ASTC_12x10_SRGB_BLOCK, VK_FORMAT_ASTC_12x12_UNORM_BLOCK, VK_FORMAT_ASTC_12x12_SRGB_BLOCK, VK_FORMAT_G8B8G8R8_422_UNORM, VK_FORMAT_B8G8R8G8_422_UNORM, VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM, VK_FORMAT_G8_B8R8_2PLANE_420_UNORM, VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM, VK_FORMAT_G8_B8R8_2PLANE_422_UNORM, VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM, VK_FORMAT_R10X6_UNORM_PACK16, VK_FORMAT_R10X6G10X6_UNORM_2PACK16, VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16, VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16, VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16, VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16, VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16, VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16, VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16, VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16, VK_FORMAT_R12X4_UNORM_PACK16, VK_FORMAT_R12X4G12X4_UNORM_2PACK16, VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16, VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16, VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16, VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16, VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16, VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16, VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16, VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16, VK_FORMAT_G16B16G16R16_422_UNORM, VK_FORMAT_B16G16R16G16_422_UNORM, VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM, VK_FORMAT_G16_B16R16_2PLANE_420_UNORM, VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM, VK_FORMAT_G16_B16R16_2PLANE_422_UNORM, VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM, VK_FORMAT_G8_B8R8_2PLANE_444_UNORM, VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16, VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16, VK_FORMAT_G16_B16R16_2PLANE_444_UNORM, VK_FORMAT_A4R4G4B4_UNORM_PACK16, VK_FORMAT_A4B4G4R4_UNORM_PACK16, VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK, VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK, VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK, VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK, VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK, VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK, VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK, VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK, VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK, VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK, VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK, VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK, VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK, VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK, VK_FORMAT_A1B5G5R5_UNORM_PACK16, VK_FORMAT_A8_UNORM, VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG, VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG, VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG, VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG, VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG, VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG, VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG, VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG, VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK_EXT, VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK_EXT, VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK_EXT, VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK_EXT, VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK_EXT, VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK_EXT, VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK_EXT, VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK_EXT, VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK_EXT, VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK_EXT, VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK_EXT, VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK_EXT, VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK_EXT, VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK_EXT, VK_FORMAT_G8B8G8R8_422_UNORM_KHR, VK_FORMAT_B8G8R8G8_422_UNORM_KHR, VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM_KHR, VK_FORMAT_G8_B8R8_2PLANE_420_UNORM_KHR, VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM_KHR, VK_FORMAT_G8_B8R8_2PLANE_422_UNORM_KHR, VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM_KHR, VK_FORMAT_R10X6_UNORM_PACK16_KHR, VK_FORMAT_R10X6G10X6_UNORM_2PACK16_KHR, VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16_KHR, VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16_KHR, VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16_KHR, VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16_KHR, VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16_KHR, VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16_KHR, VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16_KHR, VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16_KHR, VK_FORMAT_R12X4_UNORM_PACK16_KHR, VK_FORMAT_R12X4G12X4_UNORM_2PACK16_KHR, VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16_KHR, VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16_KHR, VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16_KHR, VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16_KHR, VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16_KHR, VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16_KHR, VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16_KHR, VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16_KHR, VK_FORMAT_G16B16G16R16_422_UNORM_KHR, VK_FORMAT_B16G16R16G16_422_UNORM_KHR, VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM_KHR, VK_FORMAT_G16_B16R16_2PLANE_420_UNORM_KHR, VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM_KHR, VK_FORMAT_G16_B16R16_2PLANE_422_UNORM_KHR, VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM_KHR, VK_FORMAT_ASTC_3x3x3_UNORM_BLOCK_EXT, VK_FORMAT_ASTC_3x3x3_SRGB_BLOCK_EXT, VK_FORMAT_ASTC_3x3x3_SFLOAT_BLOCK_EXT, VK_FORMAT_ASTC_4x3x3_UNORM_BLOCK_EXT, VK_FORMAT_ASTC_4x3x3_SRGB_BLOCK_EXT, VK_FORMAT_ASTC_4x3x3_SFLOAT_BLOCK_EXT, VK_FORMAT_ASTC_4x4x3_UNORM_BLOCK_EXT, VK_FORMAT_ASTC_4x4x3_SRGB_BLOCK_EXT, VK_FORMAT_ASTC_4x4x3_SFLOAT_BLOCK_EXT, VK_FORMAT_ASTC_4x4x4_UNORM_BLOCK_EXT, VK_FORMAT_ASTC_4x4x4_SRGB_BLOCK_EXT, VK_FORMAT_ASTC_4x4x4_SFLOAT_BLOCK_EXT, VK_FORMAT_ASTC_5x4x4_UNORM_BLOCK_EXT, VK_FORMAT_ASTC_5x4x4_SRGB_BLOCK_EXT, VK_FORMAT_ASTC_5x4x4_SFLOAT_BLOCK_EXT, VK_FORMAT_ASTC_5x5x4_UNORM_BLOCK_EXT, VK_FORMAT_ASTC_5x5x4_SRGB_BLOCK_EXT, VK_FORMAT_ASTC_5x5x4_SFLOAT_BLOCK_EXT, VK_FORMAT_ASTC_5x5x5_UNORM_BLOCK_EXT, VK_FORMAT_ASTC_5x5x5_SRGB_BLOCK_EXT, VK_FORMAT_ASTC_5x5x5_SFLOAT_BLOCK_EXT, VK_FORMAT_ASTC_6x5x5_UNORM_BLOCK_EXT, VK_FORMAT_ASTC_6x5x5_SRGB_BLOCK_EXT, VK_FORMAT_ASTC_6x5x5_SFLOAT_BLOCK_EXT, VK_FORMAT_ASTC_6x6x5_UNORM_BLOCK_EXT, VK_FORMAT_ASTC_6x6x5_SRGB_BLOCK_EXT, VK_FORMAT_ASTC_6x6x5_SFLOAT_BLOCK_EXT, VK_FORMAT_ASTC_6x6x6_UNORM_BLOCK_EXT, VK_FORMAT_ASTC_6x6x6_SRGB_BLOCK_EXT, VK_FORMAT_ASTC_6x6x6_SFLOAT_BLOCK_EXT, VK_FORMAT_G8_B8R8_2PLANE_444_UNORM_EXT, VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16_EXT, VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16_EXT, VK_FORMAT_G16_B16R16_2PLANE_444_UNORM_EXT, VK_FORMAT_A4R4G4B4_UNORM_PACK16_EXT, VK_FORMAT_A4B4G4R4_UNORM_PACK16_EXT, VK_FORMAT_R8_BOOL_ARM, VK_FORMAT_R16_SFLOAT_FPENCODING_BFLOAT16_ARM, VK_FORMAT_R8_SFLOAT_FPENCODING_FLOAT8E4M3_ARM, VK_FORMAT_R8_SFLOAT_FPENCODING_FLOAT8E5M2_ARM, VK_FORMAT_R16G16_SFIXED5_NV, VK_FORMAT_R16G16_S10_5_NV, VK_FORMAT_A1B5G5R5_UNORM_PACK16_KHR, VK_FORMAT_A8_UNORM_KHR, VK_FORMAT_R10X6_UINT_PACK16_ARM, VK_FORMAT_R10X6G10X6_UINT_2PACK16_ARM, VK_FORMAT_R10X6G10X6B10X6A10X6_UINT_4PACK16_ARM, VK_FORMAT_R12X4_UINT_PACK16_ARM, VK_FORMAT_R12X4G12X4_UINT_2PACK16_ARM, VK_FORMAT_R12X4G12X4B12X4A12X4_UINT_4PACK16_ARM, VK_FORMAT_R14X2_UINT_PACK16_ARM, VK_FORMAT_R14X2G14X2_UINT_2PACK16_ARM, VK_FORMAT_R14X2G14X2B14X2A14X2_UINT_4PACK16_ARM, VK_FORMAT_R14X2_UNORM_PACK16_ARM, VK_FORMAT_R14X2G14X2_UNORM_2PACK16_ARM, VK_FORMAT_R14X2G14X2B14X2A14X2_UNORM_4PACK16_ARM, VK_FORMAT_G14X2_B14X2R14X2_2PLANE_420_UNORM_3PACK16_ARM, VK_FORMAT_G14X2_B14X2R14X2_2PLANE_422_UNORM_3PACK16_ARM });

flags!(VkFormatFeatureFlags);
from_into_transparent!(VkFormatFeatureFlags: i32);
/// `VkFormatFeatureFlags`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkFormatFeatureFlags(pub i32);

/// `1 << 0`  
/// 
/// Format can be used for sampled images (SAMPLED_IMAGE and COMBINED_IMAGE_SAMPLER descriptor types)
pub const VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT: VkFormatFeatureFlags = VkFormatFeatureFlags(1 << 0);
/// `1 << 1`  
/// 
/// Format can be used for storage images (STORAGE_IMAGE descriptor type)
pub const VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT: VkFormatFeatureFlags = VkFormatFeatureFlags(1 << 1);
/// `1 << 2`  
/// 
/// Format supports atomic operations in case it is used for storage images
pub const VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT: VkFormatFeatureFlags = VkFormatFeatureFlags(1 << 2);
/// `1 << 3`  
/// 
/// Format can be used for uniform texel buffers (TBOs)
pub const VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT: VkFormatFeatureFlags = VkFormatFeatureFlags(1 << 3);
/// `1 << 4`  
/// 
/// Format can be used for storage texel buffers (IBOs)
pub const VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT: VkFormatFeatureFlags = VkFormatFeatureFlags(1 << 4);
/// `1 << 5`  
/// 
/// Format supports atomic operations in case it is used for storage texel buffers
pub const VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT: VkFormatFeatureFlags = VkFormatFeatureFlags(1 << 5);
/// `1 << 6`  
/// 
/// Format can be used for vertex buffers (VBOs)
pub const VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT: VkFormatFeatureFlags = VkFormatFeatureFlags(1 << 6);
/// `1 << 7`  
/// 
/// Format can be used for color attachment images
pub const VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT: VkFormatFeatureFlags = VkFormatFeatureFlags(1 << 7);
/// `1 << 8`  
/// 
/// Format supports blending in case it is used for color attachment images
pub const VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT: VkFormatFeatureFlags = VkFormatFeatureFlags(1 << 8);
/// `1 << 9`  
/// 
/// Format can be used for depth/stencil attachment images
pub const VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT: VkFormatFeatureFlags = VkFormatFeatureFlags(1 << 9);
/// `1 << 10`  
/// 
/// Format can be used as the source image of blits with vkCmdBlitImage
pub const VK_FORMAT_FEATURE_BLIT_SRC_BIT: VkFormatFeatureFlags = VkFormatFeatureFlags(1 << 10);
/// `1 << 11`  
/// 
/// Format can be used as the destination image of blits with vkCmdBlitImage
pub const VK_FORMAT_FEATURE_BLIT_DST_BIT: VkFormatFeatureFlags = VkFormatFeatureFlags(1 << 11);
/// `1 << 12`  
/// 
/// Format can be filtered with VK_FILTER_LINEAR when being sampled
pub const VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT: VkFormatFeatureFlags = VkFormatFeatureFlags(1 << 12);
/// `1 << 14`  
/// 
/// Format can be used as the source image of image transfer commands
pub const VK_FORMAT_FEATURE_TRANSFER_SRC_BIT: VkFormatFeatureFlags = VkFormatFeatureFlags(1 << 14);
/// `1 << 15`  
/// 
/// Format can be used as the destination image of image transfer commands
pub const VK_FORMAT_FEATURE_TRANSFER_DST_BIT: VkFormatFeatureFlags = VkFormatFeatureFlags(1 << 15);
/// `1 << 17`  
/// 
/// Format can have midpoint rather than cosited chroma samples
pub const VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT: VkFormatFeatureFlags = VkFormatFeatureFlags(1 << 17);
/// `1 << 18`  
/// 
/// Format can be used with linear filtering whilst color conversion is enabled
pub const VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT: VkFormatFeatureFlags = VkFormatFeatureFlags(1 << 18);
/// `1 << 19`  
/// 
/// Format can have different chroma, min and mag filters
pub const VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT: VkFormatFeatureFlags = VkFormatFeatureFlags(1 << 19);
/// `1 << 20`  
pub const VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT: VkFormatFeatureFlags = VkFormatFeatureFlags(1 << 20);
/// `1 << 21`  
pub const VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT: VkFormatFeatureFlags = VkFormatFeatureFlags(1 << 21);
/// `1 << 22`  
/// 
/// Format supports disjoint planes
pub const VK_FORMAT_FEATURE_DISJOINT_BIT: VkFormatFeatureFlags = VkFormatFeatureFlags(1 << 22);
/// `1 << 23`  
/// 
/// Format can have cosited rather than midpoint chroma samples
pub const VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT: VkFormatFeatureFlags = VkFormatFeatureFlags(1 << 23);
/// `1 << 16`  
/// 
/// Format can be used with min/max reduction filtering
pub const VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT: VkFormatFeatureFlags = VkFormatFeatureFlags(1 << 16);
/// `VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT`  
/// 
/// Format can be filtered with VK_FILTER_CUBIC_IMG when being sampled
pub const VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG: VkFormatFeatureFlags = VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT;
/// `1 << 25`  
pub const VK_FORMAT_FEATURE_VIDEO_DECODE_OUTPUT_BIT_KHR: VkFormatFeatureFlags = VkFormatFeatureFlags(1 << 25);
/// `1 << 26`  
pub const VK_FORMAT_FEATURE_VIDEO_DECODE_DPB_BIT_KHR: VkFormatFeatureFlags = VkFormatFeatureFlags(1 << 26);
/// `VK_FORMAT_FEATURE_TRANSFER_SRC_BIT`  
pub const VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR: VkFormatFeatureFlags = VK_FORMAT_FEATURE_TRANSFER_SRC_BIT;
/// `VK_FORMAT_FEATURE_TRANSFER_DST_BIT`  
pub const VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR: VkFormatFeatureFlags = VK_FORMAT_FEATURE_TRANSFER_DST_BIT;
/// `VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT`  
pub const VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT_EXT: VkFormatFeatureFlags = VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT;
/// `1 << 29`  
pub const VK_FORMAT_FEATURE_ACCELERATION_STRUCTURE_VERTEX_BUFFER_BIT_KHR: VkFormatFeatureFlags = VkFormatFeatureFlags(1 << 29);
/// `VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT`  
pub const VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT_KHR: VkFormatFeatureFlags = VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT;
/// `VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT`  
pub const VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT_KHR: VkFormatFeatureFlags = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT;
/// `VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT`  
pub const VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT_KHR: VkFormatFeatureFlags = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT;
/// `VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT`  
pub const VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT_KHR: VkFormatFeatureFlags = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT;
/// `VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT`  
pub const VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT_KHR: VkFormatFeatureFlags = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT;
/// `VK_FORMAT_FEATURE_DISJOINT_BIT`  
pub const VK_FORMAT_FEATURE_DISJOINT_BIT_KHR: VkFormatFeatureFlags = VK_FORMAT_FEATURE_DISJOINT_BIT;
/// `VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT`  
pub const VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT_KHR: VkFormatFeatureFlags = VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT;
/// `1 << 13`  
pub const VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT: VkFormatFeatureFlags = VkFormatFeatureFlags(1 << 13);
/// `1 << 24`  
pub const VK_FORMAT_FEATURE_FRAGMENT_DENSITY_MAP_BIT_EXT: VkFormatFeatureFlags = VkFormatFeatureFlags(1 << 24);
/// `1 << 30`  
pub const VK_FORMAT_FEATURE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR: VkFormatFeatureFlags = VkFormatFeatureFlags(1 << 30);
/// `1 << 27`  
pub const VK_FORMAT_FEATURE_VIDEO_ENCODE_INPUT_BIT_KHR: VkFormatFeatureFlags = VkFormatFeatureFlags(1 << 27);
/// `1 << 28`  
pub const VK_FORMAT_FEATURE_VIDEO_ENCODE_DPB_BIT_KHR: VkFormatFeatureFlags = VkFormatFeatureFlags(1 << 28);

impl_flags_display!(VkFormatFeatureFlags { VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT, VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT, VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT, VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT, VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT, VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT, VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT, VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT, VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT, VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT, VK_FORMAT_FEATURE_BLIT_SRC_BIT, VK_FORMAT_FEATURE_BLIT_DST_BIT, VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT, VK_FORMAT_FEATURE_TRANSFER_SRC_BIT, VK_FORMAT_FEATURE_TRANSFER_DST_BIT, VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT, VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT, VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT, VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT, VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT, VK_FORMAT_FEATURE_DISJOINT_BIT, VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT, VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT, VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG, VK_FORMAT_FEATURE_VIDEO_DECODE_OUTPUT_BIT_KHR, VK_FORMAT_FEATURE_VIDEO_DECODE_DPB_BIT_KHR, VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR, VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR, VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT_EXT, VK_FORMAT_FEATURE_ACCELERATION_STRUCTURE_VERTEX_BUFFER_BIT_KHR, VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT_KHR, VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT_KHR, VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT_KHR, VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT_KHR, VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT_KHR, VK_FORMAT_FEATURE_DISJOINT_BIT_KHR, VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT_KHR, VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT, VK_FORMAT_FEATURE_FRAGMENT_DENSITY_MAP_BIT_EXT, VK_FORMAT_FEATURE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR, VK_FORMAT_FEATURE_VIDEO_ENCODE_INPUT_BIT_KHR, VK_FORMAT_FEATURE_VIDEO_ENCODE_DPB_BIT_KHR });

flags!(VkFormatFeatureFlags2);
from_into_transparent!(VkFormatFeatureFlags2: i64);
/// `VkFormatFeatureFlags2`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkFormatFeatureFlags2(pub i64);

/// `1 << 0`  
pub const VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT: VkFormatFeatureFlags2 = VkFormatFeatureFlags2(1 << 0);
/// `1 << 1`  
pub const VK_FORMAT_FEATURE_2_STORAGE_IMAGE_BIT: VkFormatFeatureFlags2 = VkFormatFeatureFlags2(1 << 1);
/// `1 << 2`  
pub const VK_FORMAT_FEATURE_2_STORAGE_IMAGE_ATOMIC_BIT: VkFormatFeatureFlags2 = VkFormatFeatureFlags2(1 << 2);
/// `1 << 3`  
pub const VK_FORMAT_FEATURE_2_UNIFORM_TEXEL_BUFFER_BIT: VkFormatFeatureFlags2 = VkFormatFeatureFlags2(1 << 3);
/// `1 << 4`  
pub const VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_BIT: VkFormatFeatureFlags2 = VkFormatFeatureFlags2(1 << 4);
/// `1 << 5`  
pub const VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_ATOMIC_BIT: VkFormatFeatureFlags2 = VkFormatFeatureFlags2(1 << 5);
/// `1 << 6`  
pub const VK_FORMAT_FEATURE_2_VERTEX_BUFFER_BIT: VkFormatFeatureFlags2 = VkFormatFeatureFlags2(1 << 6);
/// `1 << 7`  
pub const VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BIT: VkFormatFeatureFlags2 = VkFormatFeatureFlags2(1 << 7);
/// `1 << 8`  
pub const VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BLEND_BIT: VkFormatFeatureFlags2 = VkFormatFeatureFlags2(1 << 8);
/// `1 << 9`  
pub const VK_FORMAT_FEATURE_2_DEPTH_STENCIL_ATTACHMENT_BIT: VkFormatFeatureFlags2 = VkFormatFeatureFlags2(1 << 9);
/// `1 << 10`  
pub const VK_FORMAT_FEATURE_2_BLIT_SRC_BIT: VkFormatFeatureFlags2 = VkFormatFeatureFlags2(1 << 10);
/// `1 << 11`  
pub const VK_FORMAT_FEATURE_2_BLIT_DST_BIT: VkFormatFeatureFlags2 = VkFormatFeatureFlags2(1 << 11);
/// `1 << 12`  
pub const VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_LINEAR_BIT: VkFormatFeatureFlags2 = VkFormatFeatureFlags2(1 << 12);
/// `1 << 14`  
pub const VK_FORMAT_FEATURE_2_TRANSFER_SRC_BIT: VkFormatFeatureFlags2 = VkFormatFeatureFlags2(1 << 14);
/// `1 << 15`  
pub const VK_FORMAT_FEATURE_2_TRANSFER_DST_BIT: VkFormatFeatureFlags2 = VkFormatFeatureFlags2(1 << 15);
/// `1 << 16`  
pub const VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_MINMAX_BIT: VkFormatFeatureFlags2 = VkFormatFeatureFlags2(1 << 16);
/// `1 << 17`  
pub const VK_FORMAT_FEATURE_2_MIDPOINT_CHROMA_SAMPLES_BIT: VkFormatFeatureFlags2 = VkFormatFeatureFlags2(1 << 17);
/// `1 << 18`  
pub const VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT: VkFormatFeatureFlags2 = VkFormatFeatureFlags2(1 << 18);
/// `1 << 19`  
pub const VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT: VkFormatFeatureFlags2 = VkFormatFeatureFlags2(1 << 19);
/// `1 << 20`  
pub const VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT: VkFormatFeatureFlags2 = VkFormatFeatureFlags2(1 << 20);
/// `1 << 21`  
pub const VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT: VkFormatFeatureFlags2 = VkFormatFeatureFlags2(1 << 21);
/// `1 << 22`  
pub const VK_FORMAT_FEATURE_2_DISJOINT_BIT: VkFormatFeatureFlags2 = VkFormatFeatureFlags2(1 << 22);
/// `1 << 23`  
pub const VK_FORMAT_FEATURE_2_COSITED_CHROMA_SAMPLES_BIT: VkFormatFeatureFlags2 = VkFormatFeatureFlags2(1 << 23);
/// `1 << 31`  
pub const VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT: VkFormatFeatureFlags2 = VkFormatFeatureFlags2(1 << 31);
/// `1 << 32`  
pub const VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT: VkFormatFeatureFlags2 = VkFormatFeatureFlags2(1 << 32);
/// `1 << 33`  
pub const VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT: VkFormatFeatureFlags2 = VkFormatFeatureFlags2(1 << 33);
/// `1 << 13`  
/// 
/// This is an interaction with EXT_filter_cubic, though not tagged that way
pub const VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_CUBIC_BIT: VkFormatFeatureFlags2 = VkFormatFeatureFlags2(1 << 13);
/// `1 << 46`  
pub const VK_FORMAT_FEATURE_2_HOST_IMAGE_TRANSFER_BIT: VkFormatFeatureFlags2 = VkFormatFeatureFlags2(1 << 46);
/// `1 << 25`  
pub const VK_FORMAT_FEATURE_2_VIDEO_DECODE_OUTPUT_BIT_KHR: VkFormatFeatureFlags2 = VkFormatFeatureFlags2(1 << 25);
/// `1 << 26`  
pub const VK_FORMAT_FEATURE_2_VIDEO_DECODE_DPB_BIT_KHR: VkFormatFeatureFlags2 = VkFormatFeatureFlags2(1 << 26);
/// `1 << 29`  
pub const VK_FORMAT_FEATURE_2_ACCELERATION_STRUCTURE_VERTEX_BUFFER_BIT_KHR: VkFormatFeatureFlags2 = VkFormatFeatureFlags2(1 << 29);
/// `1 << 24`  
pub const VK_FORMAT_FEATURE_2_FRAGMENT_DENSITY_MAP_BIT_EXT: VkFormatFeatureFlags2 = VkFormatFeatureFlags2(1 << 24);
/// `1 << 30`  
pub const VK_FORMAT_FEATURE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR: VkFormatFeatureFlags2 = VkFormatFeatureFlags2(1 << 30);
/// `VK_FORMAT_FEATURE_2_HOST_IMAGE_TRANSFER_BIT`  
/// 
/// Host image copies are supported
pub const VK_FORMAT_FEATURE_2_HOST_IMAGE_TRANSFER_BIT_EXT: VkFormatFeatureFlags2 = VK_FORMAT_FEATURE_2_HOST_IMAGE_TRANSFER_BIT;
/// `1 << 27`  
pub const VK_FORMAT_FEATURE_2_VIDEO_ENCODE_INPUT_BIT_KHR: VkFormatFeatureFlags2 = VkFormatFeatureFlags2(1 << 27);
/// `1 << 28`  
pub const VK_FORMAT_FEATURE_2_VIDEO_ENCODE_DPB_BIT_KHR: VkFormatFeatureFlags2 = VkFormatFeatureFlags2(1 << 28);
/// `VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT`  
pub const VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT_KHR: VkFormatFeatureFlags2 = VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT;
/// `VK_FORMAT_FEATURE_2_STORAGE_IMAGE_BIT`  
pub const VK_FORMAT_FEATURE_2_STORAGE_IMAGE_BIT_KHR: VkFormatFeatureFlags2 = VK_FORMAT_FEATURE_2_STORAGE_IMAGE_BIT;
/// `VK_FORMAT_FEATURE_2_STORAGE_IMAGE_ATOMIC_BIT`  
pub const VK_FORMAT_FEATURE_2_STORAGE_IMAGE_ATOMIC_BIT_KHR: VkFormatFeatureFlags2 = VK_FORMAT_FEATURE_2_STORAGE_IMAGE_ATOMIC_BIT;
/// `VK_FORMAT_FEATURE_2_UNIFORM_TEXEL_BUFFER_BIT`  
pub const VK_FORMAT_FEATURE_2_UNIFORM_TEXEL_BUFFER_BIT_KHR: VkFormatFeatureFlags2 = VK_FORMAT_FEATURE_2_UNIFORM_TEXEL_BUFFER_BIT;
/// `VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_BIT`  
pub const VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_BIT_KHR: VkFormatFeatureFlags2 = VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_BIT;
/// `VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_ATOMIC_BIT`  
pub const VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_ATOMIC_BIT_KHR: VkFormatFeatureFlags2 = VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_ATOMIC_BIT;
/// `VK_FORMAT_FEATURE_2_VERTEX_BUFFER_BIT`  
pub const VK_FORMAT_FEATURE_2_VERTEX_BUFFER_BIT_KHR: VkFormatFeatureFlags2 = VK_FORMAT_FEATURE_2_VERTEX_BUFFER_BIT;
/// `VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BIT`  
pub const VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BIT_KHR: VkFormatFeatureFlags2 = VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BIT;
/// `VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BLEND_BIT`  
pub const VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BLEND_BIT_KHR: VkFormatFeatureFlags2 = VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BLEND_BIT;
/// `VK_FORMAT_FEATURE_2_DEPTH_STENCIL_ATTACHMENT_BIT`  
pub const VK_FORMAT_FEATURE_2_DEPTH_STENCIL_ATTACHMENT_BIT_KHR: VkFormatFeatureFlags2 = VK_FORMAT_FEATURE_2_DEPTH_STENCIL_ATTACHMENT_BIT;
/// `VK_FORMAT_FEATURE_2_BLIT_SRC_BIT`  
pub const VK_FORMAT_FEATURE_2_BLIT_SRC_BIT_KHR: VkFormatFeatureFlags2 = VK_FORMAT_FEATURE_2_BLIT_SRC_BIT;
/// `VK_FORMAT_FEATURE_2_BLIT_DST_BIT`  
pub const VK_FORMAT_FEATURE_2_BLIT_DST_BIT_KHR: VkFormatFeatureFlags2 = VK_FORMAT_FEATURE_2_BLIT_DST_BIT;
/// `VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_LINEAR_BIT`  
pub const VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_LINEAR_BIT_KHR: VkFormatFeatureFlags2 = VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_LINEAR_BIT;
/// `VK_FORMAT_FEATURE_2_TRANSFER_SRC_BIT`  
pub const VK_FORMAT_FEATURE_2_TRANSFER_SRC_BIT_KHR: VkFormatFeatureFlags2 = VK_FORMAT_FEATURE_2_TRANSFER_SRC_BIT;
/// `VK_FORMAT_FEATURE_2_TRANSFER_DST_BIT`  
pub const VK_FORMAT_FEATURE_2_TRANSFER_DST_BIT_KHR: VkFormatFeatureFlags2 = VK_FORMAT_FEATURE_2_TRANSFER_DST_BIT;
/// `VK_FORMAT_FEATURE_2_MIDPOINT_CHROMA_SAMPLES_BIT`  
pub const VK_FORMAT_FEATURE_2_MIDPOINT_CHROMA_SAMPLES_BIT_KHR: VkFormatFeatureFlags2 = VK_FORMAT_FEATURE_2_MIDPOINT_CHROMA_SAMPLES_BIT;
/// `VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT`  
pub const VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT_KHR: VkFormatFeatureFlags2 = VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT;
/// `VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT`  
pub const VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT_KHR: VkFormatFeatureFlags2 = VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT;
/// `VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT`  
pub const VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT_KHR: VkFormatFeatureFlags2 = VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT;
/// `VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT`  
pub const VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT_KHR: VkFormatFeatureFlags2 = VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT;
/// `VK_FORMAT_FEATURE_2_DISJOINT_BIT`  
pub const VK_FORMAT_FEATURE_2_DISJOINT_BIT_KHR: VkFormatFeatureFlags2 = VK_FORMAT_FEATURE_2_DISJOINT_BIT;
/// `VK_FORMAT_FEATURE_2_COSITED_CHROMA_SAMPLES_BIT`  
pub const VK_FORMAT_FEATURE_2_COSITED_CHROMA_SAMPLES_BIT_KHR: VkFormatFeatureFlags2 = VK_FORMAT_FEATURE_2_COSITED_CHROMA_SAMPLES_BIT;
/// `VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT`  
pub const VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT_KHR: VkFormatFeatureFlags2 = VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT;
/// `VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT`  
pub const VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT_KHR: VkFormatFeatureFlags2 = VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT;
/// `VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT`  
pub const VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT_KHR: VkFormatFeatureFlags2 = VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT;
/// `VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_MINMAX_BIT`  
pub const VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_MINMAX_BIT_KHR: VkFormatFeatureFlags2 = VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_MINMAX_BIT;
/// `VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_CUBIC_BIT`  
pub const VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT: VkFormatFeatureFlags2 = VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_CUBIC_BIT;
/// `1 << 51`  
pub const VK_FORMAT_FEATURE_2_ACCELERATION_STRUCTURE_RADIUS_BUFFER_BIT_NV: VkFormatFeatureFlags2 = VkFormatFeatureFlags2(1 << 51);
/// `1 << 38`  
/// 
/// Format support linear image as render target, it cannot be mixed with non linear attachment
pub const VK_FORMAT_FEATURE_2_LINEAR_COLOR_ATTACHMENT_BIT_NV: VkFormatFeatureFlags2 = VkFormatFeatureFlags2(1 << 38);
/// `1 << 34`  
pub const VK_FORMAT_FEATURE_2_WEIGHT_IMAGE_BIT_QCOM: VkFormatFeatureFlags2 = VkFormatFeatureFlags2(1 << 34);
/// `1 << 35`  
pub const VK_FORMAT_FEATURE_2_WEIGHT_SAMPLED_IMAGE_BIT_QCOM: VkFormatFeatureFlags2 = VkFormatFeatureFlags2(1 << 35);
/// `1 << 36`  
pub const VK_FORMAT_FEATURE_2_BLOCK_MATCHING_BIT_QCOM: VkFormatFeatureFlags2 = VkFormatFeatureFlags2(1 << 36);
/// `1 << 37`  
pub const VK_FORMAT_FEATURE_2_BOX_FILTER_SAMPLED_BIT_QCOM: VkFormatFeatureFlags2 = VkFormatFeatureFlags2(1 << 37);
/// `1 << 39`  
pub const VK_FORMAT_FEATURE_2_TENSOR_SHADER_BIT_ARM: VkFormatFeatureFlags2 = VkFormatFeatureFlags2(1 << 39);
/// `1 << 43`  
pub const VK_FORMAT_FEATURE_2_TENSOR_IMAGE_ALIASING_BIT_ARM: VkFormatFeatureFlags2 = VkFormatFeatureFlags2(1 << 43);
/// `1 << 40`  
pub const VK_FORMAT_FEATURE_2_OPTICAL_FLOW_IMAGE_BIT_NV: VkFormatFeatureFlags2 = VkFormatFeatureFlags2(1 << 40);
/// `1 << 41`  
pub const VK_FORMAT_FEATURE_2_OPTICAL_FLOW_VECTOR_BIT_NV: VkFormatFeatureFlags2 = VkFormatFeatureFlags2(1 << 41);
/// `1 << 42`  
pub const VK_FORMAT_FEATURE_2_OPTICAL_FLOW_COST_BIT_NV: VkFormatFeatureFlags2 = VkFormatFeatureFlags2(1 << 42);
/// `1 << 48`  
pub const VK_FORMAT_FEATURE_2_TENSOR_DATA_GRAPH_BIT_ARM: VkFormatFeatureFlags2 = VkFormatFeatureFlags2(1 << 48);
/// `1 << 60`  
pub const VK_FORMAT_FEATURE_2_RESERVED_60_BIT_EXT: VkFormatFeatureFlags2 = VkFormatFeatureFlags2(1 << 60);
/// `1 << 59`  
pub const VK_FORMAT_FEATURE_2_COPY_IMAGE_INDIRECT_DST_BIT_KHR: VkFormatFeatureFlags2 = VkFormatFeatureFlags2(1 << 59);
/// `1 << 49`  
pub const VK_FORMAT_FEATURE_2_VIDEO_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR: VkFormatFeatureFlags2 = VkFormatFeatureFlags2(1 << 49);
/// `1 << 50`  
pub const VK_FORMAT_FEATURE_2_VIDEO_ENCODE_EMPHASIS_MAP_BIT_KHR: VkFormatFeatureFlags2 = VkFormatFeatureFlags2(1 << 50);
/// `1 << 52`  
pub const VK_FORMAT_FEATURE_2_DEPTH_COPY_ON_COMPUTE_QUEUE_BIT_KHR: VkFormatFeatureFlags2 = VkFormatFeatureFlags2(1 << 52);
/// `1 << 53`  
pub const VK_FORMAT_FEATURE_2_DEPTH_COPY_ON_TRANSFER_QUEUE_BIT_KHR: VkFormatFeatureFlags2 = VkFormatFeatureFlags2(1 << 53);
/// `1 << 54`  
pub const VK_FORMAT_FEATURE_2_STENCIL_COPY_ON_COMPUTE_QUEUE_BIT_KHR: VkFormatFeatureFlags2 = VkFormatFeatureFlags2(1 << 54);
/// `1 << 55`  
pub const VK_FORMAT_FEATURE_2_STENCIL_COPY_ON_TRANSFER_QUEUE_BIT_KHR: VkFormatFeatureFlags2 = VkFormatFeatureFlags2(1 << 55);
/// `1 << 56`  
pub const VK_FORMAT_FEATURE_2_RESERVED_56_BIT_ARM: VkFormatFeatureFlags2 = VkFormatFeatureFlags2(1 << 56);
/// `1 << 57`  
pub const VK_FORMAT_FEATURE_2_RESERVED_57_BIT_ARM: VkFormatFeatureFlags2 = VkFormatFeatureFlags2(1 << 57);
/// `1 << 58`  
pub const VK_FORMAT_FEATURE_2_RESERVED_58_BIT_ARM: VkFormatFeatureFlags2 = VkFormatFeatureFlags2(1 << 58);
/// `1 << 47`  
pub const VK_FORMAT_FEATURE_2_RESERVED_47_BIT_ARM: VkFormatFeatureFlags2 = VkFormatFeatureFlags2(1 << 47);
/// `1 << 61`  
pub const VK_FORMAT_FEATURE_2_RESERVED_61_BIT_HUAWEI: VkFormatFeatureFlags2 = VkFormatFeatureFlags2(1 << 61);

impl_flags_display!(VkFormatFeatureFlags2 { VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT, VK_FORMAT_FEATURE_2_STORAGE_IMAGE_BIT, VK_FORMAT_FEATURE_2_STORAGE_IMAGE_ATOMIC_BIT, VK_FORMAT_FEATURE_2_UNIFORM_TEXEL_BUFFER_BIT, VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_BIT, VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_ATOMIC_BIT, VK_FORMAT_FEATURE_2_VERTEX_BUFFER_BIT, VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BIT, VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BLEND_BIT, VK_FORMAT_FEATURE_2_DEPTH_STENCIL_ATTACHMENT_BIT, VK_FORMAT_FEATURE_2_BLIT_SRC_BIT, VK_FORMAT_FEATURE_2_BLIT_DST_BIT, VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_LINEAR_BIT, VK_FORMAT_FEATURE_2_TRANSFER_SRC_BIT, VK_FORMAT_FEATURE_2_TRANSFER_DST_BIT, VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_MINMAX_BIT, VK_FORMAT_FEATURE_2_MIDPOINT_CHROMA_SAMPLES_BIT, VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT, VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT, VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT, VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT, VK_FORMAT_FEATURE_2_DISJOINT_BIT, VK_FORMAT_FEATURE_2_COSITED_CHROMA_SAMPLES_BIT, VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT, VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT, VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT, VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_CUBIC_BIT, VK_FORMAT_FEATURE_2_HOST_IMAGE_TRANSFER_BIT, VK_FORMAT_FEATURE_2_VIDEO_DECODE_OUTPUT_BIT_KHR, VK_FORMAT_FEATURE_2_VIDEO_DECODE_DPB_BIT_KHR, VK_FORMAT_FEATURE_2_ACCELERATION_STRUCTURE_VERTEX_BUFFER_BIT_KHR, VK_FORMAT_FEATURE_2_FRAGMENT_DENSITY_MAP_BIT_EXT, VK_FORMAT_FEATURE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR, VK_FORMAT_FEATURE_2_HOST_IMAGE_TRANSFER_BIT_EXT, VK_FORMAT_FEATURE_2_VIDEO_ENCODE_INPUT_BIT_KHR, VK_FORMAT_FEATURE_2_VIDEO_ENCODE_DPB_BIT_KHR, VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT_KHR, VK_FORMAT_FEATURE_2_STORAGE_IMAGE_BIT_KHR, VK_FORMAT_FEATURE_2_STORAGE_IMAGE_ATOMIC_BIT_KHR, VK_FORMAT_FEATURE_2_UNIFORM_TEXEL_BUFFER_BIT_KHR, VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_BIT_KHR, VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_ATOMIC_BIT_KHR, VK_FORMAT_FEATURE_2_VERTEX_BUFFER_BIT_KHR, VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BIT_KHR, VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BLEND_BIT_KHR, VK_FORMAT_FEATURE_2_DEPTH_STENCIL_ATTACHMENT_BIT_KHR, VK_FORMAT_FEATURE_2_BLIT_SRC_BIT_KHR, VK_FORMAT_FEATURE_2_BLIT_DST_BIT_KHR, VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_LINEAR_BIT_KHR, VK_FORMAT_FEATURE_2_TRANSFER_SRC_BIT_KHR, VK_FORMAT_FEATURE_2_TRANSFER_DST_BIT_KHR, VK_FORMAT_FEATURE_2_MIDPOINT_CHROMA_SAMPLES_BIT_KHR, VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT_KHR, VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT_KHR, VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT_KHR, VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT_KHR, VK_FORMAT_FEATURE_2_DISJOINT_BIT_KHR, VK_FORMAT_FEATURE_2_COSITED_CHROMA_SAMPLES_BIT_KHR, VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT_KHR, VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT_KHR, VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT_KHR, VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_MINMAX_BIT_KHR, VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT, VK_FORMAT_FEATURE_2_ACCELERATION_STRUCTURE_RADIUS_BUFFER_BIT_NV, VK_FORMAT_FEATURE_2_LINEAR_COLOR_ATTACHMENT_BIT_NV, VK_FORMAT_FEATURE_2_WEIGHT_IMAGE_BIT_QCOM, VK_FORMAT_FEATURE_2_WEIGHT_SAMPLED_IMAGE_BIT_QCOM, VK_FORMAT_FEATURE_2_BLOCK_MATCHING_BIT_QCOM, VK_FORMAT_FEATURE_2_BOX_FILTER_SAMPLED_BIT_QCOM, VK_FORMAT_FEATURE_2_TENSOR_SHADER_BIT_ARM, VK_FORMAT_FEATURE_2_TENSOR_IMAGE_ALIASING_BIT_ARM, VK_FORMAT_FEATURE_2_OPTICAL_FLOW_IMAGE_BIT_NV, VK_FORMAT_FEATURE_2_OPTICAL_FLOW_VECTOR_BIT_NV, VK_FORMAT_FEATURE_2_OPTICAL_FLOW_COST_BIT_NV, VK_FORMAT_FEATURE_2_TENSOR_DATA_GRAPH_BIT_ARM, VK_FORMAT_FEATURE_2_RESERVED_60_BIT_EXT, VK_FORMAT_FEATURE_2_COPY_IMAGE_INDIRECT_DST_BIT_KHR, VK_FORMAT_FEATURE_2_VIDEO_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR, VK_FORMAT_FEATURE_2_VIDEO_ENCODE_EMPHASIS_MAP_BIT_KHR, VK_FORMAT_FEATURE_2_DEPTH_COPY_ON_COMPUTE_QUEUE_BIT_KHR, VK_FORMAT_FEATURE_2_DEPTH_COPY_ON_TRANSFER_QUEUE_BIT_KHR, VK_FORMAT_FEATURE_2_STENCIL_COPY_ON_COMPUTE_QUEUE_BIT_KHR, VK_FORMAT_FEATURE_2_STENCIL_COPY_ON_TRANSFER_QUEUE_BIT_KHR, VK_FORMAT_FEATURE_2_RESERVED_56_BIT_ARM, VK_FORMAT_FEATURE_2_RESERVED_57_BIT_ARM, VK_FORMAT_FEATURE_2_RESERVED_58_BIT_ARM, VK_FORMAT_FEATURE_2_RESERVED_47_BIT_ARM, VK_FORMAT_FEATURE_2_RESERVED_61_BIT_HUAWEI });

/// `VkFormatFeatureFlags2`
pub type VkFormatFeatureFlags2KHR = VkFormatFeatureFlags2;

/// `VkFormatProperties`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkFormatProperties {
    /// Format features in case of linear tiling
    pub linearTilingFeatures: VkFormatFeatureFlags,
    /// Format features in case of optimal tiling
    pub optimalTilingFeatures: VkFormatFeatureFlags,
    /// Format features supported by buffers
    pub bufferFeatures: VkFormatFeatureFlags,
}
impl_default_zeroed!(VkFormatProperties);

/// `VkFormatProperties2`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkFormatProperties2 {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub formatProperties: VkFormatProperties,
}
impl_default_zeroed_with_s_type!(VkFormatProperties2 : VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2);

/// `VkFormatProperties2`
pub type VkFormatProperties2KHR = VkFormatProperties2;

/// `VkFormatProperties3`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkFormatProperties3 {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub linearTilingFeatures: VkFormatFeatureFlags2,
    pub optimalTilingFeatures: VkFormatFeatureFlags2,
    pub bufferFeatures: VkFormatFeatureFlags2,
}
impl_default_zeroed_with_s_type!(VkFormatProperties3 : VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3);
impl_extends!(VkFormatProperties3 : VkFormatProperties2);

/// `VkFormatProperties3`
pub type VkFormatProperties3KHR = VkFormatProperties3;

/// `VkFragmentShadingRateAttachmentInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkFragmentShadingRateAttachmentInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub pFragmentShadingRateAttachment: *const VkAttachmentReference2,
    pub shadingRateAttachmentTexelSize: VkExtent2D,
}
impl_default_zeroed_with_s_type!(VkFragmentShadingRateAttachmentInfoKHR : VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR);
impl_extends!(VkFragmentShadingRateAttachmentInfoKHR : VkSubpassDescription2);

from_into_transparent!(VkFragmentShadingRateCombinerOpKHR: i32);
/// `VkFragmentShadingRateCombinerOpKHR`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkFragmentShadingRateCombinerOpKHR(pub i32);

/// `0`  
pub const VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR: VkFragmentShadingRateCombinerOpKHR = VkFragmentShadingRateCombinerOpKHR(0);
/// `1`  
pub const VK_FRAGMENT_SHADING_RATE_COMBINER_OP_REPLACE_KHR: VkFragmentShadingRateCombinerOpKHR = VkFragmentShadingRateCombinerOpKHR(1);
/// `2`  
pub const VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MIN_KHR: VkFragmentShadingRateCombinerOpKHR = VkFragmentShadingRateCombinerOpKHR(2);
/// `3`  
pub const VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MAX_KHR: VkFragmentShadingRateCombinerOpKHR = VkFragmentShadingRateCombinerOpKHR(3);
/// `4`  
pub const VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MUL_KHR: VkFragmentShadingRateCombinerOpKHR = VkFragmentShadingRateCombinerOpKHR(4);

impl_enum_display!(VkFragmentShadingRateCombinerOpKHR { VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR, VK_FRAGMENT_SHADING_RATE_COMBINER_OP_REPLACE_KHR, VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MIN_KHR, VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MAX_KHR, VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MUL_KHR });

from_into_transparent!(VkFragmentShadingRateNV: i32);
/// `VkFragmentShadingRateNV`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkFragmentShadingRateNV(pub i32);

/// `0`  
pub const VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_PIXEL_NV: VkFragmentShadingRateNV = VkFragmentShadingRateNV(0);
/// `1`  
pub const VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_1X2_PIXELS_NV: VkFragmentShadingRateNV = VkFragmentShadingRateNV(1);
/// `4`  
pub const VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_2X1_PIXELS_NV: VkFragmentShadingRateNV = VkFragmentShadingRateNV(4);
/// `5`  
pub const VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_2X2_PIXELS_NV: VkFragmentShadingRateNV = VkFragmentShadingRateNV(5);
/// `6`  
pub const VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_2X4_PIXELS_NV: VkFragmentShadingRateNV = VkFragmentShadingRateNV(6);
/// `9`  
pub const VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_4X2_PIXELS_NV: VkFragmentShadingRateNV = VkFragmentShadingRateNV(9);
/// `10`  
pub const VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_4X4_PIXELS_NV: VkFragmentShadingRateNV = VkFragmentShadingRateNV(10);
/// `11`  
pub const VK_FRAGMENT_SHADING_RATE_2_INVOCATIONS_PER_PIXEL_NV: VkFragmentShadingRateNV = VkFragmentShadingRateNV(11);
/// `12`  
pub const VK_FRAGMENT_SHADING_RATE_4_INVOCATIONS_PER_PIXEL_NV: VkFragmentShadingRateNV = VkFragmentShadingRateNV(12);
/// `13`  
pub const VK_FRAGMENT_SHADING_RATE_8_INVOCATIONS_PER_PIXEL_NV: VkFragmentShadingRateNV = VkFragmentShadingRateNV(13);
/// `14`  
pub const VK_FRAGMENT_SHADING_RATE_16_INVOCATIONS_PER_PIXEL_NV: VkFragmentShadingRateNV = VkFragmentShadingRateNV(14);
/// `15`  
pub const VK_FRAGMENT_SHADING_RATE_NO_INVOCATIONS_NV: VkFragmentShadingRateNV = VkFragmentShadingRateNV(15);

impl_enum_display!(VkFragmentShadingRateNV { VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_PIXEL_NV, VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_1X2_PIXELS_NV, VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_2X1_PIXELS_NV, VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_2X2_PIXELS_NV, VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_2X4_PIXELS_NV, VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_4X2_PIXELS_NV, VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_4X4_PIXELS_NV, VK_FRAGMENT_SHADING_RATE_2_INVOCATIONS_PER_PIXEL_NV, VK_FRAGMENT_SHADING_RATE_4_INVOCATIONS_PER_PIXEL_NV, VK_FRAGMENT_SHADING_RATE_8_INVOCATIONS_PER_PIXEL_NV, VK_FRAGMENT_SHADING_RATE_16_INVOCATIONS_PER_PIXEL_NV, VK_FRAGMENT_SHADING_RATE_NO_INVOCATIONS_NV });

from_into_transparent!(VkFragmentShadingRateTypeNV: i32);
/// `VkFragmentShadingRateTypeNV`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkFragmentShadingRateTypeNV(pub i32);

/// `0`  
pub const VK_FRAGMENT_SHADING_RATE_TYPE_FRAGMENT_SIZE_NV: VkFragmentShadingRateTypeNV = VkFragmentShadingRateTypeNV(0);
/// `1`  
pub const VK_FRAGMENT_SHADING_RATE_TYPE_ENUMS_NV: VkFragmentShadingRateTypeNV = VkFragmentShadingRateTypeNV(1);

impl_enum_display!(VkFragmentShadingRateTypeNV { VK_FRAGMENT_SHADING_RATE_TYPE_FRAGMENT_SIZE_NV, VK_FRAGMENT_SHADING_RATE_TYPE_ENUMS_NV });

/// `VkFrameBoundaryEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkFrameBoundaryEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub flags: VkFrameBoundaryFlagsEXT,
    pub frameID: uint64_t,
    pub imageCount: uint32_t,
    pub pImages: *const VkImage,
    pub bufferCount: uint32_t,
    pub pBuffers: *const VkBuffer,
    pub tagName: uint64_t,
    pub tagSize: size_t,
    pub pTag: *const void,
}
impl_default_zeroed_with_s_type!(VkFrameBoundaryEXT : VK_STRUCTURE_TYPE_FRAME_BOUNDARY_EXT);
impl_extends!(VkFrameBoundaryEXT : VkSubmitInfo, VkSubmitInfo2, VkPresentInfoKHR, VkBindSparseInfo);

flags!(VkFrameBoundaryFlagsEXT);
from_into_transparent!(VkFrameBoundaryFlagsEXT: i32);
/// `VkFrameBoundaryFlagsEXT`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkFrameBoundaryFlagsEXT(pub i32);

/// `1 << 0`  
pub const VK_FRAME_BOUNDARY_FRAME_END_BIT_EXT: VkFrameBoundaryFlagsEXT = VkFrameBoundaryFlagsEXT(1 << 0);

impl_flags_display!(VkFrameBoundaryFlagsEXT { VK_FRAME_BOUNDARY_FRAME_END_BIT_EXT });

/// `VkFrameBoundaryTensorsARM`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkFrameBoundaryTensorsARM {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub tensorCount: uint32_t,
    pub pTensors: *const VkTensorARM,
}
impl_default_zeroed_with_s_type!(VkFrameBoundaryTensorsARM : VK_STRUCTURE_TYPE_FRAME_BOUNDARY_TENSORS_ARM);
impl_extends!(VkFrameBoundaryTensorsARM : VkSubmitInfo, VkSubmitInfo2, VkPresentInfoKHR, VkBindSparseInfo);

/// `VkFramebuffer` : `VkDevice`
#[repr(transparent)]
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkFramebuffer(pub u64);
from_into_transparent!(VkFramebuffer: u64);
impl_handle!(VkFramebuffer: VK_OBJECT_TYPE_FRAMEBUFFER; SubHandle = VkDevice);

/// `VkFramebufferAttachmentImageInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkFramebufferAttachmentImageInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    /// Image creation flags
    pub flags: VkImageCreateFlags,
    /// Image usage flags
    pub usage: VkImageUsageFlags,
    pub width: uint32_t,
    pub height: uint32_t,
    pub layerCount: uint32_t,
    pub viewFormatCount: uint32_t,
    pub pViewFormats: *const VkFormat,
}
impl_default_zeroed_with_s_type!(VkFramebufferAttachmentImageInfo : VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO);

/// `VkFramebufferAttachmentImageInfo`
pub type VkFramebufferAttachmentImageInfoKHR = VkFramebufferAttachmentImageInfo;

/// `VkFramebufferAttachmentsCreateInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkFramebufferAttachmentsCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub attachmentImageInfoCount: uint32_t,
    pub pAttachmentImageInfos: *const VkFramebufferAttachmentImageInfo,
}
impl_default_zeroed_with_s_type!(VkFramebufferAttachmentsCreateInfo : VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO);
impl_extends!(VkFramebufferAttachmentsCreateInfo : VkFramebufferCreateInfo);

/// `VkFramebufferAttachmentsCreateInfo`
pub type VkFramebufferAttachmentsCreateInfoKHR = VkFramebufferAttachmentsCreateInfo;

flags!(VkFramebufferCreateFlags);
from_into_transparent!(VkFramebufferCreateFlags: i32);
/// `VkFramebufferCreateFlags`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkFramebufferCreateFlags(pub i32);

/// `1 << 0`  
pub const VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT: VkFramebufferCreateFlags = VkFramebufferCreateFlags(1 << 0);
/// `VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT`  
pub const VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR: VkFramebufferCreateFlags = VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT;

impl_flags_display!(VkFramebufferCreateFlags { VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR });

/// `VkFramebufferCreateInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkFramebufferCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub flags: VkFramebufferCreateFlags,
    pub renderPass: VkRenderPass,
    pub attachmentCount: uint32_t,
    pub pAttachments: *const VkImageView,
    pub width: uint32_t,
    pub height: uint32_t,
    pub layers: uint32_t,
}
impl_default_zeroed_with_s_type!(VkFramebufferCreateInfo : VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO);

/// `VkFramebufferMixedSamplesCombinationNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkFramebufferMixedSamplesCombinationNV {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub coverageReductionMode: VkCoverageReductionModeNV,
    pub rasterizationSamples: VkSampleCountFlags,
    pub depthStencilSamples: VkSampleCountFlags,
    pub colorSamples: VkSampleCountFlags,
}
impl_default_zeroed_with_s_type!(VkFramebufferMixedSamplesCombinationNV : VK_STRUCTURE_TYPE_FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV);

from_into_transparent!(VkFrontFace: i32);
/// `VkFrontFace`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkFrontFace(pub i32);

/// `0`  
pub const VK_FRONT_FACE_COUNTER_CLOCKWISE: VkFrontFace = VkFrontFace(0);
/// `1`  
pub const VK_FRONT_FACE_CLOCKWISE: VkFrontFace = VkFrontFace(1);

impl_enum_display!(VkFrontFace { VK_FRONT_FACE_COUNTER_CLOCKWISE, VK_FRONT_FACE_CLOCKWISE });

from_into_transparent!(VkFullScreenExclusiveEXT: i32);
/// `VkFullScreenExclusiveEXT`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkFullScreenExclusiveEXT(pub i32);

/// `0`  
pub const VK_FULL_SCREEN_EXCLUSIVE_DEFAULT_EXT: VkFullScreenExclusiveEXT = VkFullScreenExclusiveEXT(0);
/// `1`  
pub const VK_FULL_SCREEN_EXCLUSIVE_ALLOWED_EXT: VkFullScreenExclusiveEXT = VkFullScreenExclusiveEXT(1);
/// `2`  
pub const VK_FULL_SCREEN_EXCLUSIVE_DISALLOWED_EXT: VkFullScreenExclusiveEXT = VkFullScreenExclusiveEXT(2);
/// `3`  
pub const VK_FULL_SCREEN_EXCLUSIVE_APPLICATION_CONTROLLED_EXT: VkFullScreenExclusiveEXT = VkFullScreenExclusiveEXT(3);

impl_enum_display!(VkFullScreenExclusiveEXT { VK_FULL_SCREEN_EXCLUSIVE_DEFAULT_EXT, VK_FULL_SCREEN_EXCLUSIVE_ALLOWED_EXT, VK_FULL_SCREEN_EXCLUSIVE_DISALLOWED_EXT, VK_FULL_SCREEN_EXCLUSIVE_APPLICATION_CONTROLLED_EXT });

/// `VkGeneratedCommandsInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkGeneratedCommandsInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub shaderStages: VkShaderStageFlags,
    pub indirectExecutionSet: VkIndirectExecutionSetEXT,
    pub indirectCommandsLayout: VkIndirectCommandsLayoutEXT,
    pub indirectAddress: VkDeviceAddress,
    pub indirectAddressSize: VkDeviceSize,
    pub preprocessAddress: VkDeviceAddress,
    pub preprocessSize: VkDeviceSize,
    pub maxSequenceCount: uint32_t,
    pub sequenceCountAddress: VkDeviceAddress,
    pub maxDrawCount: uint32_t,
}
impl_default_zeroed_with_s_type!(VkGeneratedCommandsInfoEXT : VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_EXT);

/// `VkGeneratedCommandsInfoNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkGeneratedCommandsInfoNV {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub pipelineBindPoint: VkPipelineBindPoint,
    pub pipeline: VkPipeline,
    pub indirectCommandsLayout: VkIndirectCommandsLayoutNV,
    pub streamCount: uint32_t,
    pub pStreams: *const VkIndirectCommandsStreamNV,
    pub sequencesCount: uint32_t,
    pub preprocessBuffer: VkBuffer,
    pub preprocessOffset: VkDeviceSize,
    pub preprocessSize: VkDeviceSize,
    pub sequencesCountBuffer: VkBuffer,
    pub sequencesCountOffset: VkDeviceSize,
    pub sequencesIndexBuffer: VkBuffer,
    pub sequencesIndexOffset: VkDeviceSize,
}
impl_default_zeroed_with_s_type!(VkGeneratedCommandsInfoNV : VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_NV);

/// `VkGeneratedCommandsMemoryRequirementsInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkGeneratedCommandsMemoryRequirementsInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub indirectExecutionSet: VkIndirectExecutionSetEXT,
    pub indirectCommandsLayout: VkIndirectCommandsLayoutEXT,
    pub maxSequenceCount: uint32_t,
    pub maxDrawCount: uint32_t,
}
impl_default_zeroed_with_s_type!(VkGeneratedCommandsMemoryRequirementsInfoEXT : VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_EXT);

/// `VkGeneratedCommandsMemoryRequirementsInfoNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkGeneratedCommandsMemoryRequirementsInfoNV {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub pipelineBindPoint: VkPipelineBindPoint,
    pub pipeline: VkPipeline,
    pub indirectCommandsLayout: VkIndirectCommandsLayoutNV,
    pub maxSequencesCount: uint32_t,
}
impl_default_zeroed_with_s_type!(VkGeneratedCommandsMemoryRequirementsInfoNV : VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_NV);

/// `VkGeneratedCommandsPipelineInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkGeneratedCommandsPipelineInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub pipeline: VkPipeline,
}
impl_default_zeroed_with_s_type!(VkGeneratedCommandsPipelineInfoEXT : VK_STRUCTURE_TYPE_GENERATED_COMMANDS_PIPELINE_INFO_EXT);
impl_extends!(VkGeneratedCommandsPipelineInfoEXT : VkGeneratedCommandsInfoEXT, VkGeneratedCommandsMemoryRequirementsInfoEXT);

/// `VkGeneratedCommandsShaderInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkGeneratedCommandsShaderInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub shaderCount: uint32_t,
    pub pShaders: *const VkShaderEXT,
}
impl_default_zeroed_with_s_type!(VkGeneratedCommandsShaderInfoEXT : VK_STRUCTURE_TYPE_GENERATED_COMMANDS_SHADER_INFO_EXT);
impl_extends!(VkGeneratedCommandsShaderInfoEXT : VkGeneratedCommandsInfoEXT, VkGeneratedCommandsMemoryRequirementsInfoEXT);

/// `VkGeometryAABBNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkGeometryAABBNV {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub aabbData: VkBuffer,
    pub numAABBs: uint32_t,
    /// Stride in bytes between AABBs
    pub stride: uint32_t,
    /// Offset in bytes of the first AABB in aabbData
    pub offset: VkDeviceSize,
}
impl_default_zeroed_with_s_type!(VkGeometryAABBNV : VK_STRUCTURE_TYPE_GEOMETRY_AABB_NV);

/// `VkGeometryDataNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkGeometryDataNV {
    pub triangles: VkGeometryTrianglesNV,
    pub aabbs: VkGeometryAABBNV,
}
impl_default_zeroed!(VkGeometryDataNV);

flags!(VkGeometryFlagsKHR);
from_into_transparent!(VkGeometryFlagsKHR: i32);
/// `VkGeometryFlagsKHR`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkGeometryFlagsKHR(pub i32);

/// `1 << 0`  
pub const VK_GEOMETRY_OPAQUE_BIT_KHR: VkGeometryFlagsKHR = VkGeometryFlagsKHR(1 << 0);
/// `1 << 1`  
pub const VK_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_KHR: VkGeometryFlagsKHR = VkGeometryFlagsKHR(1 << 1);
/// `VK_GEOMETRY_OPAQUE_BIT_KHR`  
pub const VK_GEOMETRY_OPAQUE_BIT_NV: VkGeometryFlagsKHR = VK_GEOMETRY_OPAQUE_BIT_KHR;
/// `VK_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_KHR`  
pub const VK_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_NV: VkGeometryFlagsKHR = VK_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_KHR;

impl_flags_display!(VkGeometryFlagsKHR { VK_GEOMETRY_OPAQUE_BIT_KHR, VK_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_KHR, VK_GEOMETRY_OPAQUE_BIT_NV, VK_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_NV });

/// `VkGeometryFlagsKHR`
pub type VkGeometryFlagsNV = VkGeometryFlagsKHR;

flags!(VkGeometryInstanceFlagsKHR);
from_into_transparent!(VkGeometryInstanceFlagsKHR: i32);
/// `VkGeometryInstanceFlagsKHR`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkGeometryInstanceFlagsKHR(pub i32);

/// `1 << 0`  
pub const VK_GEOMETRY_INSTANCE_TRIANGLE_FACING_CULL_DISABLE_BIT_KHR: VkGeometryInstanceFlagsKHR = VkGeometryInstanceFlagsKHR(1 << 0);
/// `1 << 1`  
pub const VK_GEOMETRY_INSTANCE_TRIANGLE_FLIP_FACING_BIT_KHR: VkGeometryInstanceFlagsKHR = VkGeometryInstanceFlagsKHR(1 << 1);
/// `1 << 2`  
pub const VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_KHR: VkGeometryInstanceFlagsKHR = VkGeometryInstanceFlagsKHR(1 << 2);
/// `1 << 3`  
pub const VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_KHR: VkGeometryInstanceFlagsKHR = VkGeometryInstanceFlagsKHR(1 << 3);
/// `VK_GEOMETRY_INSTANCE_TRIANGLE_FLIP_FACING_BIT_KHR`  
pub const VK_GEOMETRY_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_KHR: VkGeometryInstanceFlagsKHR = VK_GEOMETRY_INSTANCE_TRIANGLE_FLIP_FACING_BIT_KHR;
/// `VK_GEOMETRY_INSTANCE_TRIANGLE_FACING_CULL_DISABLE_BIT_KHR`  
pub const VK_GEOMETRY_INSTANCE_TRIANGLE_CULL_DISABLE_BIT_NV: VkGeometryInstanceFlagsKHR = VK_GEOMETRY_INSTANCE_TRIANGLE_FACING_CULL_DISABLE_BIT_KHR;
/// `VK_GEOMETRY_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_KHR`  
pub const VK_GEOMETRY_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_NV: VkGeometryInstanceFlagsKHR = VK_GEOMETRY_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_KHR;
/// `VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_KHR`  
pub const VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_NV: VkGeometryInstanceFlagsKHR = VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_KHR;
/// `VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_KHR`  
pub const VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_NV: VkGeometryInstanceFlagsKHR = VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_KHR;
/// `1 << 4`  
pub const VK_GEOMETRY_INSTANCE_FORCE_OPACITY_MICROMAP_2_STATE_BIT_EXT: VkGeometryInstanceFlagsKHR = VkGeometryInstanceFlagsKHR(1 << 4);
/// `VK_GEOMETRY_INSTANCE_FORCE_OPACITY_MICROMAP_2_STATE_BIT_EXT`  
pub const VK_GEOMETRY_INSTANCE_FORCE_OPACITY_MICROMAP_2_STATE_EXT: VkGeometryInstanceFlagsKHR = VK_GEOMETRY_INSTANCE_FORCE_OPACITY_MICROMAP_2_STATE_BIT_EXT;
/// `1 << 5`  
pub const VK_GEOMETRY_INSTANCE_DISABLE_OPACITY_MICROMAPS_BIT_EXT: VkGeometryInstanceFlagsKHR = VkGeometryInstanceFlagsKHR(1 << 5);
/// `VK_GEOMETRY_INSTANCE_DISABLE_OPACITY_MICROMAPS_BIT_EXT`  
pub const VK_GEOMETRY_INSTANCE_DISABLE_OPACITY_MICROMAPS_EXT: VkGeometryInstanceFlagsKHR = VK_GEOMETRY_INSTANCE_DISABLE_OPACITY_MICROMAPS_BIT_EXT;

impl_flags_display!(VkGeometryInstanceFlagsKHR { VK_GEOMETRY_INSTANCE_TRIANGLE_FACING_CULL_DISABLE_BIT_KHR, VK_GEOMETRY_INSTANCE_TRIANGLE_FLIP_FACING_BIT_KHR, VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_KHR, VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_KHR, VK_GEOMETRY_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_KHR, VK_GEOMETRY_INSTANCE_TRIANGLE_CULL_DISABLE_BIT_NV, VK_GEOMETRY_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_NV, VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_NV, VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_NV, VK_GEOMETRY_INSTANCE_FORCE_OPACITY_MICROMAP_2_STATE_BIT_EXT, VK_GEOMETRY_INSTANCE_FORCE_OPACITY_MICROMAP_2_STATE_EXT, VK_GEOMETRY_INSTANCE_DISABLE_OPACITY_MICROMAPS_BIT_EXT, VK_GEOMETRY_INSTANCE_DISABLE_OPACITY_MICROMAPS_EXT });

/// `VkGeometryInstanceFlagsKHR`
pub type VkGeometryInstanceFlagsNV = VkGeometryInstanceFlagsKHR;

/// `VkGeometryNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkGeometryNV {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub geometryType: VkGeometryTypeKHR,
    pub geometry: VkGeometryDataNV,
    pub flags: VkGeometryFlagsKHR,
}
impl_default_zeroed_with_s_type!(VkGeometryNV : VK_STRUCTURE_TYPE_GEOMETRY_NV);

/// `VkGeometryTrianglesNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkGeometryTrianglesNV {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub vertexData: VkBuffer,
    pub vertexOffset: VkDeviceSize,
    pub vertexCount: uint32_t,
    pub vertexStride: VkDeviceSize,
    pub vertexFormat: VkFormat,
    pub indexData: VkBuffer,
    pub indexOffset: VkDeviceSize,
    pub indexCount: uint32_t,
    pub indexType: VkIndexType,
    /// Optional reference to array of floats representing a 3x4 row major affine transformation matrix.
    pub transformData: VkBuffer,
    pub transformOffset: VkDeviceSize,
}
impl_default_zeroed_with_s_type!(VkGeometryTrianglesNV : VK_STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NV);

from_into_transparent!(VkGeometryTypeKHR: i32);
/// `VkGeometryTypeKHR`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkGeometryTypeKHR(pub i32);

/// `0`  
pub const VK_GEOMETRY_TYPE_TRIANGLES_KHR: VkGeometryTypeKHR = VkGeometryTypeKHR(0);
/// `1`  
pub const VK_GEOMETRY_TYPE_AABBS_KHR: VkGeometryTypeKHR = VkGeometryTypeKHR(1);
/// `2`  
pub const VK_GEOMETRY_TYPE_INSTANCES_KHR: VkGeometryTypeKHR = VkGeometryTypeKHR(2);
/// `VK_GEOMETRY_TYPE_TRIANGLES_KHR`  
pub const VK_GEOMETRY_TYPE_TRIANGLES_NV: VkGeometryTypeKHR = VK_GEOMETRY_TYPE_TRIANGLES_KHR;
/// `VK_GEOMETRY_TYPE_AABBS_KHR`  
pub const VK_GEOMETRY_TYPE_AABBS_NV: VkGeometryTypeKHR = VK_GEOMETRY_TYPE_AABBS_KHR;
/// `1000429004`  
pub const VK_GEOMETRY_TYPE_SPHERES_NV: VkGeometryTypeKHR = VkGeometryTypeKHR(1000429004);
/// `1000429005`  
pub const VK_GEOMETRY_TYPE_LINEAR_SWEPT_SPHERES_NV: VkGeometryTypeKHR = VkGeometryTypeKHR(1000429005);
/// `1000478000`  
pub const VK_GEOMETRY_TYPE_DENSE_GEOMETRY_FORMAT_TRIANGLES_AMDX: VkGeometryTypeKHR = VkGeometryTypeKHR(1000478000);

impl_enum_display!(VkGeometryTypeKHR { VK_GEOMETRY_TYPE_TRIANGLES_KHR, VK_GEOMETRY_TYPE_AABBS_KHR, VK_GEOMETRY_TYPE_INSTANCES_KHR, VK_GEOMETRY_TYPE_TRIANGLES_NV, VK_GEOMETRY_TYPE_AABBS_NV, VK_GEOMETRY_TYPE_SPHERES_NV, VK_GEOMETRY_TYPE_LINEAR_SWEPT_SPHERES_NV, VK_GEOMETRY_TYPE_DENSE_GEOMETRY_FORMAT_TRIANGLES_AMDX });

/// `VkGeometryTypeKHR`
pub type VkGeometryTypeNV = VkGeometryTypeKHR;

/// `VkGetLatencyMarkerInfoNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkGetLatencyMarkerInfoNV {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub timingCount: uint32_t,
    pub pTimings: *mut VkLatencyTimingsFrameReportNV,
}
impl_default_zeroed_with_s_type!(VkGetLatencyMarkerInfoNV : VK_STRUCTURE_TYPE_GET_LATENCY_MARKER_INFO_NV);

/// `VkGraphicsPipelineCreateInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkGraphicsPipelineCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    /// Pipeline creation flags
    pub flags: VkPipelineCreateFlags,
    pub stageCount: uint32_t,
    /// One entry for each active shader stage
    pub pStages: *const VkPipelineShaderStageCreateInfo,
    pub pVertexInputState: *const VkPipelineVertexInputStateCreateInfo,
    pub pInputAssemblyState: *const VkPipelineInputAssemblyStateCreateInfo,
    pub pTessellationState: *const VkPipelineTessellationStateCreateInfo,
    pub pViewportState: *const VkPipelineViewportStateCreateInfo,
    pub pRasterizationState: *const VkPipelineRasterizationStateCreateInfo,
    pub pMultisampleState: *const VkPipelineMultisampleStateCreateInfo,
    pub pDepthStencilState: *const VkPipelineDepthStencilStateCreateInfo,
    pub pColorBlendState: *const VkPipelineColorBlendStateCreateInfo,
    pub pDynamicState: *const VkPipelineDynamicStateCreateInfo,
    /// Interface layout of the pipeline
    pub layout: VkPipelineLayout,
    pub renderPass: VkRenderPass,
    pub subpass: uint32_t,
    /// 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 basePipelineHandle: VkPipeline,
    /// 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 basePipelineIndex: int32_t,
}
impl_default_zeroed_with_s_type!(VkGraphicsPipelineCreateInfo : VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO);

/// `VkGraphicsPipelineLibraryCreateInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkGraphicsPipelineLibraryCreateInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub flags: VkGraphicsPipelineLibraryFlagsEXT,
}
impl_default_zeroed_with_s_type!(VkGraphicsPipelineLibraryCreateInfoEXT : VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT);
impl_extends!(VkGraphicsPipelineLibraryCreateInfoEXT : VkGraphicsPipelineCreateInfo);

flags!(VkGraphicsPipelineLibraryFlagsEXT);
from_into_transparent!(VkGraphicsPipelineLibraryFlagsEXT: i32);
/// `VkGraphicsPipelineLibraryFlagsEXT`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkGraphicsPipelineLibraryFlagsEXT(pub i32);

/// `1 << 0`  
pub const VK_GRAPHICS_PIPELINE_LIBRARY_VERTEX_INPUT_INTERFACE_BIT_EXT: VkGraphicsPipelineLibraryFlagsEXT = VkGraphicsPipelineLibraryFlagsEXT(1 << 0);
/// `1 << 1`  
pub const VK_GRAPHICS_PIPELINE_LIBRARY_PRE_RASTERIZATION_SHADERS_BIT_EXT: VkGraphicsPipelineLibraryFlagsEXT = VkGraphicsPipelineLibraryFlagsEXT(1 << 1);
/// `1 << 2`  
pub const VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_SHADER_BIT_EXT: VkGraphicsPipelineLibraryFlagsEXT = VkGraphicsPipelineLibraryFlagsEXT(1 << 2);
/// `1 << 3`  
pub const VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_OUTPUT_INTERFACE_BIT_EXT: VkGraphicsPipelineLibraryFlagsEXT = VkGraphicsPipelineLibraryFlagsEXT(1 << 3);

impl_flags_display!(VkGraphicsPipelineLibraryFlagsEXT { VK_GRAPHICS_PIPELINE_LIBRARY_VERTEX_INPUT_INTERFACE_BIT_EXT, VK_GRAPHICS_PIPELINE_LIBRARY_PRE_RASTERIZATION_SHADERS_BIT_EXT, VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_SHADER_BIT_EXT, VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_OUTPUT_INTERFACE_BIT_EXT });

/// `VkGraphicsPipelineShaderGroupsCreateInfoNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkGraphicsPipelineShaderGroupsCreateInfoNV {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub groupCount: uint32_t,
    pub pGroups: *const VkGraphicsShaderGroupCreateInfoNV,
    pub pipelineCount: uint32_t,
    pub pPipelines: *const VkPipeline,
}
impl_default_zeroed_with_s_type!(VkGraphicsPipelineShaderGroupsCreateInfoNV : VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV);
impl_extends!(VkGraphicsPipelineShaderGroupsCreateInfoNV : VkGraphicsPipelineCreateInfo);

/// `VkGraphicsShaderGroupCreateInfoNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkGraphicsShaderGroupCreateInfoNV {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub stageCount: uint32_t,
    pub pStages: *const VkPipelineShaderStageCreateInfo,
    pub pVertexInputState: *const VkPipelineVertexInputStateCreateInfo,
    pub pTessellationState: *const VkPipelineTessellationStateCreateInfo,
}
impl_default_zeroed_with_s_type!(VkGraphicsShaderGroupCreateInfoNV : VK_STRUCTURE_TYPE_GRAPHICS_SHADER_GROUP_CREATE_INFO_NV);

/// `VkHdrMetadataEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkHdrMetadataEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    /// Display primary's Red
    pub displayPrimaryRed: VkXYColorEXT,
    /// Display primary's Green
    pub displayPrimaryGreen: VkXYColorEXT,
    /// Display primary's Blue
    pub displayPrimaryBlue: VkXYColorEXT,
    /// Display primary's Blue
    pub whitePoint: VkXYColorEXT,
    /// Display maximum luminance
    pub maxLuminance: float,
    /// Display minimum luminance
    pub minLuminance: float,
    /// Content maximum luminance
    pub maxContentLightLevel: float,
    pub maxFrameAverageLightLevel: float,
}
impl_default_zeroed_with_s_type!(VkHdrMetadataEXT : VK_STRUCTURE_TYPE_HDR_METADATA_EXT);

/// `VkHdrVividDynamicMetadataHUAWEI`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkHdrVividDynamicMetadataHUAWEI {
    pub sType: VkStructureType,
    pub pNext: *const void,
    /// Specified in bytes
    pub dynamicMetadataSize: size_t,
    /// Binary code of size dynamicMetadataSize
    pub pDynamicMetadata: *const void,
}
impl_default_zeroed_with_s_type!(VkHdrVividDynamicMetadataHUAWEI : VK_STRUCTURE_TYPE_HDR_VIVID_DYNAMIC_METADATA_HUAWEI);
impl_extends!(VkHdrVividDynamicMetadataHUAWEI : VkHdrMetadataEXT);

flags!(VkHeadlessSurfaceCreateFlagsEXT);
from_into_transparent!(VkHeadlessSurfaceCreateFlagsEXT: i32);
/// `VkHeadlessSurfaceCreateFlagsEXT`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkHeadlessSurfaceCreateFlagsEXT(pub i32);

impl_flags_display!(VkHeadlessSurfaceCreateFlagsEXT {  });

/// `VkHeadlessSurfaceCreateInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkHeadlessSurfaceCreateInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub flags: VkHeadlessSurfaceCreateFlagsEXT,
}
impl_default_zeroed_with_s_type!(VkHeadlessSurfaceCreateInfoEXT : VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT);

/// `VkHostAddressRangeConstEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkHostAddressRangeConstEXT {
    pub address: *const void,
    pub size: size_t,
}
impl_default_zeroed!(VkHostAddressRangeConstEXT);

/// `VkHostAddressRangeEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkHostAddressRangeEXT {
    pub address: *mut void,
    pub size: size_t,
}
impl_default_zeroed!(VkHostAddressRangeEXT);

/// `VkHostImageCopyDevicePerformanceQuery`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkHostImageCopyDevicePerformanceQuery {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    /// Specifies if device access is optimal
    pub optimalDeviceAccess: VkBool32,
    /// Specifies if memory layout is identical
    pub identicalMemoryLayout: VkBool32,
}
impl_default_zeroed_with_s_type!(VkHostImageCopyDevicePerformanceQuery : VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY);
impl_extends!(VkHostImageCopyDevicePerformanceQuery : VkImageFormatProperties2);

/// `VkHostImageCopyDevicePerformanceQuery`
pub type VkHostImageCopyDevicePerformanceQueryEXT = VkHostImageCopyDevicePerformanceQuery;

flags!(VkHostImageCopyFlags);
from_into_transparent!(VkHostImageCopyFlags: i32);
/// `VkHostImageCopyFlags`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkHostImageCopyFlags(pub i32);

/// `1 << 0`  
pub const VK_HOST_IMAGE_COPY_MEMCPY_BIT: VkHostImageCopyFlags = VkHostImageCopyFlags(1 << 0);
/// `VK_HOST_IMAGE_COPY_MEMCPY_BIT`  
pub const VK_HOST_IMAGE_COPY_MEMCPY: VkHostImageCopyFlags = VK_HOST_IMAGE_COPY_MEMCPY_BIT;
/// `VK_HOST_IMAGE_COPY_MEMCPY_BIT`  
pub const VK_HOST_IMAGE_COPY_MEMCPY_BIT_EXT: VkHostImageCopyFlags = VK_HOST_IMAGE_COPY_MEMCPY_BIT;
/// `VK_HOST_IMAGE_COPY_MEMCPY_BIT`  
pub const VK_HOST_IMAGE_COPY_MEMCPY_EXT: VkHostImageCopyFlags = VK_HOST_IMAGE_COPY_MEMCPY_BIT;

impl_flags_display!(VkHostImageCopyFlags { VK_HOST_IMAGE_COPY_MEMCPY_BIT, VK_HOST_IMAGE_COPY_MEMCPY, VK_HOST_IMAGE_COPY_MEMCPY_BIT_EXT, VK_HOST_IMAGE_COPY_MEMCPY_EXT });

/// `VkHostImageCopyFlags`
pub type VkHostImageCopyFlagsEXT = VkHostImageCopyFlags;

/// `VkHostImageLayoutTransitionInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkHostImageLayoutTransitionInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub image: VkImage,
    pub oldLayout: VkImageLayout,
    pub newLayout: VkImageLayout,
    pub subresourceRange: VkImageSubresourceRange,
}
impl_default_zeroed_with_s_type!(VkHostImageLayoutTransitionInfo : VK_STRUCTURE_TYPE_HOST_IMAGE_LAYOUT_TRANSITION_INFO);

/// `VkHostImageLayoutTransitionInfo`
pub type VkHostImageLayoutTransitionInfoEXT = VkHostImageLayoutTransitionInfo;

flags!(VkIOSSurfaceCreateFlagsMVK);
from_into_transparent!(VkIOSSurfaceCreateFlagsMVK: i32);
/// `VkIOSSurfaceCreateFlagsMVK`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkIOSSurfaceCreateFlagsMVK(pub i32);

impl_flags_display!(VkIOSSurfaceCreateFlagsMVK {  });

/// `VkIOSSurfaceCreateInfoMVK`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkIOSSurfaceCreateInfoMVK {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub flags: VkIOSSurfaceCreateFlagsMVK,
    pub pView: *const void,
}
impl_default_zeroed_with_s_type!(VkIOSSurfaceCreateInfoMVK : VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK);

/// `VkImage` : `VkDevice`
#[repr(transparent)]
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkImage(pub u64);
from_into_transparent!(VkImage: u64);
impl_handle!(VkImage: VK_OBJECT_TYPE_IMAGE; SubHandle = VkDevice);

/// `VkImageAlignmentControlCreateInfoMESA`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkImageAlignmentControlCreateInfoMESA {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub maximumRequestedAlignment: uint32_t,
}
impl_default_zeroed_with_s_type!(VkImageAlignmentControlCreateInfoMESA : VK_STRUCTURE_TYPE_IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA);
impl_extends!(VkImageAlignmentControlCreateInfoMESA : VkImageCreateInfo);

flags!(VkImageAspectFlags);
from_into_transparent!(VkImageAspectFlags: i32);
/// `VkImageAspectFlags`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkImageAspectFlags(pub i32);

/// `1 << 0`  
pub const VK_IMAGE_ASPECT_COLOR_BIT: VkImageAspectFlags = VkImageAspectFlags(1 << 0);
/// `1 << 1`  
pub const VK_IMAGE_ASPECT_DEPTH_BIT: VkImageAspectFlags = VkImageAspectFlags(1 << 1);
/// `1 << 2`  
pub const VK_IMAGE_ASPECT_STENCIL_BIT: VkImageAspectFlags = VkImageAspectFlags(1 << 2);
/// `1 << 3`  
pub const VK_IMAGE_ASPECT_METADATA_BIT: VkImageAspectFlags = VkImageAspectFlags(1 << 3);
/// `1 << 4`  
pub const VK_IMAGE_ASPECT_PLANE_0_BIT: VkImageAspectFlags = VkImageAspectFlags(1 << 4);
/// `1 << 5`  
pub const VK_IMAGE_ASPECT_PLANE_1_BIT: VkImageAspectFlags = VkImageAspectFlags(1 << 5);
/// `1 << 6`  
pub const VK_IMAGE_ASPECT_PLANE_2_BIT: VkImageAspectFlags = VkImageAspectFlags(1 << 6);
/// `0`  
pub const VK_IMAGE_ASPECT_NONE: VkImageAspectFlags = VkImageAspectFlags(0);
/// `VK_IMAGE_ASPECT_PLANE_0_BIT`  
pub const VK_IMAGE_ASPECT_PLANE_0_BIT_KHR: VkImageAspectFlags = VK_IMAGE_ASPECT_PLANE_0_BIT;
/// `VK_IMAGE_ASPECT_PLANE_1_BIT`  
pub const VK_IMAGE_ASPECT_PLANE_1_BIT_KHR: VkImageAspectFlags = VK_IMAGE_ASPECT_PLANE_1_BIT;
/// `VK_IMAGE_ASPECT_PLANE_2_BIT`  
pub const VK_IMAGE_ASPECT_PLANE_2_BIT_KHR: VkImageAspectFlags = VK_IMAGE_ASPECT_PLANE_2_BIT;
/// `1 << 7`  
pub const VK_IMAGE_ASPECT_MEMORY_PLANE_0_BIT_EXT: VkImageAspectFlags = VkImageAspectFlags(1 << 7);
/// `1 << 8`  
pub const VK_IMAGE_ASPECT_MEMORY_PLANE_1_BIT_EXT: VkImageAspectFlags = VkImageAspectFlags(1 << 8);
/// `1 << 9`  
pub const VK_IMAGE_ASPECT_MEMORY_PLANE_2_BIT_EXT: VkImageAspectFlags = VkImageAspectFlags(1 << 9);
/// `1 << 10`  
pub const VK_IMAGE_ASPECT_MEMORY_PLANE_3_BIT_EXT: VkImageAspectFlags = VkImageAspectFlags(1 << 10);
/// `VK_IMAGE_ASPECT_NONE`  
pub const VK_IMAGE_ASPECT_NONE_KHR: VkImageAspectFlags = VK_IMAGE_ASPECT_NONE;
/// `1 << 11`  
pub const VK_IMAGE_ASPECT_RESERVED_11_BIT_HUAWEI: VkImageAspectFlags = VkImageAspectFlags(1 << 11);

impl_flags_display!(VkImageAspectFlags { VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_ASPECT_DEPTH_BIT, VK_IMAGE_ASPECT_STENCIL_BIT, VK_IMAGE_ASPECT_METADATA_BIT, VK_IMAGE_ASPECT_PLANE_0_BIT, VK_IMAGE_ASPECT_PLANE_1_BIT, VK_IMAGE_ASPECT_PLANE_2_BIT, VK_IMAGE_ASPECT_NONE, VK_IMAGE_ASPECT_PLANE_0_BIT_KHR, VK_IMAGE_ASPECT_PLANE_1_BIT_KHR, VK_IMAGE_ASPECT_PLANE_2_BIT_KHR, VK_IMAGE_ASPECT_MEMORY_PLANE_0_BIT_EXT, VK_IMAGE_ASPECT_MEMORY_PLANE_1_BIT_EXT, VK_IMAGE_ASPECT_MEMORY_PLANE_2_BIT_EXT, VK_IMAGE_ASPECT_MEMORY_PLANE_3_BIT_EXT, VK_IMAGE_ASPECT_NONE_KHR, VK_IMAGE_ASPECT_RESERVED_11_BIT_HUAWEI });

/// `VkImageBlit`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkImageBlit {
    pub srcSubresource: VkImageSubresourceLayers,
    /// Specified in pixels for both compressed and uncompressed images
    pub srcOffsets: [VkOffset3D; 2 as usize],
    pub dstSubresource: VkImageSubresourceLayers,
    /// Specified in pixels for both compressed and uncompressed images
    pub dstOffsets: [VkOffset3D; 2 as usize],
}
impl_default_zeroed!(VkImageBlit);

/// `VkImageBlit2`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkImageBlit2 {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub srcSubresource: VkImageSubresourceLayers,
    /// Specified in pixels for both compressed and uncompressed images
    pub srcOffsets: [VkOffset3D; 2 as usize],
    pub dstSubresource: VkImageSubresourceLayers,
    /// Specified in pixels for both compressed and uncompressed images
    pub dstOffsets: [VkOffset3D; 2 as usize],
}
impl_default_zeroed_with_s_type!(VkImageBlit2 : VK_STRUCTURE_TYPE_IMAGE_BLIT_2);

/// `VkImageBlit2`
pub type VkImageBlit2KHR = VkImageBlit2;

/// `VkImageCaptureDescriptorDataInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkImageCaptureDescriptorDataInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub image: VkImage,
}
impl_default_zeroed_with_s_type!(VkImageCaptureDescriptorDataInfoEXT : VK_STRUCTURE_TYPE_IMAGE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT);

/// `VkImageCompressionControlEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkImageCompressionControlEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub flags: VkImageCompressionFlagsEXT,
    pub compressionControlPlaneCount: uint32_t,
    pub pFixedRateFlags: *mut VkImageCompressionFixedRateFlagsEXT,
}
impl_default_zeroed_with_s_type!(VkImageCompressionControlEXT : VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT);
impl_extends!(VkImageCompressionControlEXT : VkImageCreateInfo, VkSwapchainCreateInfoKHR, VkPhysicalDeviceImageFormatInfo2);

flags!(VkImageCompressionFixedRateFlagsEXT);
from_into_transparent!(VkImageCompressionFixedRateFlagsEXT: i32);
/// `VkImageCompressionFixedRateFlagsEXT`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkImageCompressionFixedRateFlagsEXT(pub i32);

/// `0`  
pub const VK_IMAGE_COMPRESSION_FIXED_RATE_NONE_EXT: VkImageCompressionFixedRateFlagsEXT = VkImageCompressionFixedRateFlagsEXT(0);
/// `1 << 0`  
pub const VK_IMAGE_COMPRESSION_FIXED_RATE_1BPC_BIT_EXT: VkImageCompressionFixedRateFlagsEXT = VkImageCompressionFixedRateFlagsEXT(1 << 0);
/// `1 << 1`  
pub const VK_IMAGE_COMPRESSION_FIXED_RATE_2BPC_BIT_EXT: VkImageCompressionFixedRateFlagsEXT = VkImageCompressionFixedRateFlagsEXT(1 << 1);
/// `1 << 2`  
pub const VK_IMAGE_COMPRESSION_FIXED_RATE_3BPC_BIT_EXT: VkImageCompressionFixedRateFlagsEXT = VkImageCompressionFixedRateFlagsEXT(1 << 2);
/// `1 << 3`  
pub const VK_IMAGE_COMPRESSION_FIXED_RATE_4BPC_BIT_EXT: VkImageCompressionFixedRateFlagsEXT = VkImageCompressionFixedRateFlagsEXT(1 << 3);
/// `1 << 4`  
pub const VK_IMAGE_COMPRESSION_FIXED_RATE_5BPC_BIT_EXT: VkImageCompressionFixedRateFlagsEXT = VkImageCompressionFixedRateFlagsEXT(1 << 4);
/// `1 << 5`  
pub const VK_IMAGE_COMPRESSION_FIXED_RATE_6BPC_BIT_EXT: VkImageCompressionFixedRateFlagsEXT = VkImageCompressionFixedRateFlagsEXT(1 << 5);
/// `1 << 6`  
pub const VK_IMAGE_COMPRESSION_FIXED_RATE_7BPC_BIT_EXT: VkImageCompressionFixedRateFlagsEXT = VkImageCompressionFixedRateFlagsEXT(1 << 6);
/// `1 << 7`  
pub const VK_IMAGE_COMPRESSION_FIXED_RATE_8BPC_BIT_EXT: VkImageCompressionFixedRateFlagsEXT = VkImageCompressionFixedRateFlagsEXT(1 << 7);
/// `1 << 8`  
pub const VK_IMAGE_COMPRESSION_FIXED_RATE_9BPC_BIT_EXT: VkImageCompressionFixedRateFlagsEXT = VkImageCompressionFixedRateFlagsEXT(1 << 8);
/// `1 << 9`  
pub const VK_IMAGE_COMPRESSION_FIXED_RATE_10BPC_BIT_EXT: VkImageCompressionFixedRateFlagsEXT = VkImageCompressionFixedRateFlagsEXT(1 << 9);
/// `1 << 10`  
pub const VK_IMAGE_COMPRESSION_FIXED_RATE_11BPC_BIT_EXT: VkImageCompressionFixedRateFlagsEXT = VkImageCompressionFixedRateFlagsEXT(1 << 10);
/// `1 << 11`  
pub const VK_IMAGE_COMPRESSION_FIXED_RATE_12BPC_BIT_EXT: VkImageCompressionFixedRateFlagsEXT = VkImageCompressionFixedRateFlagsEXT(1 << 11);
/// `1 << 12`  
pub const VK_IMAGE_COMPRESSION_FIXED_RATE_13BPC_BIT_EXT: VkImageCompressionFixedRateFlagsEXT = VkImageCompressionFixedRateFlagsEXT(1 << 12);
/// `1 << 13`  
pub const VK_IMAGE_COMPRESSION_FIXED_RATE_14BPC_BIT_EXT: VkImageCompressionFixedRateFlagsEXT = VkImageCompressionFixedRateFlagsEXT(1 << 13);
/// `1 << 14`  
pub const VK_IMAGE_COMPRESSION_FIXED_RATE_15BPC_BIT_EXT: VkImageCompressionFixedRateFlagsEXT = VkImageCompressionFixedRateFlagsEXT(1 << 14);
/// `1 << 15`  
pub const VK_IMAGE_COMPRESSION_FIXED_RATE_16BPC_BIT_EXT: VkImageCompressionFixedRateFlagsEXT = VkImageCompressionFixedRateFlagsEXT(1 << 15);
/// `1 << 16`  
pub const VK_IMAGE_COMPRESSION_FIXED_RATE_17BPC_BIT_EXT: VkImageCompressionFixedRateFlagsEXT = VkImageCompressionFixedRateFlagsEXT(1 << 16);
/// `1 << 17`  
pub const VK_IMAGE_COMPRESSION_FIXED_RATE_18BPC_BIT_EXT: VkImageCompressionFixedRateFlagsEXT = VkImageCompressionFixedRateFlagsEXT(1 << 17);
/// `1 << 18`  
pub const VK_IMAGE_COMPRESSION_FIXED_RATE_19BPC_BIT_EXT: VkImageCompressionFixedRateFlagsEXT = VkImageCompressionFixedRateFlagsEXT(1 << 18);
/// `1 << 19`  
pub const VK_IMAGE_COMPRESSION_FIXED_RATE_20BPC_BIT_EXT: VkImageCompressionFixedRateFlagsEXT = VkImageCompressionFixedRateFlagsEXT(1 << 19);
/// `1 << 20`  
pub const VK_IMAGE_COMPRESSION_FIXED_RATE_21BPC_BIT_EXT: VkImageCompressionFixedRateFlagsEXT = VkImageCompressionFixedRateFlagsEXT(1 << 20);
/// `1 << 21`  
pub const VK_IMAGE_COMPRESSION_FIXED_RATE_22BPC_BIT_EXT: VkImageCompressionFixedRateFlagsEXT = VkImageCompressionFixedRateFlagsEXT(1 << 21);
/// `1 << 22`  
pub const VK_IMAGE_COMPRESSION_FIXED_RATE_23BPC_BIT_EXT: VkImageCompressionFixedRateFlagsEXT = VkImageCompressionFixedRateFlagsEXT(1 << 22);
/// `1 << 23`  
pub const VK_IMAGE_COMPRESSION_FIXED_RATE_24BPC_BIT_EXT: VkImageCompressionFixedRateFlagsEXT = VkImageCompressionFixedRateFlagsEXT(1 << 23);

impl_flags_display!(VkImageCompressionFixedRateFlagsEXT { VK_IMAGE_COMPRESSION_FIXED_RATE_NONE_EXT, VK_IMAGE_COMPRESSION_FIXED_RATE_1BPC_BIT_EXT, VK_IMAGE_COMPRESSION_FIXED_RATE_2BPC_BIT_EXT, VK_IMAGE_COMPRESSION_FIXED_RATE_3BPC_BIT_EXT, VK_IMAGE_COMPRESSION_FIXED_RATE_4BPC_BIT_EXT, VK_IMAGE_COMPRESSION_FIXED_RATE_5BPC_BIT_EXT, VK_IMAGE_COMPRESSION_FIXED_RATE_6BPC_BIT_EXT, VK_IMAGE_COMPRESSION_FIXED_RATE_7BPC_BIT_EXT, VK_IMAGE_COMPRESSION_FIXED_RATE_8BPC_BIT_EXT, VK_IMAGE_COMPRESSION_FIXED_RATE_9BPC_BIT_EXT, VK_IMAGE_COMPRESSION_FIXED_RATE_10BPC_BIT_EXT, VK_IMAGE_COMPRESSION_FIXED_RATE_11BPC_BIT_EXT, VK_IMAGE_COMPRESSION_FIXED_RATE_12BPC_BIT_EXT, VK_IMAGE_COMPRESSION_FIXED_RATE_13BPC_BIT_EXT, VK_IMAGE_COMPRESSION_FIXED_RATE_14BPC_BIT_EXT, VK_IMAGE_COMPRESSION_FIXED_RATE_15BPC_BIT_EXT, VK_IMAGE_COMPRESSION_FIXED_RATE_16BPC_BIT_EXT, VK_IMAGE_COMPRESSION_FIXED_RATE_17BPC_BIT_EXT, VK_IMAGE_COMPRESSION_FIXED_RATE_18BPC_BIT_EXT, VK_IMAGE_COMPRESSION_FIXED_RATE_19BPC_BIT_EXT, VK_IMAGE_COMPRESSION_FIXED_RATE_20BPC_BIT_EXT, VK_IMAGE_COMPRESSION_FIXED_RATE_21BPC_BIT_EXT, VK_IMAGE_COMPRESSION_FIXED_RATE_22BPC_BIT_EXT, VK_IMAGE_COMPRESSION_FIXED_RATE_23BPC_BIT_EXT, VK_IMAGE_COMPRESSION_FIXED_RATE_24BPC_BIT_EXT });

flags!(VkImageCompressionFlagsEXT);
from_into_transparent!(VkImageCompressionFlagsEXT: i32);
/// `VkImageCompressionFlagsEXT`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkImageCompressionFlagsEXT(pub i32);

/// `0`  
pub const VK_IMAGE_COMPRESSION_DEFAULT_EXT: VkImageCompressionFlagsEXT = VkImageCompressionFlagsEXT(0);
/// `1 << 0`  
pub const VK_IMAGE_COMPRESSION_FIXED_RATE_DEFAULT_EXT: VkImageCompressionFlagsEXT = VkImageCompressionFlagsEXT(1 << 0);
/// `1 << 1`  
pub const VK_IMAGE_COMPRESSION_FIXED_RATE_EXPLICIT_EXT: VkImageCompressionFlagsEXT = VkImageCompressionFlagsEXT(1 << 1);
/// `1 << 2`  
pub const VK_IMAGE_COMPRESSION_DISABLED_EXT: VkImageCompressionFlagsEXT = VkImageCompressionFlagsEXT(1 << 2);

impl_flags_display!(VkImageCompressionFlagsEXT { VK_IMAGE_COMPRESSION_DEFAULT_EXT, VK_IMAGE_COMPRESSION_FIXED_RATE_DEFAULT_EXT, VK_IMAGE_COMPRESSION_FIXED_RATE_EXPLICIT_EXT, VK_IMAGE_COMPRESSION_DISABLED_EXT });

/// `VkImageCompressionPropertiesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkImageCompressionPropertiesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub imageCompressionFlags: VkImageCompressionFlagsEXT,
    pub imageCompressionFixedRateFlags: VkImageCompressionFixedRateFlagsEXT,
}
impl_default_zeroed_with_s_type!(VkImageCompressionPropertiesEXT : VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT);
impl_extends!(VkImageCompressionPropertiesEXT : VkImageFormatProperties2, VkSurfaceFormat2KHR, VkSubresourceLayout2);

/// `VkImageConstraintsInfoFUCHSIA`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkImageConstraintsInfoFUCHSIA {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub formatConstraintsCount: uint32_t,
    pub pFormatConstraints: *const VkImageFormatConstraintsInfoFUCHSIA,
    pub bufferCollectionConstraints: VkBufferCollectionConstraintsInfoFUCHSIA,
    pub flags: VkImageConstraintsInfoFlagsFUCHSIA,
}
impl_default_zeroed_with_s_type!(VkImageConstraintsInfoFUCHSIA : VK_STRUCTURE_TYPE_IMAGE_CONSTRAINTS_INFO_FUCHSIA);

flags!(VkImageConstraintsInfoFlagsFUCHSIA);
from_into_transparent!(VkImageConstraintsInfoFlagsFUCHSIA: i32);
/// `VkImageConstraintsInfoFlagsFUCHSIA`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkImageConstraintsInfoFlagsFUCHSIA(pub i32);

/// `1 << 0`  
pub const VK_IMAGE_CONSTRAINTS_INFO_CPU_READ_RARELY_FUCHSIA: VkImageConstraintsInfoFlagsFUCHSIA = VkImageConstraintsInfoFlagsFUCHSIA(1 << 0);
/// `1 << 1`  
pub const VK_IMAGE_CONSTRAINTS_INFO_CPU_READ_OFTEN_FUCHSIA: VkImageConstraintsInfoFlagsFUCHSIA = VkImageConstraintsInfoFlagsFUCHSIA(1 << 1);
/// `1 << 2`  
pub const VK_IMAGE_CONSTRAINTS_INFO_CPU_WRITE_RARELY_FUCHSIA: VkImageConstraintsInfoFlagsFUCHSIA = VkImageConstraintsInfoFlagsFUCHSIA(1 << 2);
/// `1 << 3`  
pub const VK_IMAGE_CONSTRAINTS_INFO_CPU_WRITE_OFTEN_FUCHSIA: VkImageConstraintsInfoFlagsFUCHSIA = VkImageConstraintsInfoFlagsFUCHSIA(1 << 3);
/// `1 << 4`  
pub const VK_IMAGE_CONSTRAINTS_INFO_PROTECTED_OPTIONAL_FUCHSIA: VkImageConstraintsInfoFlagsFUCHSIA = VkImageConstraintsInfoFlagsFUCHSIA(1 << 4);

impl_flags_display!(VkImageConstraintsInfoFlagsFUCHSIA { VK_IMAGE_CONSTRAINTS_INFO_CPU_READ_RARELY_FUCHSIA, VK_IMAGE_CONSTRAINTS_INFO_CPU_READ_OFTEN_FUCHSIA, VK_IMAGE_CONSTRAINTS_INFO_CPU_WRITE_RARELY_FUCHSIA, VK_IMAGE_CONSTRAINTS_INFO_CPU_WRITE_OFTEN_FUCHSIA, VK_IMAGE_CONSTRAINTS_INFO_PROTECTED_OPTIONAL_FUCHSIA });

/// `VkImageCopy`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkImageCopy {
    pub srcSubresource: VkImageSubresourceLayers,
    /// Specified in pixels for both compressed and uncompressed images
    pub srcOffset: VkOffset3D,
    pub dstSubresource: VkImageSubresourceLayers,
    /// Specified in pixels for both compressed and uncompressed images
    pub dstOffset: VkOffset3D,
    /// Specified in pixels for both compressed and uncompressed images
    pub extent: VkExtent3D,
}
impl_default_zeroed!(VkImageCopy);

/// `VkImageCopy2`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkImageCopy2 {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub srcSubresource: VkImageSubresourceLayers,
    /// Specified in pixels for both compressed and uncompressed images
    pub srcOffset: VkOffset3D,
    pub dstSubresource: VkImageSubresourceLayers,
    /// Specified in pixels for both compressed and uncompressed images
    pub dstOffset: VkOffset3D,
    /// Specified in pixels for both compressed and uncompressed images
    pub extent: VkExtent3D,
}
impl_default_zeroed_with_s_type!(VkImageCopy2 : VK_STRUCTURE_TYPE_IMAGE_COPY_2);

/// `VkImageCopy2`
pub type VkImageCopy2KHR = VkImageCopy2;

flags!(VkImageCreateFlags);
from_into_transparent!(VkImageCreateFlags: i32);
/// `VkImageCreateFlags`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkImageCreateFlags(pub i32);

/// `1 << 0`  
/// 
/// Image should support sparse backing
pub const VK_IMAGE_CREATE_SPARSE_BINDING_BIT: VkImageCreateFlags = VkImageCreateFlags(1 << 0);
/// `1 << 1`  
/// 
/// Image should support sparse backing with partial residency
pub const VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT: VkImageCreateFlags = VkImageCreateFlags(1 << 1);
/// `1 << 2`  
/// 
/// Image should support constant data access to physical memory ranges mapped into multiple locations of sparse images
pub const VK_IMAGE_CREATE_SPARSE_ALIASED_BIT: VkImageCreateFlags = VkImageCreateFlags(1 << 2);
/// `1 << 3`  
/// 
/// Allows image views to have different format than the base image
pub const VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT: VkImageCreateFlags = VkImageCreateFlags(1 << 3);
/// `1 << 4`  
/// 
/// Allows creating image views with cube type from the created image
pub const VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT: VkImageCreateFlags = VkImageCreateFlags(1 << 4);
/// `1 << 10`  
pub const VK_IMAGE_CREATE_ALIAS_BIT: VkImageCreateFlags = VkImageCreateFlags(1 << 10);
/// `1 << 6`  
/// 
/// Allows using VkBindImageMemoryDeviceGroupInfo::pSplitInstanceBindRegions when binding memory to the image
pub const VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT: VkImageCreateFlags = VkImageCreateFlags(1 << 6);
/// `1 << 5`  
/// 
/// The 3D image can be viewed as a 2D or 2D array image
pub const VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT: VkImageCreateFlags = VkImageCreateFlags(1 << 5);
/// `1 << 7`  
pub const VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT: VkImageCreateFlags = VkImageCreateFlags(1 << 7);
/// `1 << 8`  
pub const VK_IMAGE_CREATE_EXTENDED_USAGE_BIT: VkImageCreateFlags = VkImageCreateFlags(1 << 8);
/// `1 << 11`  
/// 
/// Image requires protected memory
pub const VK_IMAGE_CREATE_PROTECTED_BIT: VkImageCreateFlags = VkImageCreateFlags(1 << 11);
/// `1 << 9`  
pub const VK_IMAGE_CREATE_DISJOINT_BIT: VkImageCreateFlags = VkImageCreateFlags(1 << 9);
/// `1 << 13`  
pub const VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV: VkImageCreateFlags = VkImageCreateFlags(1 << 13);
/// `VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT`  
pub const VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR: VkImageCreateFlags = VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT;
/// `VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT`  
pub const VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR: VkImageCreateFlags = VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT;
/// `1 << 21`  
pub const VK_IMAGE_CREATE_RESERVED_21_BIT_IMG: VkImageCreateFlags = VkImageCreateFlags(1 << 21);
/// `VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT`  
pub const VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT_KHR: VkImageCreateFlags = VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT;
/// `VK_IMAGE_CREATE_EXTENDED_USAGE_BIT`  
pub const VK_IMAGE_CREATE_EXTENDED_USAGE_BIT_KHR: VkImageCreateFlags = VK_IMAGE_CREATE_EXTENDED_USAGE_BIT;
/// `1 << 16`  
pub const VK_IMAGE_CREATE_DESCRIPTOR_HEAP_CAPTURE_REPLAY_BIT_EXT: VkImageCreateFlags = VkImageCreateFlags(1 << 16);
/// `1 << 12`  
pub const VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT: VkImageCreateFlags = VkImageCreateFlags(1 << 12);
/// `VK_IMAGE_CREATE_DISJOINT_BIT`  
pub const VK_IMAGE_CREATE_DISJOINT_BIT_KHR: VkImageCreateFlags = VK_IMAGE_CREATE_DISJOINT_BIT;
/// `VK_IMAGE_CREATE_ALIAS_BIT`  
pub const VK_IMAGE_CREATE_ALIAS_BIT_KHR: VkImageCreateFlags = VK_IMAGE_CREATE_ALIAS_BIT;
/// `1 << 14`  
pub const VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT: VkImageCreateFlags = VkImageCreateFlags(1 << 14);
/// `VK_IMAGE_CREATE_DESCRIPTOR_HEAP_CAPTURE_REPLAY_BIT_EXT`  
pub const VK_IMAGE_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT: VkImageCreateFlags = VK_IMAGE_CREATE_DESCRIPTOR_HEAP_CAPTURE_REPLAY_BIT_EXT;
/// `1 << 18`  
pub const VK_IMAGE_CREATE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_BIT_EXT: VkImageCreateFlags = VkImageCreateFlags(1 << 18);
/// `1 << 17`  
/// 
/// Image is created with a layout where individual slices are capable of being used as 2D images
pub const VK_IMAGE_CREATE_2D_VIEW_COMPATIBLE_BIT_EXT: VkImageCreateFlags = VkImageCreateFlags(1 << 17);
/// `VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_EXT`  
pub const VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_QCOM: VkImageCreateFlags = VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_EXT;
/// `1 << 20`  
pub const VK_IMAGE_CREATE_VIDEO_PROFILE_INDEPENDENT_BIT_KHR: VkImageCreateFlags = VkImageCreateFlags(1 << 20);
/// `1 << 15`  
pub const VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_EXT: VkImageCreateFlags = VkImageCreateFlags(1 << 15);
/// `1 << 22`  
pub const VK_IMAGE_CREATE_RESERVED_22_BIT_KHR: VkImageCreateFlags = VkImageCreateFlags(1 << 22);

impl_flags_display!(VkImageCreateFlags { VK_IMAGE_CREATE_SPARSE_BINDING_BIT, VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT, VK_IMAGE_CREATE_SPARSE_ALIASED_BIT, VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT, VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT, VK_IMAGE_CREATE_ALIAS_BIT, VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT, VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT, VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT, VK_IMAGE_CREATE_EXTENDED_USAGE_BIT, VK_IMAGE_CREATE_PROTECTED_BIT, VK_IMAGE_CREATE_DISJOINT_BIT, VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV, VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR, VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR, VK_IMAGE_CREATE_RESERVED_21_BIT_IMG, VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT_KHR, VK_IMAGE_CREATE_EXTENDED_USAGE_BIT_KHR, VK_IMAGE_CREATE_DESCRIPTOR_HEAP_CAPTURE_REPLAY_BIT_EXT, VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT, VK_IMAGE_CREATE_DISJOINT_BIT_KHR, VK_IMAGE_CREATE_ALIAS_BIT_KHR, VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT, VK_IMAGE_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT, VK_IMAGE_CREATE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_BIT_EXT, VK_IMAGE_CREATE_2D_VIEW_COMPATIBLE_BIT_EXT, VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_QCOM, VK_IMAGE_CREATE_VIDEO_PROFILE_INDEPENDENT_BIT_KHR, VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_EXT, VK_IMAGE_CREATE_RESERVED_22_BIT_KHR });

/// `VkImageCreateInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkImageCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    /// Image creation flags
    pub flags: VkImageCreateFlags,
    pub imageType: VkImageType,
    pub format: VkFormat,
    pub extent: VkExtent3D,
    pub mipLevels: uint32_t,
    pub arrayLayers: uint32_t,
    pub samples: VkSampleCountFlags,
    pub tiling: VkImageTiling,
    /// Image usage flags
    pub usage: VkImageUsageFlags,
    /// Cross-queue-family sharing mode
    pub sharingMode: VkSharingMode,
    /// Number of queue families to share across
    pub queueFamilyIndexCount: uint32_t,
    /// Array of queue family indices to share across
    pub pQueueFamilyIndices: *const uint32_t,
    /// Initial image layout for all subresources
    pub initialLayout: VkImageLayout,
}
impl_default_zeroed_with_s_type!(VkImageCreateInfo : VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO);

/// `VkImageDescriptorInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkImageDescriptorInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub pView: *const VkImageViewCreateInfo,
    pub layout: VkImageLayout,
}
impl_default_zeroed_with_s_type!(VkImageDescriptorInfoEXT : VK_STRUCTURE_TYPE_IMAGE_DESCRIPTOR_INFO_EXT);

/// `VkImageDrmFormatModifierExplicitCreateInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkImageDrmFormatModifierExplicitCreateInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub drmFormatModifier: uint64_t,
    pub drmFormatModifierPlaneCount: uint32_t,
    pub pPlaneLayouts: *const VkSubresourceLayout,
}
impl_default_zeroed_with_s_type!(VkImageDrmFormatModifierExplicitCreateInfoEXT : VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT);
impl_extends!(VkImageDrmFormatModifierExplicitCreateInfoEXT : VkImageCreateInfo);

/// `VkImageDrmFormatModifierListCreateInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkImageDrmFormatModifierListCreateInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub drmFormatModifierCount: uint32_t,
    pub pDrmFormatModifiers: *const uint64_t,
}
impl_default_zeroed_with_s_type!(VkImageDrmFormatModifierListCreateInfoEXT : VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT);
impl_extends!(VkImageDrmFormatModifierListCreateInfoEXT : VkImageCreateInfo);

/// `VkImageDrmFormatModifierPropertiesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkImageDrmFormatModifierPropertiesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub drmFormatModifier: uint64_t,
}
impl_default_zeroed_with_s_type!(VkImageDrmFormatModifierPropertiesEXT : VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT);

flags!(VkImageFormatConstraintsFlagsFUCHSIA);
from_into_transparent!(VkImageFormatConstraintsFlagsFUCHSIA: i32);
/// `VkImageFormatConstraintsFlagsFUCHSIA`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkImageFormatConstraintsFlagsFUCHSIA(pub i32);

impl_flags_display!(VkImageFormatConstraintsFlagsFUCHSIA {  });

/// `VkImageFormatConstraintsInfoFUCHSIA`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkImageFormatConstraintsInfoFUCHSIA {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub imageCreateInfo: VkImageCreateInfo,
    pub requiredFormatFeatures: VkFormatFeatureFlags,
    pub flags: VkImageFormatConstraintsFlagsFUCHSIA,
    pub sysmemPixelFormat: uint64_t,
    pub colorSpaceCount: uint32_t,
    pub pColorSpaces: *const VkSysmemColorSpaceFUCHSIA,
}
impl_default_zeroed_with_s_type!(VkImageFormatConstraintsInfoFUCHSIA : VK_STRUCTURE_TYPE_IMAGE_FORMAT_CONSTRAINTS_INFO_FUCHSIA);

/// `VkImageFormatListCreateInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkImageFormatListCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub viewFormatCount: uint32_t,
    pub pViewFormats: *const VkFormat,
}
impl_default_zeroed_with_s_type!(VkImageFormatListCreateInfo : VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO);
impl_extends!(VkImageFormatListCreateInfo : VkImageCreateInfo, VkSwapchainCreateInfoKHR, VkPhysicalDeviceImageFormatInfo2);

/// `VkImageFormatListCreateInfo`
pub type VkImageFormatListCreateInfoKHR = VkImageFormatListCreateInfo;

/// `VkImageFormatProperties`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkImageFormatProperties {
    /// max image dimensions for this resource type
    pub maxExtent: VkExtent3D,
    /// max number of mipmap levels for this resource type
    pub maxMipLevels: uint32_t,
    /// max array size for this resource type
    pub maxArrayLayers: uint32_t,
    /// supported sample counts for this resource type
    pub sampleCounts: VkSampleCountFlags,
    /// max size (in bytes) of this resource type
    pub maxResourceSize: VkDeviceSize,
}
impl_default_zeroed!(VkImageFormatProperties);

/// `VkImageFormatProperties2`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkImageFormatProperties2 {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub imageFormatProperties: VkImageFormatProperties,
}
impl_default_zeroed_with_s_type!(VkImageFormatProperties2 : VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2);

/// `VkImageFormatProperties2`
pub type VkImageFormatProperties2KHR = VkImageFormatProperties2;

from_into_transparent!(VkImageLayout: i32);
/// `VkImageLayout`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkImageLayout(pub i32);

/// `0`  
/// 
/// Implicit layout an image is when its contents are undefined due to various reasons (e.g. right after creation)
pub const VK_IMAGE_LAYOUT_UNDEFINED: VkImageLayout = VkImageLayout(0);
/// `1`  
/// 
/// General layout when image can be used for any kind of access
pub const VK_IMAGE_LAYOUT_GENERAL: VkImageLayout = VkImageLayout(1);
/// `2`  
/// 
/// Optimal layout when image is only used for color attachment read/write
pub const VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL: VkImageLayout = VkImageLayout(2);
/// `3`  
/// 
/// Optimal layout when image is only used for depth/stencil attachment read/write
pub const VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL: VkImageLayout = VkImageLayout(3);
/// `4`  
/// 
/// Optimal layout when image is used for read only depth/stencil attachment and shader access
pub const VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL: VkImageLayout = VkImageLayout(4);
/// `5`  
/// 
/// Optimal layout when image is used for read only shader access
pub const VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL: VkImageLayout = VkImageLayout(5);
/// `6`  
/// 
/// Optimal layout when image is used only as source of transfer operations
pub const VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL: VkImageLayout = VkImageLayout(6);
/// `7`  
/// 
/// Optimal layout when image is used only as destination of transfer operations
pub const VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL: VkImageLayout = VkImageLayout(7);
/// `8`  
/// 
/// Initial layout used when the data is populated by the CPU
pub const VK_IMAGE_LAYOUT_PREINITIALIZED: VkImageLayout = VkImageLayout(8);
/// `1000117000`  
pub const VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL: VkImageLayout = VkImageLayout(1000117000);
/// `1000117001`  
pub const VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL: VkImageLayout = VkImageLayout(1000117001);
/// `1000241000`  
pub const VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL: VkImageLayout = VkImageLayout(1000241000);
/// `1000241001`  
pub const VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL: VkImageLayout = VkImageLayout(1000241001);
/// `1000241002`  
pub const VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL: VkImageLayout = VkImageLayout(1000241002);
/// `1000241003`  
pub const VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL: VkImageLayout = VkImageLayout(1000241003);
/// `1000314000`  
pub const VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL: VkImageLayout = VkImageLayout(1000314000);
/// `1000314001`  
pub const VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL: VkImageLayout = VkImageLayout(1000314001);
/// `1000232000`  
pub const VK_IMAGE_LAYOUT_RENDERING_LOCAL_READ: VkImageLayout = VkImageLayout(1000232000);
/// `1000001002`  
pub const VK_IMAGE_LAYOUT_PRESENT_SRC_KHR: VkImageLayout = VkImageLayout(1000001002);
/// `1000024000`  
pub const VK_IMAGE_LAYOUT_VIDEO_DECODE_DST_KHR: VkImageLayout = VkImageLayout(1000024000);
/// `1000024001`  
pub const VK_IMAGE_LAYOUT_VIDEO_DECODE_SRC_KHR: VkImageLayout = VkImageLayout(1000024001);
/// `1000024002`  
pub const VK_IMAGE_LAYOUT_VIDEO_DECODE_DPB_KHR: VkImageLayout = VkImageLayout(1000024002);
/// `1000111000`  
pub const VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR: VkImageLayout = VkImageLayout(1000111000);
/// `VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL`  
pub const VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR: VkImageLayout = VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL;
/// `VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL`  
pub const VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL_KHR: VkImageLayout = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL;
/// `VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR`  
pub const VK_IMAGE_LAYOUT_SHADING_RATE_OPTIMAL_NV: VkImageLayout = VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR;
/// `1000218000`  
pub const VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT: VkImageLayout = VkImageLayout(1000218000);
/// `1000164003`  
pub const VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR: VkImageLayout = VkImageLayout(1000164003);
/// `VK_IMAGE_LAYOUT_RENDERING_LOCAL_READ`  
pub const VK_IMAGE_LAYOUT_RENDERING_LOCAL_READ_KHR: VkImageLayout = VK_IMAGE_LAYOUT_RENDERING_LOCAL_READ;
/// `VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL`  
pub const VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL_KHR: VkImageLayout = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL;
/// `VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL`  
pub const VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL_KHR: VkImageLayout = VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL;
/// `VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL`  
pub const VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL_KHR: VkImageLayout = VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL;
/// `VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL`  
pub const VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL_KHR: VkImageLayout = VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL;
/// `1000299000`  
pub const VK_IMAGE_LAYOUT_VIDEO_ENCODE_DST_KHR: VkImageLayout = VkImageLayout(1000299000);
/// `1000299001`  
pub const VK_IMAGE_LAYOUT_VIDEO_ENCODE_SRC_KHR: VkImageLayout = VkImageLayout(1000299001);
/// `1000299002`  
pub const VK_IMAGE_LAYOUT_VIDEO_ENCODE_DPB_KHR: VkImageLayout = VkImageLayout(1000299002);
/// `VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL`  
pub const VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL_KHR: VkImageLayout = VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL;
/// `VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL`  
pub const VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL_KHR: VkImageLayout = VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL;
/// `1000339000`  
pub const VK_IMAGE_LAYOUT_ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT: VkImageLayout = VkImageLayout(1000339000);
/// `1000460000`  
pub const VK_IMAGE_LAYOUT_TENSOR_ALIASING_ARM: VkImageLayout = VkImageLayout(1000460000);
/// `1000553000`  
pub const VK_IMAGE_LAYOUT_VIDEO_ENCODE_QUANTIZATION_MAP_KHR: VkImageLayout = VkImageLayout(1000553000);
/// `1000620000`  
pub const VK_IMAGE_LAYOUT_ZERO_INITIALIZED_EXT: VkImageLayout = VkImageLayout(1000620000);

impl_enum_display!(VkImageLayout { VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_PREINITIALIZED, VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_RENDERING_LOCAL_READ, VK_IMAGE_LAYOUT_PRESENT_SRC_KHR, VK_IMAGE_LAYOUT_VIDEO_DECODE_DST_KHR, VK_IMAGE_LAYOUT_VIDEO_DECODE_SRC_KHR, VK_IMAGE_LAYOUT_VIDEO_DECODE_DPB_KHR, VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR, VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL_KHR, VK_IMAGE_LAYOUT_SHADING_RATE_OPTIMAL_NV, VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT, VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR, VK_IMAGE_LAYOUT_RENDERING_LOCAL_READ_KHR, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL_KHR, VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL_KHR, VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL_KHR, VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL_KHR, VK_IMAGE_LAYOUT_VIDEO_ENCODE_DST_KHR, VK_IMAGE_LAYOUT_VIDEO_ENCODE_SRC_KHR, VK_IMAGE_LAYOUT_VIDEO_ENCODE_DPB_KHR, VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL_KHR, VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL_KHR, VK_IMAGE_LAYOUT_ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT, VK_IMAGE_LAYOUT_TENSOR_ALIASING_ARM, VK_IMAGE_LAYOUT_VIDEO_ENCODE_QUANTIZATION_MAP_KHR, VK_IMAGE_LAYOUT_ZERO_INITIALIZED_EXT });

/// `VkImageMemoryBarrier`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkImageMemoryBarrier {
    pub sType: VkStructureType,
    pub pNext: *const void,
    /// Memory accesses from the source of the dependency to synchronize
    pub srcAccessMask: VkAccessFlags,
    /// Memory accesses from the destination of the dependency to synchronize
    pub dstAccessMask: VkAccessFlags,
    /// Current layout of the image
    pub oldLayout: VkImageLayout,
    /// New layout to transition the image to
    pub newLayout: VkImageLayout,
    /// Queue family to transition ownership from
    pub srcQueueFamilyIndex: uint32_t,
    /// Queue family to transition ownership to
    pub dstQueueFamilyIndex: uint32_t,
    /// Image to sync
    pub image: VkImage,
    /// Subresource range to sync
    pub subresourceRange: VkImageSubresourceRange,
}
impl_default_zeroed_with_s_type!(VkImageMemoryBarrier : VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER);

/// `VkImageMemoryBarrier2`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkImageMemoryBarrier2 {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub srcStageMask: VkPipelineStageFlags2,
    pub srcAccessMask: VkAccessFlags2,
    pub dstStageMask: VkPipelineStageFlags2,
    pub dstAccessMask: VkAccessFlags2,
    pub oldLayout: VkImageLayout,
    pub newLayout: VkImageLayout,
    pub srcQueueFamilyIndex: uint32_t,
    pub dstQueueFamilyIndex: uint32_t,
    pub image: VkImage,
    pub subresourceRange: VkImageSubresourceRange,
}
impl_default_zeroed_with_s_type!(VkImageMemoryBarrier2 : VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2);

/// `VkImageMemoryBarrier2`
pub type VkImageMemoryBarrier2KHR = VkImageMemoryBarrier2;

/// `VkImageMemoryRequirementsInfo2`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkImageMemoryRequirementsInfo2 {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub image: VkImage,
}
impl_default_zeroed_with_s_type!(VkImageMemoryRequirementsInfo2 : VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2);

/// `VkImageMemoryRequirementsInfo2`
pub type VkImageMemoryRequirementsInfo2KHR = VkImageMemoryRequirementsInfo2;

flags!(VkImagePipeSurfaceCreateFlagsFUCHSIA);
from_into_transparent!(VkImagePipeSurfaceCreateFlagsFUCHSIA: i32);
/// `VkImagePipeSurfaceCreateFlagsFUCHSIA`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkImagePipeSurfaceCreateFlagsFUCHSIA(pub i32);

impl_flags_display!(VkImagePipeSurfaceCreateFlagsFUCHSIA {  });

/// `VkImagePipeSurfaceCreateInfoFUCHSIA`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkImagePipeSurfaceCreateInfoFUCHSIA {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub flags: VkImagePipeSurfaceCreateFlagsFUCHSIA,
    pub imagePipeHandle: zx_handle_t,
}
impl_default_zeroed_with_s_type!(VkImagePipeSurfaceCreateInfoFUCHSIA : VK_STRUCTURE_TYPE_IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA);

/// `VkImagePlaneMemoryRequirementsInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkImagePlaneMemoryRequirementsInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub planeAspect: VkImageAspectFlags,
}
impl_default_zeroed_with_s_type!(VkImagePlaneMemoryRequirementsInfo : VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO);
impl_extends!(VkImagePlaneMemoryRequirementsInfo : VkImageMemoryRequirementsInfo2);

/// `VkImagePlaneMemoryRequirementsInfo`
pub type VkImagePlaneMemoryRequirementsInfoKHR = VkImagePlaneMemoryRequirementsInfo;

/// `VkImageResolve`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkImageResolve {
    pub srcSubresource: VkImageSubresourceLayers,
    pub srcOffset: VkOffset3D,
    pub dstSubresource: VkImageSubresourceLayers,
    pub dstOffset: VkOffset3D,
    pub extent: VkExtent3D,
}
impl_default_zeroed!(VkImageResolve);

/// `VkImageResolve2`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkImageResolve2 {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub srcSubresource: VkImageSubresourceLayers,
    pub srcOffset: VkOffset3D,
    pub dstSubresource: VkImageSubresourceLayers,
    pub dstOffset: VkOffset3D,
    pub extent: VkExtent3D,
}
impl_default_zeroed_with_s_type!(VkImageResolve2 : VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2);

/// `VkImageResolve2`
pub type VkImageResolve2KHR = VkImageResolve2;

/// `VkImageSparseMemoryRequirementsInfo2`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkImageSparseMemoryRequirementsInfo2 {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub image: VkImage,
}
impl_default_zeroed_with_s_type!(VkImageSparseMemoryRequirementsInfo2 : VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2);

/// `VkImageSparseMemoryRequirementsInfo2`
pub type VkImageSparseMemoryRequirementsInfo2KHR = VkImageSparseMemoryRequirementsInfo2;

/// `VkImageStencilUsageCreateInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkImageStencilUsageCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub stencilUsage: VkImageUsageFlags,
}
impl_default_zeroed_with_s_type!(VkImageStencilUsageCreateInfo : VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO);
impl_extends!(VkImageStencilUsageCreateInfo : VkImageCreateInfo, VkPhysicalDeviceImageFormatInfo2);

/// `VkImageStencilUsageCreateInfo`
pub type VkImageStencilUsageCreateInfoEXT = VkImageStencilUsageCreateInfo;

/// `VkImageSubresource`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkImageSubresource {
    pub aspectMask: VkImageAspectFlags,
    pub mipLevel: uint32_t,
    pub arrayLayer: uint32_t,
}
impl_default_zeroed!(VkImageSubresource);

/// `VkImageSubresource2`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkImageSubresource2 {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub imageSubresource: VkImageSubresource,
}
impl_default_zeroed_with_s_type!(VkImageSubresource2 : VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2);

/// `VkImageSubresource2`
pub type VkImageSubresource2EXT = VkImageSubresource2;

/// `VkImageSubresource2`
pub type VkImageSubresource2KHR = VkImageSubresource2;

/// `VkImageSubresourceLayers`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkImageSubresourceLayers {
    pub aspectMask: VkImageAspectFlags,
    pub mipLevel: uint32_t,
    pub baseArrayLayer: uint32_t,
    pub layerCount: uint32_t,
}
impl_default_zeroed!(VkImageSubresourceLayers);

/// `VkImageSubresourceRange`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkImageSubresourceRange {
    pub aspectMask: VkImageAspectFlags,
    pub baseMipLevel: uint32_t,
    pub levelCount: uint32_t,
    pub baseArrayLayer: uint32_t,
    pub layerCount: uint32_t,
}
impl_default_zeroed!(VkImageSubresourceRange);

/// `VkImageSwapchainCreateInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkImageSwapchainCreateInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub swapchain: VkSwapchainKHR,
}
impl_default_zeroed_with_s_type!(VkImageSwapchainCreateInfoKHR : VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR);
impl_extends!(VkImageSwapchainCreateInfoKHR : VkImageCreateInfo);

from_into_transparent!(VkImageTiling: i32);
/// `VkImageTiling`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkImageTiling(pub i32);

/// `0`  
pub const VK_IMAGE_TILING_OPTIMAL: VkImageTiling = VkImageTiling(0);
/// `1`  
pub const VK_IMAGE_TILING_LINEAR: VkImageTiling = VkImageTiling(1);
/// `1000158000`  
pub const VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT: VkImageTiling = VkImageTiling(1000158000);

impl_enum_display!(VkImageTiling { VK_IMAGE_TILING_OPTIMAL, VK_IMAGE_TILING_LINEAR, VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT });

/// `VkImageToMemoryCopy`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkImageToMemoryCopy {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub pHostPointer: *mut void,
    /// Specified in texels
    pub memoryRowLength: uint32_t,
    pub memoryImageHeight: uint32_t,
    pub imageSubresource: VkImageSubresourceLayers,
    pub imageOffset: VkOffset3D,
    pub imageExtent: VkExtent3D,
}
impl_default_zeroed_with_s_type!(VkImageToMemoryCopy : VK_STRUCTURE_TYPE_IMAGE_TO_MEMORY_COPY);

/// `VkImageToMemoryCopy`
pub type VkImageToMemoryCopyEXT = VkImageToMemoryCopy;

from_into_transparent!(VkImageType: i32);
/// `VkImageType`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkImageType(pub i32);

/// `0`  
pub const VK_IMAGE_TYPE_1D: VkImageType = VkImageType(0);
/// `1`  
pub const VK_IMAGE_TYPE_2D: VkImageType = VkImageType(1);
/// `2`  
pub const VK_IMAGE_TYPE_3D: VkImageType = VkImageType(2);

impl_enum_display!(VkImageType { VK_IMAGE_TYPE_1D, VK_IMAGE_TYPE_2D, VK_IMAGE_TYPE_3D });

flags!(VkImageUsageFlags);
from_into_transparent!(VkImageUsageFlags: i32);
/// `VkImageUsageFlags`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkImageUsageFlags(pub i32);

/// `1 << 0`  
/// 
/// Can be used as a source of transfer operations
pub const VK_IMAGE_USAGE_TRANSFER_SRC_BIT: VkImageUsageFlags = VkImageUsageFlags(1 << 0);
/// `1 << 1`  
/// 
/// Can be used as a destination of transfer operations
pub const VK_IMAGE_USAGE_TRANSFER_DST_BIT: VkImageUsageFlags = VkImageUsageFlags(1 << 1);
/// `1 << 2`  
/// 
/// Can be sampled from (SAMPLED_IMAGE and COMBINED_IMAGE_SAMPLER descriptor types)
pub const VK_IMAGE_USAGE_SAMPLED_BIT: VkImageUsageFlags = VkImageUsageFlags(1 << 2);
/// `1 << 3`  
/// 
/// Can be used as storage image (STORAGE_IMAGE descriptor type)
pub const VK_IMAGE_USAGE_STORAGE_BIT: VkImageUsageFlags = VkImageUsageFlags(1 << 3);
/// `1 << 4`  
/// 
/// Can be used as framebuffer color attachment
pub const VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT: VkImageUsageFlags = VkImageUsageFlags(1 << 4);
/// `1 << 5`  
/// 
/// Can be used as framebuffer depth/stencil attachment
pub const VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT: VkImageUsageFlags = VkImageUsageFlags(1 << 5);
/// `1 << 6`  
/// 
/// Image data not needed outside of rendering
pub const VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT: VkImageUsageFlags = VkImageUsageFlags(1 << 6);
/// `1 << 7`  
/// 
/// Can be used as framebuffer input attachment
pub const VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT: VkImageUsageFlags = VkImageUsageFlags(1 << 7);
/// `1 << 22`  
pub const VK_IMAGE_USAGE_HOST_TRANSFER_BIT: VkImageUsageFlags = VkImageUsageFlags(1 << 22);
/// `1 << 10`  
pub const VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR: VkImageUsageFlags = VkImageUsageFlags(1 << 10);
/// `1 << 11`  
pub const VK_IMAGE_USAGE_VIDEO_DECODE_SRC_BIT_KHR: VkImageUsageFlags = VkImageUsageFlags(1 << 11);
/// `1 << 12`  
pub const VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR: VkImageUsageFlags = VkImageUsageFlags(1 << 12);
/// `VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR`  
pub const VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV: VkImageUsageFlags = VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR;
/// `1 << 9`  
pub const VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT: VkImageUsageFlags = VkImageUsageFlags(1 << 9);
/// `1 << 8`  
pub const VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR: VkImageUsageFlags = VkImageUsageFlags(1 << 8);
/// `VK_IMAGE_USAGE_HOST_TRANSFER_BIT`  
/// 
/// Can be used with host image copies
pub const VK_IMAGE_USAGE_HOST_TRANSFER_BIT_EXT: VkImageUsageFlags = VK_IMAGE_USAGE_HOST_TRANSFER_BIT;
/// `1 << 13`  
pub const VK_IMAGE_USAGE_VIDEO_ENCODE_DST_BIT_KHR: VkImageUsageFlags = VkImageUsageFlags(1 << 13);
/// `1 << 14`  
pub const VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR: VkImageUsageFlags = VkImageUsageFlags(1 << 14);
/// `1 << 15`  
pub const VK_IMAGE_USAGE_VIDEO_ENCODE_DPB_BIT_KHR: VkImageUsageFlags = VkImageUsageFlags(1 << 15);
/// `1 << 19`  
pub const VK_IMAGE_USAGE_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT: VkImageUsageFlags = VkImageUsageFlags(1 << 19);
/// `1 << 18`  
pub const VK_IMAGE_USAGE_INVOCATION_MASK_BIT_HUAWEI: VkImageUsageFlags = VkImageUsageFlags(1 << 18);
/// `1 << 20`  
pub const VK_IMAGE_USAGE_SAMPLE_WEIGHT_BIT_QCOM: VkImageUsageFlags = VkImageUsageFlags(1 << 20);
/// `1 << 21`  
pub const VK_IMAGE_USAGE_SAMPLE_BLOCK_MATCH_BIT_QCOM: VkImageUsageFlags = VkImageUsageFlags(1 << 21);
/// `1 << 24`  
pub const VK_IMAGE_USAGE_RESERVED_24_BIT_COREAVI: VkImageUsageFlags = VkImageUsageFlags(1 << 24);
/// `1 << 23`  
pub const VK_IMAGE_USAGE_TENSOR_ALIASING_BIT_ARM: VkImageUsageFlags = VkImageUsageFlags(1 << 23);
/// `1 << 28`  
pub const VK_IMAGE_USAGE_RESERVED_28_BIT_EXT: VkImageUsageFlags = VkImageUsageFlags(1 << 28);
/// `1 << 27`  
pub const VK_IMAGE_USAGE_TILE_MEMORY_BIT_QCOM: VkImageUsageFlags = VkImageUsageFlags(1 << 27);
/// `1 << 25`  
pub const VK_IMAGE_USAGE_VIDEO_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR: VkImageUsageFlags = VkImageUsageFlags(1 << 25);
/// `1 << 26`  
pub const VK_IMAGE_USAGE_VIDEO_ENCODE_EMPHASIS_MAP_BIT_KHR: VkImageUsageFlags = VkImageUsageFlags(1 << 26);
/// `1 << 29`  
pub const VK_IMAGE_USAGE_RESERVED_29_BIT_KHR: VkImageUsageFlags = VkImageUsageFlags(1 << 29);
/// `1 << 30`  
pub const VK_IMAGE_USAGE_RESERVED_30_BIT_KHR: VkImageUsageFlags = VkImageUsageFlags(1 << 30);
/// `1 << 16`  
pub const VK_IMAGE_USAGE_RESERVED_16_BIT_HUAWEI: VkImageUsageFlags = VkImageUsageFlags(1 << 16);
/// `1 << 17`  
pub const VK_IMAGE_USAGE_RESERVED_27_BIT_HUAWEI: VkImageUsageFlags = VkImageUsageFlags(1 << 17);

impl_flags_display!(VkImageUsageFlags { VK_IMAGE_USAGE_TRANSFER_SRC_BIT, VK_IMAGE_USAGE_TRANSFER_DST_BIT, VK_IMAGE_USAGE_SAMPLED_BIT, VK_IMAGE_USAGE_STORAGE_BIT, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT, VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT, VK_IMAGE_USAGE_HOST_TRANSFER_BIT, VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR, VK_IMAGE_USAGE_VIDEO_DECODE_SRC_BIT_KHR, VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR, VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV, VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT, VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR, VK_IMAGE_USAGE_HOST_TRANSFER_BIT_EXT, VK_IMAGE_USAGE_VIDEO_ENCODE_DST_BIT_KHR, VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR, VK_IMAGE_USAGE_VIDEO_ENCODE_DPB_BIT_KHR, VK_IMAGE_USAGE_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT, VK_IMAGE_USAGE_INVOCATION_MASK_BIT_HUAWEI, VK_IMAGE_USAGE_SAMPLE_WEIGHT_BIT_QCOM, VK_IMAGE_USAGE_SAMPLE_BLOCK_MATCH_BIT_QCOM, VK_IMAGE_USAGE_RESERVED_24_BIT_COREAVI, VK_IMAGE_USAGE_TENSOR_ALIASING_BIT_ARM, VK_IMAGE_USAGE_RESERVED_28_BIT_EXT, VK_IMAGE_USAGE_TILE_MEMORY_BIT_QCOM, VK_IMAGE_USAGE_VIDEO_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR, VK_IMAGE_USAGE_VIDEO_ENCODE_EMPHASIS_MAP_BIT_KHR, VK_IMAGE_USAGE_RESERVED_29_BIT_KHR, VK_IMAGE_USAGE_RESERVED_30_BIT_KHR, VK_IMAGE_USAGE_RESERVED_16_BIT_HUAWEI, VK_IMAGE_USAGE_RESERVED_27_BIT_HUAWEI });

/// `VkImageView` : `VkDevice`
#[repr(transparent)]
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkImageView(pub u64);
from_into_transparent!(VkImageView: u64);
impl_handle!(VkImageView: VK_OBJECT_TYPE_IMAGE_VIEW; SubHandle = VkDevice);

/// `VkImageViewASTCDecodeModeEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkImageViewASTCDecodeModeEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub decodeMode: VkFormat,
}
impl_default_zeroed_with_s_type!(VkImageViewASTCDecodeModeEXT : VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT);
impl_extends!(VkImageViewASTCDecodeModeEXT : VkImageViewCreateInfo);

/// `VkImageViewAddressPropertiesNVX`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkImageViewAddressPropertiesNVX {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub deviceAddress: VkDeviceAddress,
    pub size: VkDeviceSize,
}
impl_default_zeroed_with_s_type!(VkImageViewAddressPropertiesNVX : VK_STRUCTURE_TYPE_IMAGE_VIEW_ADDRESS_PROPERTIES_NVX);

/// `VkImageViewCaptureDescriptorDataInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkImageViewCaptureDescriptorDataInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub imageView: VkImageView,
}
impl_default_zeroed_with_s_type!(VkImageViewCaptureDescriptorDataInfoEXT : VK_STRUCTURE_TYPE_IMAGE_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_EXT);

flags!(VkImageViewCreateFlags);
from_into_transparent!(VkImageViewCreateFlags: i32);
/// `VkImageViewCreateFlags`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkImageViewCreateFlags(pub i32);

/// `1 << 0`  
pub const VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DYNAMIC_BIT_EXT: VkImageViewCreateFlags = VkImageViewCreateFlags(1 << 0);
/// `1 << 2`  
pub const VK_IMAGE_VIEW_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT: VkImageViewCreateFlags = VkImageViewCreateFlags(1 << 2);
/// `1 << 1`  
pub const VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DEFERRED_BIT_EXT: VkImageViewCreateFlags = VkImageViewCreateFlags(1 << 1);

impl_flags_display!(VkImageViewCreateFlags { VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DYNAMIC_BIT_EXT, VK_IMAGE_VIEW_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT, VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DEFERRED_BIT_EXT });

/// `VkImageViewCreateInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkImageViewCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub flags: VkImageViewCreateFlags,
    pub image: VkImage,
    pub viewType: VkImageViewType,
    pub format: VkFormat,
    pub components: VkComponentMapping,
    pub subresourceRange: VkImageSubresourceRange,
}
impl_default_zeroed_with_s_type!(VkImageViewCreateInfo : VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO);

/// `VkImageViewHandleInfoNVX`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkImageViewHandleInfoNVX {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub imageView: VkImageView,
    pub descriptorType: VkDescriptorType,
    pub sampler: VkSampler,
}
impl_default_zeroed_with_s_type!(VkImageViewHandleInfoNVX : VK_STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX);

/// `VkImageViewMinLodCreateInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkImageViewMinLodCreateInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub minLod: float,
}
impl_default_zeroed_with_s_type!(VkImageViewMinLodCreateInfoEXT : VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT);
impl_extends!(VkImageViewMinLodCreateInfoEXT : VkImageViewCreateInfo);

/// `VkImageViewSampleWeightCreateInfoQCOM`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkImageViewSampleWeightCreateInfoQCOM {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub filterCenter: VkOffset2D,
    pub filterSize: VkExtent2D,
    pub numPhases: uint32_t,
}
impl_default_zeroed_with_s_type!(VkImageViewSampleWeightCreateInfoQCOM : VK_STRUCTURE_TYPE_IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM);
impl_extends!(VkImageViewSampleWeightCreateInfoQCOM : VkImageViewCreateInfo);

/// `VkImageViewSlicedCreateInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkImageViewSlicedCreateInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub sliceOffset: uint32_t,
    pub sliceCount: uint32_t,
}
impl_default_zeroed_with_s_type!(VkImageViewSlicedCreateInfoEXT : VK_STRUCTURE_TYPE_IMAGE_VIEW_SLICED_CREATE_INFO_EXT);
impl_extends!(VkImageViewSlicedCreateInfoEXT : VkImageViewCreateInfo);

from_into_transparent!(VkImageViewType: i32);
/// `VkImageViewType`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkImageViewType(pub i32);

/// `0`  
pub const VK_IMAGE_VIEW_TYPE_1D: VkImageViewType = VkImageViewType(0);
/// `1`  
pub const VK_IMAGE_VIEW_TYPE_2D: VkImageViewType = VkImageViewType(1);
/// `2`  
pub const VK_IMAGE_VIEW_TYPE_3D: VkImageViewType = VkImageViewType(2);
/// `3`  
pub const VK_IMAGE_VIEW_TYPE_CUBE: VkImageViewType = VkImageViewType(3);
/// `4`  
pub const VK_IMAGE_VIEW_TYPE_1D_ARRAY: VkImageViewType = VkImageViewType(4);
/// `5`  
pub const VK_IMAGE_VIEW_TYPE_2D_ARRAY: VkImageViewType = VkImageViewType(5);
/// `6`  
pub const VK_IMAGE_VIEW_TYPE_CUBE_ARRAY: VkImageViewType = VkImageViewType(6);

impl_enum_display!(VkImageViewType { VK_IMAGE_VIEW_TYPE_1D, VK_IMAGE_VIEW_TYPE_2D, VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY, VK_IMAGE_VIEW_TYPE_CUBE_ARRAY });

/// `VkImageViewUsageCreateInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkImageViewUsageCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub usage: VkImageUsageFlags,
}
impl_default_zeroed_with_s_type!(VkImageViewUsageCreateInfo : VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO);
impl_extends!(VkImageViewUsageCreateInfo : VkImageViewCreateInfo);

/// `VkImageViewUsageCreateInfo`
pub type VkImageViewUsageCreateInfoKHR = VkImageViewUsageCreateInfo;

/// `VkImportAndroidHardwareBufferInfoANDROID`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkImportAndroidHardwareBufferInfoANDROID {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub buffer: *mut AHardwareBuffer,
}
impl_default_zeroed_with_s_type!(VkImportAndroidHardwareBufferInfoANDROID : VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID);
impl_extends!(VkImportAndroidHardwareBufferInfoANDROID : VkMemoryAllocateInfo);

/// `VkImportFenceFdInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkImportFenceFdInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub fence: VkFence,
    pub flags: VkFenceImportFlags,
    pub handleType: VkExternalFenceHandleTypeFlags,
    pub fd: int,
}
impl_default_zeroed_with_s_type!(VkImportFenceFdInfoKHR : VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR);

/// `VkImportFenceSciSyncInfoNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkImportFenceSciSyncInfoNV {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub fence: VkFence,
    pub handleType: VkExternalFenceHandleTypeFlags,
    pub handle: *mut void,
}
impl_default_zeroed_with_s_type!(VkImportFenceSciSyncInfoNV : VK_STRUCTURE_TYPE_IMPORT_FENCE_SCI_SYNC_INFO_NV);

/// `VkImportFenceWin32HandleInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkImportFenceWin32HandleInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub fence: VkFence,
    pub flags: VkFenceImportFlags,
    pub handleType: VkExternalFenceHandleTypeFlags,
    pub handle: HANDLE,
    pub name: LPCWSTR,
}
impl_default_zeroed_with_s_type!(VkImportFenceWin32HandleInfoKHR : VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR);

/// `VkImportMemoryBufferCollectionFUCHSIA`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkImportMemoryBufferCollectionFUCHSIA {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub collection: VkBufferCollectionFUCHSIA,
    pub index: uint32_t,
}
impl_default_zeroed_with_s_type!(VkImportMemoryBufferCollectionFUCHSIA : VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA);
impl_extends!(VkImportMemoryBufferCollectionFUCHSIA : VkMemoryAllocateInfo);

/// `VkImportMemoryFdInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkImportMemoryFdInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub handleType: VkExternalMemoryHandleTypeFlags,
    pub fd: int,
}
impl_default_zeroed_with_s_type!(VkImportMemoryFdInfoKHR : VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR);
impl_extends!(VkImportMemoryFdInfoKHR : VkMemoryAllocateInfo);

/// `VkImportMemoryHostPointerInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkImportMemoryHostPointerInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub handleType: VkExternalMemoryHandleTypeFlags,
    pub pHostPointer: *mut void,
}
impl_default_zeroed_with_s_type!(VkImportMemoryHostPointerInfoEXT : VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT);
impl_extends!(VkImportMemoryHostPointerInfoEXT : VkMemoryAllocateInfo);

/// `VkImportMemoryMetalHandleInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkImportMemoryMetalHandleInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub handleType: VkExternalMemoryHandleTypeFlags,
    pub handle: *mut void,
}
impl_default_zeroed_with_s_type!(VkImportMemoryMetalHandleInfoEXT : VK_STRUCTURE_TYPE_IMPORT_MEMORY_METAL_HANDLE_INFO_EXT);
impl_extends!(VkImportMemoryMetalHandleInfoEXT : VkMemoryAllocateInfo);

/// `VkImportMemorySciBufInfoNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkImportMemorySciBufInfoNV {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub handleType: VkExternalMemoryHandleTypeFlags,
    pub handle: NvSciBufObj,
}
impl_default_zeroed_with_s_type!(VkImportMemorySciBufInfoNV : VK_STRUCTURE_TYPE_IMPORT_MEMORY_SCI_BUF_INFO_NV);
impl_extends!(VkImportMemorySciBufInfoNV : VkMemoryAllocateInfo);

/// `VkImportMemoryWin32HandleInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkImportMemoryWin32HandleInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub handleType: VkExternalMemoryHandleTypeFlags,
    pub handle: HANDLE,
    pub name: LPCWSTR,
}
impl_default_zeroed_with_s_type!(VkImportMemoryWin32HandleInfoKHR : VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR);
impl_extends!(VkImportMemoryWin32HandleInfoKHR : VkMemoryAllocateInfo);

/// `VkImportMemoryWin32HandleInfoNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkImportMemoryWin32HandleInfoNV {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub handleType: VkExternalMemoryHandleTypeFlagsNV,
    pub handle: HANDLE,
}
impl_default_zeroed_with_s_type!(VkImportMemoryWin32HandleInfoNV : VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV);
impl_extends!(VkImportMemoryWin32HandleInfoNV : VkMemoryAllocateInfo);

/// `VkImportMemoryZirconHandleInfoFUCHSIA`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkImportMemoryZirconHandleInfoFUCHSIA {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub handleType: VkExternalMemoryHandleTypeFlags,
    pub handle: zx_handle_t,
}
impl_default_zeroed_with_s_type!(VkImportMemoryZirconHandleInfoFUCHSIA : VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA);
impl_extends!(VkImportMemoryZirconHandleInfoFUCHSIA : VkMemoryAllocateInfo);

/// `VkImportMetalBufferInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkImportMetalBufferInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub mtlBuffer: MTLBuffer_id,
}
impl_default_zeroed_with_s_type!(VkImportMetalBufferInfoEXT : VK_STRUCTURE_TYPE_IMPORT_METAL_BUFFER_INFO_EXT);
impl_extends!(VkImportMetalBufferInfoEXT : VkMemoryAllocateInfo);

/// `VkImportMetalIOSurfaceInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkImportMetalIOSurfaceInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub ioSurface: IOSurfaceRef,
}
impl_default_zeroed_with_s_type!(VkImportMetalIOSurfaceInfoEXT : VK_STRUCTURE_TYPE_IMPORT_METAL_IO_SURFACE_INFO_EXT);
impl_extends!(VkImportMetalIOSurfaceInfoEXT : VkImageCreateInfo);

/// `VkImportMetalSharedEventInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkImportMetalSharedEventInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub mtlSharedEvent: MTLSharedEvent_id,
}
impl_default_zeroed_with_s_type!(VkImportMetalSharedEventInfoEXT : VK_STRUCTURE_TYPE_IMPORT_METAL_SHARED_EVENT_INFO_EXT);
impl_extends!(VkImportMetalSharedEventInfoEXT : VkSemaphoreCreateInfo, VkEventCreateInfo);

/// `VkImportMetalTextureInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkImportMetalTextureInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub plane: VkImageAspectFlags,
    pub mtlTexture: MTLTexture_id,
}
impl_default_zeroed_with_s_type!(VkImportMetalTextureInfoEXT : VK_STRUCTURE_TYPE_IMPORT_METAL_TEXTURE_INFO_EXT);
impl_extends!(VkImportMetalTextureInfoEXT : VkImageCreateInfo);

/// `VkImportNativeBufferInfoOHOS`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkImportNativeBufferInfoOHOS {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub buffer: *mut OH_NativeBuffer,
}
impl_default_zeroed_with_s_type!(VkImportNativeBufferInfoOHOS : VK_STRUCTURE_TYPE_IMPORT_NATIVE_BUFFER_INFO_OHOS);
impl_extends!(VkImportNativeBufferInfoOHOS : VkMemoryAllocateInfo);

/// `VkImportScreenBufferInfoQNX`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkImportScreenBufferInfoQNX {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub buffer: *mut _screen_buffer,
}
impl_default_zeroed_with_s_type!(VkImportScreenBufferInfoQNX : VK_STRUCTURE_TYPE_IMPORT_SCREEN_BUFFER_INFO_QNX);
impl_extends!(VkImportScreenBufferInfoQNX : VkMemoryAllocateInfo);

/// `VkImportSemaphoreFdInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkImportSemaphoreFdInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub semaphore: VkSemaphore,
    pub flags: VkSemaphoreImportFlags,
    pub handleType: VkExternalSemaphoreHandleTypeFlags,
    pub fd: int,
}
impl_default_zeroed_with_s_type!(VkImportSemaphoreFdInfoKHR : VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR);

/// `VkImportSemaphoreSciSyncInfoNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkImportSemaphoreSciSyncInfoNV {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub semaphore: VkSemaphore,
    pub handleType: VkExternalSemaphoreHandleTypeFlags,
    pub handle: *mut void,
}
impl_default_zeroed_with_s_type!(VkImportSemaphoreSciSyncInfoNV : VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_SCI_SYNC_INFO_NV);

/// `VkImportSemaphoreWin32HandleInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkImportSemaphoreWin32HandleInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub semaphore: VkSemaphore,
    pub flags: VkSemaphoreImportFlags,
    pub handleType: VkExternalSemaphoreHandleTypeFlags,
    pub handle: HANDLE,
    pub name: LPCWSTR,
}
impl_default_zeroed_with_s_type!(VkImportSemaphoreWin32HandleInfoKHR : VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR);

/// `VkImportSemaphoreZirconHandleInfoFUCHSIA`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkImportSemaphoreZirconHandleInfoFUCHSIA {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub semaphore: VkSemaphore,
    pub flags: VkSemaphoreImportFlags,
    pub handleType: VkExternalSemaphoreHandleTypeFlags,
    pub zirconHandle: zx_handle_t,
}
impl_default_zeroed_with_s_type!(VkImportSemaphoreZirconHandleInfoFUCHSIA : VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA);

from_into_transparent!(VkIndexType: i32);
/// `VkIndexType`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkIndexType(pub i32);

/// `0`  
pub const VK_INDEX_TYPE_UINT16: VkIndexType = VkIndexType(0);
/// `1`  
pub const VK_INDEX_TYPE_UINT32: VkIndexType = VkIndexType(1);
/// `1000265000`  
pub const VK_INDEX_TYPE_UINT8: VkIndexType = VkIndexType(1000265000);
/// `1000165000`  
pub const VK_INDEX_TYPE_NONE_KHR: VkIndexType = VkIndexType(1000165000);
/// `VK_INDEX_TYPE_NONE_KHR`  
pub const VK_INDEX_TYPE_NONE_NV: VkIndexType = VK_INDEX_TYPE_NONE_KHR;
/// `VK_INDEX_TYPE_UINT8`  
pub const VK_INDEX_TYPE_UINT8_EXT: VkIndexType = VK_INDEX_TYPE_UINT8;
/// `VK_INDEX_TYPE_UINT8`  
pub const VK_INDEX_TYPE_UINT8_KHR: VkIndexType = VK_INDEX_TYPE_UINT8;

impl_enum_display!(VkIndexType { VK_INDEX_TYPE_UINT16, VK_INDEX_TYPE_UINT32, VK_INDEX_TYPE_UINT8, VK_INDEX_TYPE_NONE_KHR, VK_INDEX_TYPE_NONE_NV, VK_INDEX_TYPE_UINT8_EXT, VK_INDEX_TYPE_UINT8_KHR });

/// `VkIndirectCommandsExecutionSetTokenEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkIndirectCommandsExecutionSetTokenEXT {
    pub r#type: VkIndirectExecutionSetInfoTypeEXT,
    pub shaderStages: VkShaderStageFlags,
}
impl_default_zeroed!(VkIndirectCommandsExecutionSetTokenEXT);

/// `VkIndirectCommandsIndexBufferTokenEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkIndirectCommandsIndexBufferTokenEXT {
    pub mode: VkIndirectCommandsInputModeFlagsEXT,
}
impl_default_zeroed!(VkIndirectCommandsIndexBufferTokenEXT);

flags!(VkIndirectCommandsInputModeFlagsEXT);
from_into_transparent!(VkIndirectCommandsInputModeFlagsEXT: i32);
/// `VkIndirectCommandsInputModeFlagsEXT`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkIndirectCommandsInputModeFlagsEXT(pub i32);

/// `1 << 0`  
pub const VK_INDIRECT_COMMANDS_INPUT_MODE_VULKAN_INDEX_BUFFER_EXT: VkIndirectCommandsInputModeFlagsEXT = VkIndirectCommandsInputModeFlagsEXT(1 << 0);
/// `1 << 1`  
pub const VK_INDIRECT_COMMANDS_INPUT_MODE_DXGI_INDEX_BUFFER_EXT: VkIndirectCommandsInputModeFlagsEXT = VkIndirectCommandsInputModeFlagsEXT(1 << 1);

impl_flags_display!(VkIndirectCommandsInputModeFlagsEXT { VK_INDIRECT_COMMANDS_INPUT_MODE_VULKAN_INDEX_BUFFER_EXT, VK_INDIRECT_COMMANDS_INPUT_MODE_DXGI_INDEX_BUFFER_EXT });

/// `VkIndirectCommandsLayoutCreateInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkIndirectCommandsLayoutCreateInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub flags: VkIndirectCommandsLayoutUsageFlagsEXT,
    pub shaderStages: VkShaderStageFlags,
    pub indirectStride: uint32_t,
    pub pipelineLayout: VkPipelineLayout,
    pub tokenCount: uint32_t,
    pub pTokens: *const VkIndirectCommandsLayoutTokenEXT,
}
impl_default_zeroed_with_s_type!(VkIndirectCommandsLayoutCreateInfoEXT : VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_EXT);

/// `VkIndirectCommandsLayoutCreateInfoNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkIndirectCommandsLayoutCreateInfoNV {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub flags: VkIndirectCommandsLayoutUsageFlagsNV,
    pub pipelineBindPoint: VkPipelineBindPoint,
    pub tokenCount: uint32_t,
    pub pTokens: *const VkIndirectCommandsLayoutTokenNV,
    pub streamCount: uint32_t,
    pub pStreamStrides: *const uint32_t,
}
impl_default_zeroed_with_s_type!(VkIndirectCommandsLayoutCreateInfoNV : VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NV);

/// `VkIndirectCommandsLayoutEXT` : `VkDevice`
#[repr(transparent)]
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkIndirectCommandsLayoutEXT(pub u64);
from_into_transparent!(VkIndirectCommandsLayoutEXT: u64);
impl_handle!(VkIndirectCommandsLayoutEXT: VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_EXT; SubHandle = VkDevice);

/// `VkIndirectCommandsLayoutNV` : `VkDevice`
#[repr(transparent)]
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkIndirectCommandsLayoutNV(pub u64);
from_into_transparent!(VkIndirectCommandsLayoutNV: u64);
impl_handle!(VkIndirectCommandsLayoutNV: VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NV; SubHandle = VkDevice);

/// `VkIndirectCommandsLayoutPushDataTokenNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkIndirectCommandsLayoutPushDataTokenNV {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub pushDataOffset: uint32_t,
    pub pushDataSize: uint32_t,
}
impl_default_zeroed_with_s_type!(VkIndirectCommandsLayoutPushDataTokenNV : VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_PUSH_DATA_TOKEN_NV);
impl_extends!(VkIndirectCommandsLayoutPushDataTokenNV : VkIndirectCommandsLayoutTokenNV);

/// `VkIndirectCommandsLayoutTokenEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkIndirectCommandsLayoutTokenEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub r#type: VkIndirectCommandsTokenTypeEXT,
    pub data: VkIndirectCommandsTokenDataEXT,
    pub offset: uint32_t,
}
impl_default_zeroed_with_s_type!(VkIndirectCommandsLayoutTokenEXT : VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_EXT);

/// `VkIndirectCommandsLayoutTokenNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkIndirectCommandsLayoutTokenNV {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub tokenType: VkIndirectCommandsTokenTypeNV,
    pub stream: uint32_t,
    pub offset: uint32_t,
    pub vertexBindingUnit: uint32_t,
    pub vertexDynamicStride: VkBool32,
    pub pushconstantPipelineLayout: VkPipelineLayout,
    pub pushconstantShaderStageFlags: VkShaderStageFlags,
    pub pushconstantOffset: uint32_t,
    pub pushconstantSize: uint32_t,
    pub indirectStateFlags: VkIndirectStateFlagsNV,
    pub indexTypeCount: uint32_t,
    pub pIndexTypes: *const VkIndexType,
    pub pIndexTypeValues: *const uint32_t,
}
impl_default_zeroed_with_s_type!(VkIndirectCommandsLayoutTokenNV : VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_NV);

flags!(VkIndirectCommandsLayoutUsageFlagsEXT);
from_into_transparent!(VkIndirectCommandsLayoutUsageFlagsEXT: i32);
/// `VkIndirectCommandsLayoutUsageFlagsEXT`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkIndirectCommandsLayoutUsageFlagsEXT(pub i32);

/// `1 << 0`  
pub const VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EXPLICIT_PREPROCESS_BIT_EXT: VkIndirectCommandsLayoutUsageFlagsEXT = VkIndirectCommandsLayoutUsageFlagsEXT(1 << 0);
/// `1 << 1`  
pub const VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_EXT: VkIndirectCommandsLayoutUsageFlagsEXT = VkIndirectCommandsLayoutUsageFlagsEXT(1 << 1);

impl_flags_display!(VkIndirectCommandsLayoutUsageFlagsEXT { VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EXPLICIT_PREPROCESS_BIT_EXT, VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_EXT });

flags!(VkIndirectCommandsLayoutUsageFlagsNV);
from_into_transparent!(VkIndirectCommandsLayoutUsageFlagsNV: i32);
/// `VkIndirectCommandsLayoutUsageFlagsNV`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkIndirectCommandsLayoutUsageFlagsNV(pub i32);

/// `1 << 0`  
pub const VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EXPLICIT_PREPROCESS_BIT_NV: VkIndirectCommandsLayoutUsageFlagsNV = VkIndirectCommandsLayoutUsageFlagsNV(1 << 0);
/// `1 << 1`  
pub const VK_INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NV: VkIndirectCommandsLayoutUsageFlagsNV = VkIndirectCommandsLayoutUsageFlagsNV(1 << 1);
/// `1 << 2`  
pub const VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NV: VkIndirectCommandsLayoutUsageFlagsNV = VkIndirectCommandsLayoutUsageFlagsNV(1 << 2);

impl_flags_display!(VkIndirectCommandsLayoutUsageFlagsNV { VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EXPLICIT_PREPROCESS_BIT_NV, VK_INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NV, VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NV });

/// `VkIndirectCommandsPushConstantTokenEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkIndirectCommandsPushConstantTokenEXT {
    pub updateRange: VkPushConstantRange,
}
impl_default_zeroed!(VkIndirectCommandsPushConstantTokenEXT);

/// `VkIndirectCommandsStreamNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkIndirectCommandsStreamNV {
    pub buffer: VkBuffer,
    pub offset: VkDeviceSize,
}
impl_default_zeroed!(VkIndirectCommandsStreamNV);

/// `VkIndirectCommandsTokenDataEXT`
#[repr(C)]
#[derive(Clone, Copy)]
pub union VkIndirectCommandsTokenDataEXT {
    pub pPushConstant: *const VkIndirectCommandsPushConstantTokenEXT,
    pub pVertexBuffer: *const VkIndirectCommandsVertexBufferTokenEXT,
    pub pIndexBuffer: *const VkIndirectCommandsIndexBufferTokenEXT,
    pub pExecutionSet: *const VkIndirectCommandsExecutionSetTokenEXT,
}
impl_debug_for_union!(VkIndirectCommandsTokenDataEXT);
impl_default_zeroed!(VkIndirectCommandsTokenDataEXT);

from_into_transparent!(VkIndirectCommandsTokenTypeEXT: i32);
/// `VkIndirectCommandsTokenTypeEXT`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkIndirectCommandsTokenTypeEXT(pub i32);

/// `0`  
pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_EXECUTION_SET_EXT: VkIndirectCommandsTokenTypeEXT = VkIndirectCommandsTokenTypeEXT(0);
/// `1`  
pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_EXT: VkIndirectCommandsTokenTypeEXT = VkIndirectCommandsTokenTypeEXT(1);
/// `2`  
pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_SEQUENCE_INDEX_EXT: VkIndirectCommandsTokenTypeEXT = VkIndirectCommandsTokenTypeEXT(2);
/// `3`  
pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_EXT: VkIndirectCommandsTokenTypeEXT = VkIndirectCommandsTokenTypeEXT(3);
/// `4`  
pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_EXT: VkIndirectCommandsTokenTypeEXT = VkIndirectCommandsTokenTypeEXT(4);
/// `5`  
pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_EXT: VkIndirectCommandsTokenTypeEXT = VkIndirectCommandsTokenTypeEXT(5);
/// `6`  
pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_EXT: VkIndirectCommandsTokenTypeEXT = VkIndirectCommandsTokenTypeEXT(6);
/// `7`  
pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_COUNT_EXT: VkIndirectCommandsTokenTypeEXT = VkIndirectCommandsTokenTypeEXT(7);
/// `8`  
pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_COUNT_EXT: VkIndirectCommandsTokenTypeEXT = VkIndirectCommandsTokenTypeEXT(8);
/// `9`  
pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_EXT: VkIndirectCommandsTokenTypeEXT = VkIndirectCommandsTokenTypeEXT(9);
/// `1000135000`  
pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_DATA_EXT: VkIndirectCommandsTokenTypeEXT = VkIndirectCommandsTokenTypeEXT(1000135000);
/// `1000135001`  
pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_DATA_SEQUENCE_INDEX_EXT: VkIndirectCommandsTokenTypeEXT = VkIndirectCommandsTokenTypeEXT(1000135001);
/// `1000202002`  
pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_NV_EXT: VkIndirectCommandsTokenTypeEXT = VkIndirectCommandsTokenTypeEXT(1000202002);
/// `1000202003`  
pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_COUNT_NV_EXT: VkIndirectCommandsTokenTypeEXT = VkIndirectCommandsTokenTypeEXT(1000202003);
/// `1000328000`  
pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_EXT: VkIndirectCommandsTokenTypeEXT = VkIndirectCommandsTokenTypeEXT(1000328000);
/// `1000328001`  
pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_COUNT_EXT: VkIndirectCommandsTokenTypeEXT = VkIndirectCommandsTokenTypeEXT(1000328001);
/// `1000386004`  
pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_TRACE_RAYS2_EXT: VkIndirectCommandsTokenTypeEXT = VkIndirectCommandsTokenTypeEXT(1000386004);

impl_enum_display!(VkIndirectCommandsTokenTypeEXT { VK_INDIRECT_COMMANDS_TOKEN_TYPE_EXECUTION_SET_EXT, VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_EXT, VK_INDIRECT_COMMANDS_TOKEN_TYPE_SEQUENCE_INDEX_EXT, VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_EXT, VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_EXT, VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_EXT, VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_EXT, VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_COUNT_EXT, VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_COUNT_EXT, VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_EXT, VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_DATA_EXT, VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_DATA_SEQUENCE_INDEX_EXT, VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_NV_EXT, VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_COUNT_NV_EXT, VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_EXT, VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_COUNT_EXT, VK_INDIRECT_COMMANDS_TOKEN_TYPE_TRACE_RAYS2_EXT });

from_into_transparent!(VkIndirectCommandsTokenTypeNV: i32);
/// `VkIndirectCommandsTokenTypeNV`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkIndirectCommandsTokenTypeNV(pub i32);

/// `0`  
pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_SHADER_GROUP_NV: VkIndirectCommandsTokenTypeNV = VkIndirectCommandsTokenTypeNV(0);
/// `1`  
pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_STATE_FLAGS_NV: VkIndirectCommandsTokenTypeNV = VkIndirectCommandsTokenTypeNV(1);
/// `2`  
pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_NV: VkIndirectCommandsTokenTypeNV = VkIndirectCommandsTokenTypeNV(2);
/// `3`  
pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_NV: VkIndirectCommandsTokenTypeNV = VkIndirectCommandsTokenTypeNV(3);
/// `4`  
pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NV: VkIndirectCommandsTokenTypeNV = VkIndirectCommandsTokenTypeNV(4);
/// `5`  
pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NV: VkIndirectCommandsTokenTypeNV = VkIndirectCommandsTokenTypeNV(5);
/// `6`  
pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NV: VkIndirectCommandsTokenTypeNV = VkIndirectCommandsTokenTypeNV(6);
/// `7`  
pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_TASKS_NV: VkIndirectCommandsTokenTypeNV = VkIndirectCommandsTokenTypeNV(7);
/// `1000135000`  
pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_DATA_NV: VkIndirectCommandsTokenTypeNV = VkIndirectCommandsTokenTypeNV(1000135000);
/// `1000328000`  
pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_NV: VkIndirectCommandsTokenTypeNV = VkIndirectCommandsTokenTypeNV(1000328000);
/// `1000428003`  
pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NV: VkIndirectCommandsTokenTypeNV = VkIndirectCommandsTokenTypeNV(1000428003);
/// `1000428004`  
pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NV: VkIndirectCommandsTokenTypeNV = VkIndirectCommandsTokenTypeNV(1000428004);

impl_enum_display!(VkIndirectCommandsTokenTypeNV { VK_INDIRECT_COMMANDS_TOKEN_TYPE_SHADER_GROUP_NV, VK_INDIRECT_COMMANDS_TOKEN_TYPE_STATE_FLAGS_NV, VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_NV, VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_NV, VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NV, VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NV, VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NV, VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_TASKS_NV, VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_DATA_NV, VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_NV, VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NV, VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NV });

/// `VkIndirectCommandsVertexBufferTokenEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkIndirectCommandsVertexBufferTokenEXT {
    pub vertexBindingUnit: uint32_t,
}
impl_default_zeroed!(VkIndirectCommandsVertexBufferTokenEXT);

/// `VkIndirectExecutionSetCreateInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkIndirectExecutionSetCreateInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub r#type: VkIndirectExecutionSetInfoTypeEXT,
    pub info: VkIndirectExecutionSetInfoEXT,
}
impl_default_zeroed_with_s_type!(VkIndirectExecutionSetCreateInfoEXT : VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_CREATE_INFO_EXT);

/// `VkIndirectExecutionSetEXT` : `VkDevice`
#[repr(transparent)]
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkIndirectExecutionSetEXT(pub u64);
from_into_transparent!(VkIndirectExecutionSetEXT: u64);
impl_handle!(VkIndirectExecutionSetEXT: VK_OBJECT_TYPE_INDIRECT_EXECUTION_SET_EXT; SubHandle = VkDevice);

/// `VkIndirectExecutionSetInfoEXT`
#[repr(C)]
#[derive(Clone, Copy)]
pub union VkIndirectExecutionSetInfoEXT {
    pub pPipelineInfo: *const VkIndirectExecutionSetPipelineInfoEXT,
    pub pShaderInfo: *const VkIndirectExecutionSetShaderInfoEXT,
}
impl_debug_for_union!(VkIndirectExecutionSetInfoEXT);
impl_default_zeroed!(VkIndirectExecutionSetInfoEXT);

from_into_transparent!(VkIndirectExecutionSetInfoTypeEXT: i32);
/// `VkIndirectExecutionSetInfoTypeEXT`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkIndirectExecutionSetInfoTypeEXT(pub i32);

/// `0`  
pub const VK_INDIRECT_EXECUTION_SET_INFO_TYPE_PIPELINES_EXT: VkIndirectExecutionSetInfoTypeEXT = VkIndirectExecutionSetInfoTypeEXT(0);
/// `1`  
pub const VK_INDIRECT_EXECUTION_SET_INFO_TYPE_SHADER_OBJECTS_EXT: VkIndirectExecutionSetInfoTypeEXT = VkIndirectExecutionSetInfoTypeEXT(1);

impl_enum_display!(VkIndirectExecutionSetInfoTypeEXT { VK_INDIRECT_EXECUTION_SET_INFO_TYPE_PIPELINES_EXT, VK_INDIRECT_EXECUTION_SET_INFO_TYPE_SHADER_OBJECTS_EXT });

/// `VkIndirectExecutionSetPipelineInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkIndirectExecutionSetPipelineInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub initialPipeline: VkPipeline,
    pub maxPipelineCount: uint32_t,
}
impl_default_zeroed_with_s_type!(VkIndirectExecutionSetPipelineInfoEXT : VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_PIPELINE_INFO_EXT);

/// `VkIndirectExecutionSetShaderInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkIndirectExecutionSetShaderInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub shaderCount: uint32_t,
    pub pInitialShaders: *const VkShaderEXT,
    pub pSetLayoutInfos: *const VkIndirectExecutionSetShaderLayoutInfoEXT,
    pub maxShaderCount: uint32_t,
    pub pushConstantRangeCount: uint32_t,
    pub pPushConstantRanges: *const VkPushConstantRange,
}
impl_default_zeroed_with_s_type!(VkIndirectExecutionSetShaderInfoEXT : VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_INFO_EXT);

/// `VkIndirectExecutionSetShaderLayoutInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkIndirectExecutionSetShaderLayoutInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub setLayoutCount: uint32_t,
    pub pSetLayouts: *const VkDescriptorSetLayout,
}
impl_default_zeroed_with_s_type!(VkIndirectExecutionSetShaderLayoutInfoEXT : VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_LAYOUT_INFO_EXT);

flags!(VkIndirectStateFlagsNV);
from_into_transparent!(VkIndirectStateFlagsNV: i32);
/// `VkIndirectStateFlagsNV`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkIndirectStateFlagsNV(pub i32);

/// `1 << 0`  
pub const VK_INDIRECT_STATE_FLAG_FRONTFACE_BIT_NV: VkIndirectStateFlagsNV = VkIndirectStateFlagsNV(1 << 0);

impl_flags_display!(VkIndirectStateFlagsNV { VK_INDIRECT_STATE_FLAG_FRONTFACE_BIT_NV });

/// `VkInitializePerformanceApiInfoINTEL`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkInitializePerformanceApiInfoINTEL {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub pUserData: *mut void,
}
impl_default_zeroed_with_s_type!(VkInitializePerformanceApiInfoINTEL : VK_STRUCTURE_TYPE_INITIALIZE_PERFORMANCE_API_INFO_INTEL);

/// `VkInputAttachmentAspectReference`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkInputAttachmentAspectReference {
    pub subpass: uint32_t,
    pub inputAttachmentIndex: uint32_t,
    pub aspectMask: VkImageAspectFlags,
}
impl_default_zeroed!(VkInputAttachmentAspectReference);

/// `VkInputAttachmentAspectReference`
pub type VkInputAttachmentAspectReferenceKHR = VkInputAttachmentAspectReference;

/// `VkInstance`
#[repr(transparent)]
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkInstance(pub *mut void);
from_into_transparent!(VkInstance: *mut void);
from_into_transparent!(VkInstance: u64);
impl_handle!(VkInstance: VK_OBJECT_TYPE_INSTANCE; RootHandle);

flags!(VkInstanceCreateFlags);
from_into_transparent!(VkInstanceCreateFlags: i32);
/// `VkInstanceCreateFlags`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkInstanceCreateFlags(pub i32);

/// `1 << 0`  
pub const VK_INSTANCE_CREATE_ENUMERATE_PORTABILITY_BIT_KHR: VkInstanceCreateFlags = VkInstanceCreateFlags(1 << 0);
/// `1 << 1`  
pub const VK_INSTANCE_CREATE_RESERVED_616_BIT_EXT: VkInstanceCreateFlags = VkInstanceCreateFlags(1 << 1);

impl_flags_display!(VkInstanceCreateFlags { VK_INSTANCE_CREATE_ENUMERATE_PORTABILITY_BIT_KHR, VK_INSTANCE_CREATE_RESERVED_616_BIT_EXT });

/// `VkInstanceCreateInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkInstanceCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub flags: VkInstanceCreateFlags,
    pub pApplicationInfo: *const VkApplicationInfo,
    pub enabledLayerCount: uint32_t,
    /// Ordered list of layer names to be enabled
    pub ppEnabledLayerNames: *const *const c_char,
    pub enabledExtensionCount: uint32_t,
    /// Extension names to be enabled
    pub ppEnabledExtensionNames: *const *const c_char,
}
impl_default_zeroed_with_s_type!(VkInstanceCreateInfo : VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO);

from_into_transparent!(VkInternalAllocationType: i32);
/// `VkInternalAllocationType`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkInternalAllocationType(pub i32);

/// `0`  
pub const VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE: VkInternalAllocationType = VkInternalAllocationType(0);

impl_enum_display!(VkInternalAllocationType { VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE });

from_into_transparent!(VkLatencyMarkerNV: i32);
/// `VkLatencyMarkerNV`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkLatencyMarkerNV(pub i32);

/// `0`  
pub const VK_LATENCY_MARKER_SIMULATION_START_NV: VkLatencyMarkerNV = VkLatencyMarkerNV(0);
/// `1`  
pub const VK_LATENCY_MARKER_SIMULATION_END_NV: VkLatencyMarkerNV = VkLatencyMarkerNV(1);
/// `2`  
pub const VK_LATENCY_MARKER_RENDERSUBMIT_START_NV: VkLatencyMarkerNV = VkLatencyMarkerNV(2);
/// `3`  
pub const VK_LATENCY_MARKER_RENDERSUBMIT_END_NV: VkLatencyMarkerNV = VkLatencyMarkerNV(3);
/// `4`  
pub const VK_LATENCY_MARKER_PRESENT_START_NV: VkLatencyMarkerNV = VkLatencyMarkerNV(4);
/// `5`  
pub const VK_LATENCY_MARKER_PRESENT_END_NV: VkLatencyMarkerNV = VkLatencyMarkerNV(5);
/// `6`  
pub const VK_LATENCY_MARKER_INPUT_SAMPLE_NV: VkLatencyMarkerNV = VkLatencyMarkerNV(6);
/// `7`  
pub const VK_LATENCY_MARKER_TRIGGER_FLASH_NV: VkLatencyMarkerNV = VkLatencyMarkerNV(7);
/// `8`  
pub const VK_LATENCY_MARKER_OUT_OF_BAND_RENDERSUBMIT_START_NV: VkLatencyMarkerNV = VkLatencyMarkerNV(8);
/// `9`  
pub const VK_LATENCY_MARKER_OUT_OF_BAND_RENDERSUBMIT_END_NV: VkLatencyMarkerNV = VkLatencyMarkerNV(9);
/// `10`  
pub const VK_LATENCY_MARKER_OUT_OF_BAND_PRESENT_START_NV: VkLatencyMarkerNV = VkLatencyMarkerNV(10);
/// `11`  
pub const VK_LATENCY_MARKER_OUT_OF_BAND_PRESENT_END_NV: VkLatencyMarkerNV = VkLatencyMarkerNV(11);

impl_enum_display!(VkLatencyMarkerNV { VK_LATENCY_MARKER_SIMULATION_START_NV, VK_LATENCY_MARKER_SIMULATION_END_NV, VK_LATENCY_MARKER_RENDERSUBMIT_START_NV, VK_LATENCY_MARKER_RENDERSUBMIT_END_NV, VK_LATENCY_MARKER_PRESENT_START_NV, VK_LATENCY_MARKER_PRESENT_END_NV, VK_LATENCY_MARKER_INPUT_SAMPLE_NV, VK_LATENCY_MARKER_TRIGGER_FLASH_NV, VK_LATENCY_MARKER_OUT_OF_BAND_RENDERSUBMIT_START_NV, VK_LATENCY_MARKER_OUT_OF_BAND_RENDERSUBMIT_END_NV, VK_LATENCY_MARKER_OUT_OF_BAND_PRESENT_START_NV, VK_LATENCY_MARKER_OUT_OF_BAND_PRESENT_END_NV });

/// `VkLatencySleepInfoNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkLatencySleepInfoNV {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub signalSemaphore: VkSemaphore,
    pub value: uint64_t,
}
impl_default_zeroed_with_s_type!(VkLatencySleepInfoNV : VK_STRUCTURE_TYPE_LATENCY_SLEEP_INFO_NV);

/// `VkLatencySleepModeInfoNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkLatencySleepModeInfoNV {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub lowLatencyMode: VkBool32,
    pub lowLatencyBoost: VkBool32,
    pub minimumIntervalUs: uint32_t,
}
impl_default_zeroed_with_s_type!(VkLatencySleepModeInfoNV : VK_STRUCTURE_TYPE_LATENCY_SLEEP_MODE_INFO_NV);

/// `VkLatencySubmissionPresentIdNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkLatencySubmissionPresentIdNV {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub presentID: uint64_t,
}
impl_default_zeroed_with_s_type!(VkLatencySubmissionPresentIdNV : VK_STRUCTURE_TYPE_LATENCY_SUBMISSION_PRESENT_ID_NV);
impl_extends!(VkLatencySubmissionPresentIdNV : VkSubmitInfo, VkSubmitInfo2);

/// `VkLatencySurfaceCapabilitiesNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkLatencySurfaceCapabilitiesNV {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub presentModeCount: uint32_t,
    pub pPresentModes: *mut VkPresentModeKHR,
}
impl_default_zeroed_with_s_type!(VkLatencySurfaceCapabilitiesNV : VK_STRUCTURE_TYPE_LATENCY_SURFACE_CAPABILITIES_NV);
impl_extends!(VkLatencySurfaceCapabilitiesNV : VkSurfaceCapabilities2KHR);

/// `VkLatencyTimingsFrameReportNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkLatencyTimingsFrameReportNV {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub presentID: uint64_t,
    pub inputSampleTimeUs: uint64_t,
    pub simStartTimeUs: uint64_t,
    pub simEndTimeUs: uint64_t,
    pub renderSubmitStartTimeUs: uint64_t,
    pub renderSubmitEndTimeUs: uint64_t,
    pub presentStartTimeUs: uint64_t,
    pub presentEndTimeUs: uint64_t,
    pub driverStartTimeUs: uint64_t,
    pub driverEndTimeUs: uint64_t,
    pub osRenderQueueStartTimeUs: uint64_t,
    pub osRenderQueueEndTimeUs: uint64_t,
    pub gpuRenderStartTimeUs: uint64_t,
    pub gpuRenderEndTimeUs: uint64_t,
}
impl_default_zeroed_with_s_type!(VkLatencyTimingsFrameReportNV : VK_STRUCTURE_TYPE_LATENCY_TIMINGS_FRAME_REPORT_NV);

/// `VkLayerProperties`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkLayerProperties {
    /// layer name
    pub layerName: [c_char; VK_MAX_EXTENSION_NAME_SIZE as usize],
    /// version of the layer specification implemented
    pub specVersion: uint32_t,
    /// build or release version of the layer's library
    pub implementationVersion: uint32_t,
    /// Free-form description of the layer
    pub description: [c_char; VK_MAX_DESCRIPTION_SIZE as usize],
}
impl_default_zeroed!(VkLayerProperties);

/// `VkLayerSettingEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkLayerSettingEXT {
    pub pLayerName: *const c_char,
    pub pSettingName: *const c_char,
    /// The type of the object
    pub r#type: VkLayerSettingTypeEXT,
    /// Number of values of the setting
    pub valueCount: uint32_t,
    /// Values to pass for a setting
    pub pValues: *const void,
}
impl_default_zeroed!(VkLayerSettingEXT);

from_into_transparent!(VkLayerSettingTypeEXT: i32);
/// `VkLayerSettingTypeEXT`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkLayerSettingTypeEXT(pub i32);

/// `0`  
pub const VK_LAYER_SETTING_TYPE_BOOL32_EXT: VkLayerSettingTypeEXT = VkLayerSettingTypeEXT(0);
/// `1`  
pub const VK_LAYER_SETTING_TYPE_INT32_EXT: VkLayerSettingTypeEXT = VkLayerSettingTypeEXT(1);
/// `2`  
pub const VK_LAYER_SETTING_TYPE_INT64_EXT: VkLayerSettingTypeEXT = VkLayerSettingTypeEXT(2);
/// `3`  
pub const VK_LAYER_SETTING_TYPE_UINT32_EXT: VkLayerSettingTypeEXT = VkLayerSettingTypeEXT(3);
/// `4`  
pub const VK_LAYER_SETTING_TYPE_UINT64_EXT: VkLayerSettingTypeEXT = VkLayerSettingTypeEXT(4);
/// `5`  
pub const VK_LAYER_SETTING_TYPE_FLOAT32_EXT: VkLayerSettingTypeEXT = VkLayerSettingTypeEXT(5);
/// `6`  
pub const VK_LAYER_SETTING_TYPE_FLOAT64_EXT: VkLayerSettingTypeEXT = VkLayerSettingTypeEXT(6);
/// `7`  
pub const VK_LAYER_SETTING_TYPE_STRING_EXT: VkLayerSettingTypeEXT = VkLayerSettingTypeEXT(7);

impl_enum_display!(VkLayerSettingTypeEXT { VK_LAYER_SETTING_TYPE_BOOL32_EXT, VK_LAYER_SETTING_TYPE_INT32_EXT, VK_LAYER_SETTING_TYPE_INT64_EXT, VK_LAYER_SETTING_TYPE_UINT32_EXT, VK_LAYER_SETTING_TYPE_UINT64_EXT, VK_LAYER_SETTING_TYPE_FLOAT32_EXT, VK_LAYER_SETTING_TYPE_FLOAT64_EXT, VK_LAYER_SETTING_TYPE_STRING_EXT });

/// `VkLayerSettingsCreateInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkLayerSettingsCreateInfoEXT {
    /// Must be VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT
    pub sType: VkStructureType,
    pub pNext: *const void,
    /// Number of settings to configure
    pub settingCount: uint32_t,
    /// Validation features to enable
    pub pSettings: *const VkLayerSettingEXT,
}
impl_default_zeroed_with_s_type!(VkLayerSettingsCreateInfoEXT : VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT);
impl_extends!(VkLayerSettingsCreateInfoEXT : VkInstanceCreateInfo);

from_into_transparent!(VkLayeredDriverUnderlyingApiMSFT: i32);
/// `VkLayeredDriverUnderlyingApiMSFT`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkLayeredDriverUnderlyingApiMSFT(pub i32);

/// `0`  
pub const VK_LAYERED_DRIVER_UNDERLYING_API_NONE_MSFT: VkLayeredDriverUnderlyingApiMSFT = VkLayeredDriverUnderlyingApiMSFT(0);
/// `1`  
pub const VK_LAYERED_DRIVER_UNDERLYING_API_D3D12_MSFT: VkLayeredDriverUnderlyingApiMSFT = VkLayeredDriverUnderlyingApiMSFT(1);

impl_enum_display!(VkLayeredDriverUnderlyingApiMSFT { VK_LAYERED_DRIVER_UNDERLYING_API_NONE_MSFT, VK_LAYERED_DRIVER_UNDERLYING_API_D3D12_MSFT });

from_into_transparent!(VkLineRasterizationMode: i32);
/// `VkLineRasterizationMode`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkLineRasterizationMode(pub i32);

/// `0`  
pub const VK_LINE_RASTERIZATION_MODE_DEFAULT: VkLineRasterizationMode = VkLineRasterizationMode(0);
/// `1`  
pub const VK_LINE_RASTERIZATION_MODE_RECTANGULAR: VkLineRasterizationMode = VkLineRasterizationMode(1);
/// `2`  
pub const VK_LINE_RASTERIZATION_MODE_BRESENHAM: VkLineRasterizationMode = VkLineRasterizationMode(2);
/// `3`  
pub const VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH: VkLineRasterizationMode = VkLineRasterizationMode(3);
/// `VK_LINE_RASTERIZATION_MODE_DEFAULT`  
pub const VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT: VkLineRasterizationMode = VK_LINE_RASTERIZATION_MODE_DEFAULT;
/// `VK_LINE_RASTERIZATION_MODE_RECTANGULAR`  
pub const VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT: VkLineRasterizationMode = VK_LINE_RASTERIZATION_MODE_RECTANGULAR;
/// `VK_LINE_RASTERIZATION_MODE_BRESENHAM`  
pub const VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT: VkLineRasterizationMode = VK_LINE_RASTERIZATION_MODE_BRESENHAM;
/// `VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH`  
pub const VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT: VkLineRasterizationMode = VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH;
/// `VK_LINE_RASTERIZATION_MODE_DEFAULT`  
pub const VK_LINE_RASTERIZATION_MODE_DEFAULT_KHR: VkLineRasterizationMode = VK_LINE_RASTERIZATION_MODE_DEFAULT;
/// `VK_LINE_RASTERIZATION_MODE_RECTANGULAR`  
pub const VK_LINE_RASTERIZATION_MODE_RECTANGULAR_KHR: VkLineRasterizationMode = VK_LINE_RASTERIZATION_MODE_RECTANGULAR;
/// `VK_LINE_RASTERIZATION_MODE_BRESENHAM`  
pub const VK_LINE_RASTERIZATION_MODE_BRESENHAM_KHR: VkLineRasterizationMode = VK_LINE_RASTERIZATION_MODE_BRESENHAM;
/// `VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH`  
pub const VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_KHR: VkLineRasterizationMode = VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH;

impl_enum_display!(VkLineRasterizationMode { VK_LINE_RASTERIZATION_MODE_DEFAULT, VK_LINE_RASTERIZATION_MODE_RECTANGULAR, VK_LINE_RASTERIZATION_MODE_BRESENHAM, VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH, VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT, VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT, VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT, VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT, VK_LINE_RASTERIZATION_MODE_DEFAULT_KHR, VK_LINE_RASTERIZATION_MODE_RECTANGULAR_KHR, VK_LINE_RASTERIZATION_MODE_BRESENHAM_KHR, VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_KHR });

/// `VkLineRasterizationMode`
pub type VkLineRasterizationModeEXT = VkLineRasterizationMode;

/// `VkLineRasterizationMode`
pub type VkLineRasterizationModeKHR = VkLineRasterizationMode;

from_into_transparent!(VkLogicOp: i32);
/// `VkLogicOp`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkLogicOp(pub i32);

/// `0`  
pub const VK_LOGIC_OP_CLEAR: VkLogicOp = VkLogicOp(0);
/// `1`  
pub const VK_LOGIC_OP_AND: VkLogicOp = VkLogicOp(1);
/// `2`  
pub const VK_LOGIC_OP_AND_REVERSE: VkLogicOp = VkLogicOp(2);
/// `3`  
pub const VK_LOGIC_OP_COPY: VkLogicOp = VkLogicOp(3);
/// `4`  
pub const VK_LOGIC_OP_AND_INVERTED: VkLogicOp = VkLogicOp(4);
/// `5`  
pub const VK_LOGIC_OP_NO_OP: VkLogicOp = VkLogicOp(5);
/// `6`  
pub const VK_LOGIC_OP_XOR: VkLogicOp = VkLogicOp(6);
/// `7`  
pub const VK_LOGIC_OP_OR: VkLogicOp = VkLogicOp(7);
/// `8`  
pub const VK_LOGIC_OP_NOR: VkLogicOp = VkLogicOp(8);
/// `9`  
pub const VK_LOGIC_OP_EQUIVALENT: VkLogicOp = VkLogicOp(9);
/// `10`  
pub const VK_LOGIC_OP_INVERT: VkLogicOp = VkLogicOp(10);
/// `11`  
pub const VK_LOGIC_OP_OR_REVERSE: VkLogicOp = VkLogicOp(11);
/// `12`  
pub const VK_LOGIC_OP_COPY_INVERTED: VkLogicOp = VkLogicOp(12);
/// `13`  
pub const VK_LOGIC_OP_OR_INVERTED: VkLogicOp = VkLogicOp(13);
/// `14`  
pub const VK_LOGIC_OP_NAND: VkLogicOp = VkLogicOp(14);
/// `15`  
pub const VK_LOGIC_OP_SET: VkLogicOp = VkLogicOp(15);

impl_enum_display!(VkLogicOp { VK_LOGIC_OP_CLEAR, VK_LOGIC_OP_AND, VK_LOGIC_OP_AND_REVERSE, VK_LOGIC_OP_COPY, VK_LOGIC_OP_AND_INVERTED, VK_LOGIC_OP_NO_OP, VK_LOGIC_OP_XOR, VK_LOGIC_OP_OR, VK_LOGIC_OP_NOR, VK_LOGIC_OP_EQUIVALENT, VK_LOGIC_OP_INVERT, VK_LOGIC_OP_OR_REVERSE, VK_LOGIC_OP_COPY_INVERTED, VK_LOGIC_OP_OR_INVERTED, VK_LOGIC_OP_NAND, VK_LOGIC_OP_SET });

flags!(VkMacOSSurfaceCreateFlagsMVK);
from_into_transparent!(VkMacOSSurfaceCreateFlagsMVK: i32);
/// `VkMacOSSurfaceCreateFlagsMVK`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkMacOSSurfaceCreateFlagsMVK(pub i32);

impl_flags_display!(VkMacOSSurfaceCreateFlagsMVK {  });

/// `VkMacOSSurfaceCreateInfoMVK`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkMacOSSurfaceCreateInfoMVK {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub flags: VkMacOSSurfaceCreateFlagsMVK,
    pub pView: *const void,
}
impl_default_zeroed_with_s_type!(VkMacOSSurfaceCreateInfoMVK : VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK);

/// `VkMappedMemoryRange`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkMappedMemoryRange {
    pub sType: VkStructureType,
    pub pNext: *const void,
    /// Mapped memory object
    pub memory: VkDeviceMemory,
    /// Offset within the memory object where the range starts
    pub offset: VkDeviceSize,
    /// Size of the range within the memory object
    pub size: VkDeviceSize,
}
impl_default_zeroed_with_s_type!(VkMappedMemoryRange : VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE);

flags!(VkMemoryAllocateFlags);
from_into_transparent!(VkMemoryAllocateFlags: i32);
/// `VkMemoryAllocateFlags`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkMemoryAllocateFlags(pub i32);

/// `1 << 0`  
/// 
/// Force allocation on specific devices
pub const VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT: VkMemoryAllocateFlags = VkMemoryAllocateFlags(1 << 0);
/// `1 << 1`  
pub const VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT: VkMemoryAllocateFlags = VkMemoryAllocateFlags(1 << 1);
/// `1 << 2`  
pub const VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT: VkMemoryAllocateFlags = VkMemoryAllocateFlags(1 << 2);
/// `VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT`  
pub const VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT_KHR: VkMemoryAllocateFlags = VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT;
/// `VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT`  
pub const VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT_KHR: VkMemoryAllocateFlags = VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT;
/// `VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT`  
pub const VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR: VkMemoryAllocateFlags = VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT;
/// `1 << 3`  
pub const VK_MEMORY_ALLOCATE_ZERO_INITIALIZE_BIT_EXT: VkMemoryAllocateFlags = VkMemoryAllocateFlags(1 << 3);

impl_flags_display!(VkMemoryAllocateFlags { VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT, VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT, VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT, VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT_KHR, VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT_KHR, VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR, VK_MEMORY_ALLOCATE_ZERO_INITIALIZE_BIT_EXT });

/// `VkMemoryAllocateFlagsInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkMemoryAllocateFlagsInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub flags: VkMemoryAllocateFlags,
    pub deviceMask: uint32_t,
}
impl_default_zeroed_with_s_type!(VkMemoryAllocateFlagsInfo : VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO);
impl_extends!(VkMemoryAllocateFlagsInfo : VkMemoryAllocateInfo);

/// `VkMemoryAllocateFlagsInfo`
pub type VkMemoryAllocateFlagsInfoKHR = VkMemoryAllocateFlagsInfo;

/// `VkMemoryAllocateFlags`
pub type VkMemoryAllocateFlagsKHR = VkMemoryAllocateFlags;

/// `VkMemoryAllocateInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkMemoryAllocateInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    /// Size of memory allocation
    pub allocationSize: VkDeviceSize,
    /// Index of the of the memory type to allocate from
    pub memoryTypeIndex: uint32_t,
}
impl_default_zeroed_with_s_type!(VkMemoryAllocateInfo : VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO);

/// `VkMemoryBarrier`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkMemoryBarrier {
    pub sType: VkStructureType,
    pub pNext: *const void,
    /// Memory accesses from the source of the dependency to synchronize
    pub srcAccessMask: VkAccessFlags,
    /// Memory accesses from the destination of the dependency to synchronize
    pub dstAccessMask: VkAccessFlags,
}
impl_default_zeroed_with_s_type!(VkMemoryBarrier : VK_STRUCTURE_TYPE_MEMORY_BARRIER);

/// `VkMemoryBarrier2`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkMemoryBarrier2 {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub srcStageMask: VkPipelineStageFlags2,
    pub srcAccessMask: VkAccessFlags2,
    pub dstStageMask: VkPipelineStageFlags2,
    pub dstAccessMask: VkAccessFlags2,
}
impl_default_zeroed_with_s_type!(VkMemoryBarrier2 : VK_STRUCTURE_TYPE_MEMORY_BARRIER_2);
impl_extends!(VkMemoryBarrier2 : VkSubpassDependency2);

/// `VkMemoryBarrier2`
pub type VkMemoryBarrier2KHR = VkMemoryBarrier2;

/// `VkMemoryBarrierAccessFlags3KHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkMemoryBarrierAccessFlags3KHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub srcAccessMask3: VkAccessFlags3KHR,
    pub dstAccessMask3: VkAccessFlags3KHR,
}
impl_default_zeroed_with_s_type!(VkMemoryBarrierAccessFlags3KHR : VK_STRUCTURE_TYPE_MEMORY_BARRIER_ACCESS_FLAGS_3_KHR);
impl_extends!(VkMemoryBarrierAccessFlags3KHR : VkSubpassDependency2, VkBufferMemoryBarrier2, VkImageMemoryBarrier2);

flags!(VkMemoryDecompressionMethodFlagsEXT);
from_into_transparent!(VkMemoryDecompressionMethodFlagsEXT: i64);
/// `VkMemoryDecompressionMethodFlagsEXT`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkMemoryDecompressionMethodFlagsEXT(pub i64);

/// `1 << 0`  
pub const VK_MEMORY_DECOMPRESSION_METHOD_GDEFLATE_1_0_BIT_EXT: VkMemoryDecompressionMethodFlagsEXT = VkMemoryDecompressionMethodFlagsEXT(1 << 0);
/// `VK_MEMORY_DECOMPRESSION_METHOD_GDEFLATE_1_0_BIT_EXT`  
pub const VK_MEMORY_DECOMPRESSION_METHOD_GDEFLATE_1_0_BIT_NV: VkMemoryDecompressionMethodFlagsEXT = VK_MEMORY_DECOMPRESSION_METHOD_GDEFLATE_1_0_BIT_EXT;

impl_flags_display!(VkMemoryDecompressionMethodFlagsEXT { VK_MEMORY_DECOMPRESSION_METHOD_GDEFLATE_1_0_BIT_EXT, VK_MEMORY_DECOMPRESSION_METHOD_GDEFLATE_1_0_BIT_NV });

/// `VkMemoryDecompressionMethodFlagsEXT`
pub type VkMemoryDecompressionMethodFlagsNV = VkMemoryDecompressionMethodFlagsEXT;

/// `VkMemoryDedicatedAllocateInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkMemoryDedicatedAllocateInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    /// Image that this allocation will be bound to
    pub image: VkImage,
    /// Buffer that this allocation will be bound to
    pub buffer: VkBuffer,
}
impl_default_zeroed_with_s_type!(VkMemoryDedicatedAllocateInfo : VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO);
impl_extends!(VkMemoryDedicatedAllocateInfo : VkMemoryAllocateInfo);

/// `VkMemoryDedicatedAllocateInfo`
pub type VkMemoryDedicatedAllocateInfoKHR = VkMemoryDedicatedAllocateInfo;

/// `VkMemoryDedicatedAllocateInfoTensorARM`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkMemoryDedicatedAllocateInfoTensorARM {
    pub sType: VkStructureType,
    pub pNext: *const void,
    /// Tensor that this allocation will be bound to
    pub tensor: VkTensorARM,
}
impl_default_zeroed_with_s_type!(VkMemoryDedicatedAllocateInfoTensorARM : VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_TENSOR_ARM);
impl_extends!(VkMemoryDedicatedAllocateInfoTensorARM : VkMemoryAllocateInfo);

/// `VkMemoryDedicatedRequirements`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkMemoryDedicatedRequirements {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub prefersDedicatedAllocation: VkBool32,
    pub requiresDedicatedAllocation: VkBool32,
}
impl_default_zeroed_with_s_type!(VkMemoryDedicatedRequirements : VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS);
impl_extends!(VkMemoryDedicatedRequirements : VkMemoryRequirements2);

/// `VkMemoryDedicatedRequirements`
pub type VkMemoryDedicatedRequirementsKHR = VkMemoryDedicatedRequirements;

/// `VkMemoryFdPropertiesKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkMemoryFdPropertiesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub memoryTypeBits: uint32_t,
}
impl_default_zeroed_with_s_type!(VkMemoryFdPropertiesKHR : VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR);

/// `VkMemoryGetAndroidHardwareBufferInfoANDROID`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkMemoryGetAndroidHardwareBufferInfoANDROID {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub memory: VkDeviceMemory,
}
impl_default_zeroed_with_s_type!(VkMemoryGetAndroidHardwareBufferInfoANDROID : VK_STRUCTURE_TYPE_MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID);

/// `VkMemoryGetFdInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkMemoryGetFdInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub memory: VkDeviceMemory,
    pub handleType: VkExternalMemoryHandleTypeFlags,
}
impl_default_zeroed_with_s_type!(VkMemoryGetFdInfoKHR : VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR);

/// `VkMemoryGetMetalHandleInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkMemoryGetMetalHandleInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub memory: VkDeviceMemory,
    pub handleType: VkExternalMemoryHandleTypeFlags,
}
impl_default_zeroed_with_s_type!(VkMemoryGetMetalHandleInfoEXT : VK_STRUCTURE_TYPE_MEMORY_GET_METAL_HANDLE_INFO_EXT);

/// `VkMemoryGetNativeBufferInfoOHOS`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkMemoryGetNativeBufferInfoOHOS {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub memory: VkDeviceMemory,
}
impl_default_zeroed_with_s_type!(VkMemoryGetNativeBufferInfoOHOS : VK_STRUCTURE_TYPE_MEMORY_GET_NATIVE_BUFFER_INFO_OHOS);

/// `VkMemoryGetRemoteAddressInfoNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkMemoryGetRemoteAddressInfoNV {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub memory: VkDeviceMemory,
    pub handleType: VkExternalMemoryHandleTypeFlags,
}
impl_default_zeroed_with_s_type!(VkMemoryGetRemoteAddressInfoNV : VK_STRUCTURE_TYPE_MEMORY_GET_REMOTE_ADDRESS_INFO_NV);

/// `VkMemoryGetSciBufInfoNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkMemoryGetSciBufInfoNV {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub memory: VkDeviceMemory,
    pub handleType: VkExternalMemoryHandleTypeFlags,
}
impl_default_zeroed_with_s_type!(VkMemoryGetSciBufInfoNV : VK_STRUCTURE_TYPE_MEMORY_GET_SCI_BUF_INFO_NV);

/// `VkMemoryGetWin32HandleInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkMemoryGetWin32HandleInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub memory: VkDeviceMemory,
    pub handleType: VkExternalMemoryHandleTypeFlags,
}
impl_default_zeroed_with_s_type!(VkMemoryGetWin32HandleInfoKHR : VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR);

/// `VkMemoryGetZirconHandleInfoFUCHSIA`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkMemoryGetZirconHandleInfoFUCHSIA {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub memory: VkDeviceMemory,
    pub handleType: VkExternalMemoryHandleTypeFlags,
}
impl_default_zeroed_with_s_type!(VkMemoryGetZirconHandleInfoFUCHSIA : VK_STRUCTURE_TYPE_MEMORY_GET_ZIRCON_HANDLE_INFO_FUCHSIA);

/// `VkMemoryHeap`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkMemoryHeap {
    /// Available memory in the heap
    pub size: VkDeviceSize,
    /// Flags for the heap
    pub flags: VkMemoryHeapFlags,
}
impl_default_zeroed!(VkMemoryHeap);

flags!(VkMemoryHeapFlags);
from_into_transparent!(VkMemoryHeapFlags: i32);
/// `VkMemoryHeapFlags`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkMemoryHeapFlags(pub i32);

/// `1 << 0`  
/// 
/// If set, heap represents device memory
pub const VK_MEMORY_HEAP_DEVICE_LOCAL_BIT: VkMemoryHeapFlags = VkMemoryHeapFlags(1 << 0);
/// `1 << 1`  
/// 
/// If set, heap allocations allocate multiple instances by default
pub const VK_MEMORY_HEAP_MULTI_INSTANCE_BIT: VkMemoryHeapFlags = VkMemoryHeapFlags(1 << 1);
/// `1 << 2`  
pub const VK_MEMORY_HEAP_SEU_SAFE_BIT: VkMemoryHeapFlags = VkMemoryHeapFlags(1 << 2);
/// `VK_MEMORY_HEAP_MULTI_INSTANCE_BIT`  
pub const VK_MEMORY_HEAP_MULTI_INSTANCE_BIT_KHR: VkMemoryHeapFlags = VK_MEMORY_HEAP_MULTI_INSTANCE_BIT;
/// `1 << 3`  
pub const VK_MEMORY_HEAP_TILE_MEMORY_BIT_QCOM: VkMemoryHeapFlags = VkMemoryHeapFlags(1 << 3);

impl_flags_display!(VkMemoryHeapFlags { VK_MEMORY_HEAP_DEVICE_LOCAL_BIT, VK_MEMORY_HEAP_MULTI_INSTANCE_BIT, VK_MEMORY_HEAP_SEU_SAFE_BIT, VK_MEMORY_HEAP_MULTI_INSTANCE_BIT_KHR, VK_MEMORY_HEAP_TILE_MEMORY_BIT_QCOM });

/// `VkMemoryHostPointerPropertiesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkMemoryHostPointerPropertiesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub memoryTypeBits: uint32_t,
}
impl_default_zeroed_with_s_type!(VkMemoryHostPointerPropertiesEXT : VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT);

flags!(VkMemoryMapFlags);
from_into_transparent!(VkMemoryMapFlags: i32);
/// `VkMemoryMapFlags`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkMemoryMapFlags(pub i32);

/// `1 << 0`  
pub const VK_MEMORY_MAP_PLACED_BIT_EXT: VkMemoryMapFlags = VkMemoryMapFlags(1 << 0);

impl_flags_display!(VkMemoryMapFlags { VK_MEMORY_MAP_PLACED_BIT_EXT });

/// `VkMemoryMapInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkMemoryMapInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub flags: VkMemoryMapFlags,
    pub memory: VkDeviceMemory,
    pub offset: VkDeviceSize,
    pub size: VkDeviceSize,
}
impl_default_zeroed_with_s_type!(VkMemoryMapInfo : VK_STRUCTURE_TYPE_MEMORY_MAP_INFO);

/// `VkMemoryMapInfo`
pub type VkMemoryMapInfoKHR = VkMemoryMapInfo;

/// `VkMemoryMapPlacedInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkMemoryMapPlacedInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub pPlacedAddress: *mut void,
}
impl_default_zeroed_with_s_type!(VkMemoryMapPlacedInfoEXT : VK_STRUCTURE_TYPE_MEMORY_MAP_PLACED_INFO_EXT);
impl_extends!(VkMemoryMapPlacedInfoEXT : VkMemoryMapInfo);

/// `VkMemoryMetalHandlePropertiesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkMemoryMetalHandlePropertiesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub memoryTypeBits: uint32_t,
}
impl_default_zeroed_with_s_type!(VkMemoryMetalHandlePropertiesEXT : VK_STRUCTURE_TYPE_MEMORY_METAL_HANDLE_PROPERTIES_EXT);

/// `VkMemoryOpaqueCaptureAddressAllocateInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkMemoryOpaqueCaptureAddressAllocateInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub opaqueCaptureAddress: uint64_t,
}
impl_default_zeroed_with_s_type!(VkMemoryOpaqueCaptureAddressAllocateInfo : VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO);
impl_extends!(VkMemoryOpaqueCaptureAddressAllocateInfo : VkMemoryAllocateInfo);

/// `VkMemoryOpaqueCaptureAddressAllocateInfo`
pub type VkMemoryOpaqueCaptureAddressAllocateInfoKHR = VkMemoryOpaqueCaptureAddressAllocateInfo;

from_into_transparent!(VkMemoryOverallocationBehaviorAMD: i32);
/// `VkMemoryOverallocationBehaviorAMD`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkMemoryOverallocationBehaviorAMD(pub i32);

/// `0`  
pub const VK_MEMORY_OVERALLOCATION_BEHAVIOR_DEFAULT_AMD: VkMemoryOverallocationBehaviorAMD = VkMemoryOverallocationBehaviorAMD(0);
/// `1`  
pub const VK_MEMORY_OVERALLOCATION_BEHAVIOR_ALLOWED_AMD: VkMemoryOverallocationBehaviorAMD = VkMemoryOverallocationBehaviorAMD(1);
/// `2`  
pub const VK_MEMORY_OVERALLOCATION_BEHAVIOR_DISALLOWED_AMD: VkMemoryOverallocationBehaviorAMD = VkMemoryOverallocationBehaviorAMD(2);

impl_enum_display!(VkMemoryOverallocationBehaviorAMD { VK_MEMORY_OVERALLOCATION_BEHAVIOR_DEFAULT_AMD, VK_MEMORY_OVERALLOCATION_BEHAVIOR_ALLOWED_AMD, VK_MEMORY_OVERALLOCATION_BEHAVIOR_DISALLOWED_AMD });

/// `VkMemoryPriorityAllocateInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkMemoryPriorityAllocateInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub priority: float,
}
impl_default_zeroed_with_s_type!(VkMemoryPriorityAllocateInfoEXT : VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT);
impl_extends!(VkMemoryPriorityAllocateInfoEXT : VkMemoryAllocateInfo);

flags!(VkMemoryPropertyFlags);
from_into_transparent!(VkMemoryPropertyFlags: i32);
/// `VkMemoryPropertyFlags`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkMemoryPropertyFlags(pub i32);

/// `1 << 0`  
/// 
/// If otherwise stated, then allocate memory on device
pub const VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT: VkMemoryPropertyFlags = VkMemoryPropertyFlags(1 << 0);
/// `1 << 1`  
/// 
/// Memory is mappable by host
pub const VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT: VkMemoryPropertyFlags = VkMemoryPropertyFlags(1 << 1);
/// `1 << 2`  
/// 
/// Memory will have i/o coherency. If not set, application may need to use vkFlushMappedMemoryRanges and vkInvalidateMappedMemoryRanges to flush/invalidate host cache
pub const VK_MEMORY_PROPERTY_HOST_COHERENT_BIT: VkMemoryPropertyFlags = VkMemoryPropertyFlags(1 << 2);
/// `1 << 3`  
/// 
/// Memory will be cached by the host
pub const VK_MEMORY_PROPERTY_HOST_CACHED_BIT: VkMemoryPropertyFlags = VkMemoryPropertyFlags(1 << 3);
/// `1 << 4`  
/// 
/// Memory may be allocated by the driver when it is required
pub const VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT: VkMemoryPropertyFlags = VkMemoryPropertyFlags(1 << 4);
/// `1 << 5`  
/// 
/// Memory is protected
pub const VK_MEMORY_PROPERTY_PROTECTED_BIT: VkMemoryPropertyFlags = VkMemoryPropertyFlags(1 << 5);
/// `1 << 6`  
pub const VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD: VkMemoryPropertyFlags = VkMemoryPropertyFlags(1 << 6);
/// `1 << 7`  
pub const VK_MEMORY_PROPERTY_DEVICE_UNCACHED_BIT_AMD: VkMemoryPropertyFlags = VkMemoryPropertyFlags(1 << 7);
/// `1 << 8`  
pub const VK_MEMORY_PROPERTY_RDMA_CAPABLE_BIT_NV: VkMemoryPropertyFlags = VkMemoryPropertyFlags(1 << 8);

impl_flags_display!(VkMemoryPropertyFlags { VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT, VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, VK_MEMORY_PROPERTY_HOST_CACHED_BIT, VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT, VK_MEMORY_PROPERTY_PROTECTED_BIT, VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD, VK_MEMORY_PROPERTY_DEVICE_UNCACHED_BIT_AMD, VK_MEMORY_PROPERTY_RDMA_CAPABLE_BIT_NV });

/// `VkMemoryRequirements`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkMemoryRequirements {
    /// Specified in bytes
    pub size: VkDeviceSize,
    /// Specified in bytes
    pub alignment: VkDeviceSize,
    /// Bitmask of the allowed memory type indices into memoryTypes[] for this object
    pub memoryTypeBits: uint32_t,
}
impl_default_zeroed!(VkMemoryRequirements);

/// `VkMemoryRequirements2`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkMemoryRequirements2 {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub memoryRequirements: VkMemoryRequirements,
}
impl_default_zeroed_with_s_type!(VkMemoryRequirements2 : VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2);

/// `VkMemoryRequirements2`
pub type VkMemoryRequirements2KHR = VkMemoryRequirements2;

/// `VkMemorySciBufPropertiesNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkMemorySciBufPropertiesNV {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub memoryTypeBits: uint32_t,
}
impl_default_zeroed_with_s_type!(VkMemorySciBufPropertiesNV : VK_STRUCTURE_TYPE_MEMORY_SCI_BUF_PROPERTIES_NV);

/// `VkMemoryToImageCopy`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkMemoryToImageCopy {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub pHostPointer: *const void,
    /// Specified in texels
    pub memoryRowLength: uint32_t,
    pub memoryImageHeight: uint32_t,
    pub imageSubresource: VkImageSubresourceLayers,
    pub imageOffset: VkOffset3D,
    pub imageExtent: VkExtent3D,
}
impl_default_zeroed_with_s_type!(VkMemoryToImageCopy : VK_STRUCTURE_TYPE_MEMORY_TO_IMAGE_COPY);

/// `VkMemoryToImageCopy`
pub type VkMemoryToImageCopyEXT = VkMemoryToImageCopy;

/// `VkMemoryType`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkMemoryType {
    /// Memory properties of this memory type
    pub propertyFlags: VkMemoryPropertyFlags,
    /// Index of the memory heap allocations of this memory type are taken from
    pub heapIndex: uint32_t,
}
impl_default_zeroed!(VkMemoryType);

flags!(VkMemoryUnmapFlags);
from_into_transparent!(VkMemoryUnmapFlags: i32);
/// `VkMemoryUnmapFlags`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkMemoryUnmapFlags(pub i32);

/// `1 << 0`  
pub const VK_MEMORY_UNMAP_RESERVE_BIT_EXT: VkMemoryUnmapFlags = VkMemoryUnmapFlags(1 << 0);

impl_flags_display!(VkMemoryUnmapFlags { VK_MEMORY_UNMAP_RESERVE_BIT_EXT });

/// `VkMemoryUnmapFlags`
pub type VkMemoryUnmapFlagsKHR = VkMemoryUnmapFlags;

/// `VkMemoryUnmapInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkMemoryUnmapInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub flags: VkMemoryUnmapFlags,
    pub memory: VkDeviceMemory,
}
impl_default_zeroed_with_s_type!(VkMemoryUnmapInfo : VK_STRUCTURE_TYPE_MEMORY_UNMAP_INFO);

/// `VkMemoryUnmapInfo`
pub type VkMemoryUnmapInfoKHR = VkMemoryUnmapInfo;

/// `VkMemoryWin32HandlePropertiesKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkMemoryWin32HandlePropertiesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub memoryTypeBits: uint32_t,
}
impl_default_zeroed_with_s_type!(VkMemoryWin32HandlePropertiesKHR : VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR);

/// `VkMemoryZirconHandlePropertiesFUCHSIA`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkMemoryZirconHandlePropertiesFUCHSIA {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub memoryTypeBits: uint32_t,
}
impl_default_zeroed_with_s_type!(VkMemoryZirconHandlePropertiesFUCHSIA : VK_STRUCTURE_TYPE_MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA);

flags!(VkMetalSurfaceCreateFlagsEXT);
from_into_transparent!(VkMetalSurfaceCreateFlagsEXT: i32);
/// `VkMetalSurfaceCreateFlagsEXT`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkMetalSurfaceCreateFlagsEXT(pub i32);

impl_flags_display!(VkMetalSurfaceCreateFlagsEXT {  });

/// `VkMetalSurfaceCreateInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkMetalSurfaceCreateInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub flags: VkMetalSurfaceCreateFlagsEXT,
    pub pLayer: *const CAMetalLayer,
}
impl_default_zeroed_with_s_type!(VkMetalSurfaceCreateInfoEXT : VK_STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT);

/// `VkMicromapBuildInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkMicromapBuildInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub r#type: VkMicromapTypeEXT,
    pub flags: VkBuildMicromapFlagsEXT,
    pub mode: VkBuildMicromapModeEXT,
    pub dstMicromap: VkMicromapEXT,
    pub usageCountsCount: uint32_t,
    pub pUsageCounts: *const VkMicromapUsageEXT,
    pub ppUsageCounts: *const *const VkMicromapUsageEXT,
    pub data: VkDeviceOrHostAddressConstKHR,
    pub scratchData: VkDeviceOrHostAddressKHR,
    pub triangleArray: VkDeviceOrHostAddressConstKHR,
    pub triangleArrayStride: VkDeviceSize,
}
impl_default_zeroed_with_s_type!(VkMicromapBuildInfoEXT : VK_STRUCTURE_TYPE_MICROMAP_BUILD_INFO_EXT);

/// `VkMicromapBuildSizesInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkMicromapBuildSizesInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub micromapSize: VkDeviceSize,
    pub buildScratchSize: VkDeviceSize,
    pub discardable: VkBool32,
}
impl_default_zeroed_with_s_type!(VkMicromapBuildSizesInfoEXT : VK_STRUCTURE_TYPE_MICROMAP_BUILD_SIZES_INFO_EXT);

flags!(VkMicromapCreateFlagsEXT);
from_into_transparent!(VkMicromapCreateFlagsEXT: i32);
/// `VkMicromapCreateFlagsEXT`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkMicromapCreateFlagsEXT(pub i32);

/// `1 << 0`  
pub const VK_MICROMAP_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_EXT: VkMicromapCreateFlagsEXT = VkMicromapCreateFlagsEXT(1 << 0);

impl_flags_display!(VkMicromapCreateFlagsEXT { VK_MICROMAP_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_EXT });

/// `VkMicromapCreateInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkMicromapCreateInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub createFlags: VkMicromapCreateFlagsEXT,
    pub buffer: VkBuffer,
    /// Specified in bytes
    pub offset: VkDeviceSize,
    pub size: VkDeviceSize,
    pub r#type: VkMicromapTypeEXT,
    pub deviceAddress: VkDeviceAddress,
}
impl_default_zeroed_with_s_type!(VkMicromapCreateInfoEXT : VK_STRUCTURE_TYPE_MICROMAP_CREATE_INFO_EXT);

/// `VkMicromapEXT` : `VkDevice`
#[repr(transparent)]
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkMicromapEXT(pub u64);
from_into_transparent!(VkMicromapEXT: u64);
impl_handle!(VkMicromapEXT: VK_OBJECT_TYPE_MICROMAP_EXT; SubHandle = VkDevice);

/// `VkMicromapTriangleEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkMicromapTriangleEXT {
    /// Specified in bytes
    pub dataOffset: uint32_t,
    pub subdivisionLevel: uint16_t,
    pub format: uint16_t,
}
impl_default_zeroed!(VkMicromapTriangleEXT);

from_into_transparent!(VkMicromapTypeEXT: i32);
/// `VkMicromapTypeEXT`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkMicromapTypeEXT(pub i32);

/// `0`  
pub const VK_MICROMAP_TYPE_OPACITY_MICROMAP_EXT: VkMicromapTypeEXT = VkMicromapTypeEXT(0);
/// `1000397000`  
pub const VK_MICROMAP_TYPE_DISPLACEMENT_MICROMAP_NV: VkMicromapTypeEXT = VkMicromapTypeEXT(1000397000);

impl_enum_display!(VkMicromapTypeEXT { VK_MICROMAP_TYPE_OPACITY_MICROMAP_EXT, VK_MICROMAP_TYPE_DISPLACEMENT_MICROMAP_NV });

/// `VkMicromapUsageEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkMicromapUsageEXT {
    pub count: uint32_t,
    pub subdivisionLevel: uint32_t,
    /// Interpretation depends on parent type
    pub format: uint32_t,
}
impl_default_zeroed!(VkMicromapUsageEXT);

/// `VkMicromapVersionInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkMicromapVersionInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub pVersionData: *const uint8_t,
}
impl_default_zeroed_with_s_type!(VkMicromapVersionInfoEXT : VK_STRUCTURE_TYPE_MICROMAP_VERSION_INFO_EXT);

/// `VkMultiDrawIndexedInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkMultiDrawIndexedInfoEXT {
    pub firstIndex: uint32_t,
    pub indexCount: uint32_t,
    pub vertexOffset: int32_t,
}
impl_default_zeroed!(VkMultiDrawIndexedInfoEXT);

/// `VkMultiDrawInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkMultiDrawInfoEXT {
    pub firstVertex: uint32_t,
    pub vertexCount: uint32_t,
}
impl_default_zeroed!(VkMultiDrawInfoEXT);

/// `VkMultisamplePropertiesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkMultisamplePropertiesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub maxSampleLocationGridSize: VkExtent2D,
}
impl_default_zeroed_with_s_type!(VkMultisamplePropertiesEXT : VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT);

/// `VkMultisampledRenderToSingleSampledInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkMultisampledRenderToSingleSampledInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub multisampledRenderToSingleSampledEnable: VkBool32,
    pub rasterizationSamples: VkSampleCountFlags,
}
impl_default_zeroed_with_s_type!(VkMultisampledRenderToSingleSampledInfoEXT : VK_STRUCTURE_TYPE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT);
impl_extends!(VkMultisampledRenderToSingleSampledInfoEXT : VkSubpassDescription2, VkRenderingInfo);

/// `VkMultiviewPerViewAttributesInfoNVX`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkMultiviewPerViewAttributesInfoNVX {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub perViewAttributes: VkBool32,
    pub perViewAttributesPositionXOnly: VkBool32,
}
impl_default_zeroed_with_s_type!(VkMultiviewPerViewAttributesInfoNVX : VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX);
impl_extends!(VkMultiviewPerViewAttributesInfoNVX : VkCommandBufferInheritanceInfo, VkGraphicsPipelineCreateInfo, VkRenderingInfo);

/// `VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub perViewRenderAreaCount: uint32_t,
    pub pPerViewRenderAreas: *const VkRect2D,
}
impl_default_zeroed_with_s_type!(VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM : VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM);
impl_extends!(VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM : VkRenderPassBeginInfo, VkRenderingInfo);

/// `VkMutableDescriptorTypeCreateInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkMutableDescriptorTypeCreateInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub mutableDescriptorTypeListCount: uint32_t,
    pub pMutableDescriptorTypeLists: *const VkMutableDescriptorTypeListEXT,
}
impl_default_zeroed_with_s_type!(VkMutableDescriptorTypeCreateInfoEXT : VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT);
impl_extends!(VkMutableDescriptorTypeCreateInfoEXT : VkDescriptorSetLayoutCreateInfo, VkDescriptorPoolCreateInfo);

/// `VkMutableDescriptorTypeCreateInfoEXT`
pub type VkMutableDescriptorTypeCreateInfoVALVE = VkMutableDescriptorTypeCreateInfoEXT;

/// `VkMutableDescriptorTypeListEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkMutableDescriptorTypeListEXT {
    pub descriptorTypeCount: uint32_t,
    pub pDescriptorTypes: *const VkDescriptorType,
}
impl_default_zeroed!(VkMutableDescriptorTypeListEXT);

/// `VkMutableDescriptorTypeListEXT`
pub type VkMutableDescriptorTypeListVALVE = VkMutableDescriptorTypeListEXT;

/// `VkNativeBufferANDROID`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkNativeBufferANDROID {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub handle: *const void,
    pub stride: int,
    pub format: int,
    pub usage: int,
    pub usage2: VkNativeBufferUsage2ANDROID,
}
impl_default_zeroed_with_s_type!(VkNativeBufferANDROID : VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID);
impl_extends!(VkNativeBufferANDROID : VkImageCreateInfo, VkBindImageMemoryInfo);

/// `VkNativeBufferFormatPropertiesOHOS`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkNativeBufferFormatPropertiesOHOS {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub format: VkFormat,
    pub externalFormat: uint64_t,
    pub formatFeatures: VkFormatFeatureFlags,
    pub samplerYcbcrConversionComponents: VkComponentMapping,
    pub suggestedYcbcrModel: VkSamplerYcbcrModelConversion,
    pub suggestedYcbcrRange: VkSamplerYcbcrRange,
    pub suggestedXChromaOffset: VkChromaLocation,
    pub suggestedYChromaOffset: VkChromaLocation,
}
impl_default_zeroed_with_s_type!(VkNativeBufferFormatPropertiesOHOS : VK_STRUCTURE_TYPE_NATIVE_BUFFER_FORMAT_PROPERTIES_OHOS);
impl_extends!(VkNativeBufferFormatPropertiesOHOS : VkNativeBufferPropertiesOHOS);

/// `VkNativeBufferOHOS`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkNativeBufferOHOS {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub handle: *mut OHBufferHandle,
}
impl_default_zeroed_with_s_type!(VkNativeBufferOHOS : VK_STRUCTURE_TYPE_NATIVE_BUFFER_OHOS);
impl_extends!(VkNativeBufferOHOS : VkImageCreateInfo, VkBindImageMemoryInfo);

/// `VkNativeBufferPropertiesOHOS`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkNativeBufferPropertiesOHOS {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub allocationSize: VkDeviceSize,
    pub memoryTypeBits: uint32_t,
}
impl_default_zeroed_with_s_type!(VkNativeBufferPropertiesOHOS : VK_STRUCTURE_TYPE_NATIVE_BUFFER_PROPERTIES_OHOS);

/// `VkNativeBufferUsage2ANDROID`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkNativeBufferUsage2ANDROID {
    pub consumer: uint64_t,
    pub producer: uint64_t,
}
impl_default_zeroed!(VkNativeBufferUsage2ANDROID);

/// `VkNativeBufferUsageOHOS`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkNativeBufferUsageOHOS {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub OHOSNativeBufferUsage: uint64_t,
}
impl_default_zeroed_with_s_type!(VkNativeBufferUsageOHOS : VK_STRUCTURE_TYPE_NATIVE_BUFFER_USAGE_OHOS);
impl_extends!(VkNativeBufferUsageOHOS : VkImageFormatProperties2);

from_into_transparent!(VkObjectType: i32);
/// `VkObjectType`
/// 
/// Enums to track objects of various types - also see objtypeenum attributes on type tags
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkObjectType(pub i32);

/// `0`  
pub const VK_OBJECT_TYPE_UNKNOWN: VkObjectType = VkObjectType(0);
/// `1`  
pub const VK_OBJECT_TYPE_INSTANCE: VkObjectType = VkObjectType(1);
/// `2`  
pub const VK_OBJECT_TYPE_PHYSICAL_DEVICE: VkObjectType = VkObjectType(2);
/// `3`  
pub const VK_OBJECT_TYPE_DEVICE: VkObjectType = VkObjectType(3);
/// `4`  
pub const VK_OBJECT_TYPE_QUEUE: VkObjectType = VkObjectType(4);
/// `5`  
pub const VK_OBJECT_TYPE_SEMAPHORE: VkObjectType = VkObjectType(5);
/// `6`  
pub const VK_OBJECT_TYPE_COMMAND_BUFFER: VkObjectType = VkObjectType(6);
/// `7`  
pub const VK_OBJECT_TYPE_FENCE: VkObjectType = VkObjectType(7);
/// `8`  
pub const VK_OBJECT_TYPE_DEVICE_MEMORY: VkObjectType = VkObjectType(8);
/// `9`  
pub const VK_OBJECT_TYPE_BUFFER: VkObjectType = VkObjectType(9);
/// `10`  
pub const VK_OBJECT_TYPE_IMAGE: VkObjectType = VkObjectType(10);
/// `11`  
pub const VK_OBJECT_TYPE_EVENT: VkObjectType = VkObjectType(11);
/// `12`  
pub const VK_OBJECT_TYPE_QUERY_POOL: VkObjectType = VkObjectType(12);
/// `13`  
pub const VK_OBJECT_TYPE_BUFFER_VIEW: VkObjectType = VkObjectType(13);
/// `14`  
pub const VK_OBJECT_TYPE_IMAGE_VIEW: VkObjectType = VkObjectType(14);
/// `15`  
pub const VK_OBJECT_TYPE_SHADER_MODULE: VkObjectType = VkObjectType(15);
/// `16`  
pub const VK_OBJECT_TYPE_PIPELINE_CACHE: VkObjectType = VkObjectType(16);
/// `17`  
pub const VK_OBJECT_TYPE_PIPELINE_LAYOUT: VkObjectType = VkObjectType(17);
/// `18`  
pub const VK_OBJECT_TYPE_RENDER_PASS: VkObjectType = VkObjectType(18);
/// `19`  
pub const VK_OBJECT_TYPE_PIPELINE: VkObjectType = VkObjectType(19);
/// `20`  
pub const VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT: VkObjectType = VkObjectType(20);
/// `21`  
pub const VK_OBJECT_TYPE_SAMPLER: VkObjectType = VkObjectType(21);
/// `22`  
pub const VK_OBJECT_TYPE_DESCRIPTOR_POOL: VkObjectType = VkObjectType(22);
/// `23`  
pub const VK_OBJECT_TYPE_DESCRIPTOR_SET: VkObjectType = VkObjectType(23);
/// `24`  
pub const VK_OBJECT_TYPE_FRAMEBUFFER: VkObjectType = VkObjectType(24);
/// `25`  
pub const VK_OBJECT_TYPE_COMMAND_POOL: VkObjectType = VkObjectType(25);
/// `1000085000`  
pub const VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE: VkObjectType = VkObjectType(1000085000);
/// `1000156000`  
pub const VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION: VkObjectType = VkObjectType(1000156000);
/// `1000295000`  
pub const VK_OBJECT_TYPE_PRIVATE_DATA_SLOT: VkObjectType = VkObjectType(1000295000);
/// `1000000000`  
pub const VK_OBJECT_TYPE_SURFACE_KHR: VkObjectType = VkObjectType(1000000000);
/// `1000001000`  
pub const VK_OBJECT_TYPE_SWAPCHAIN_KHR: VkObjectType = VkObjectType(1000001000);
/// `1000002000`  
pub const VK_OBJECT_TYPE_DISPLAY_KHR: VkObjectType = VkObjectType(1000002000);
/// `1000002001`  
pub const VK_OBJECT_TYPE_DISPLAY_MODE_KHR: VkObjectType = VkObjectType(1000002001);
/// `1000011000`  
pub const VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT: VkObjectType = VkObjectType(1000011000);
/// `1000023000`  
/// 
/// VkVideoSessionKHR
pub const VK_OBJECT_TYPE_VIDEO_SESSION_KHR: VkObjectType = VkObjectType(1000023000);
/// `1000023001`  
/// 
/// VkVideoSessionParametersKHR
pub const VK_OBJECT_TYPE_VIDEO_SESSION_PARAMETERS_KHR: VkObjectType = VkObjectType(1000023001);
/// `1000029000`  
pub const VK_OBJECT_TYPE_CU_MODULE_NVX: VkObjectType = VkObjectType(1000029000);
/// `1000029001`  
pub const VK_OBJECT_TYPE_CU_FUNCTION_NVX: VkObjectType = VkObjectType(1000029001);
/// `VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE`  
pub const VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR: VkObjectType = VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE;
/// `1000128000`  
pub const VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT: VkObjectType = VkObjectType(1000128000);
/// `1000150000`  
pub const VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR: VkObjectType = VkObjectType(1000150000);
/// `VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION`  
pub const VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR: VkObjectType = VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION;
/// `1000160000`  
pub const VK_OBJECT_TYPE_VALIDATION_CACHE_EXT: VkObjectType = VkObjectType(1000160000);
/// `1000165000`  
pub const VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV: VkObjectType = VkObjectType(1000165000);
/// `1000210000`  
pub const VK_OBJECT_TYPE_PERFORMANCE_CONFIGURATION_INTEL: VkObjectType = VkObjectType(1000210000);
/// `1000268000`  
pub const VK_OBJECT_TYPE_DEFERRED_OPERATION_KHR: VkObjectType = VkObjectType(1000268000);
/// `1000277000`  
pub const VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NV: VkObjectType = VkObjectType(1000277000);
/// `VK_OBJECT_TYPE_PRIVATE_DATA_SLOT`  
pub const VK_OBJECT_TYPE_PRIVATE_DATA_SLOT_EXT: VkObjectType = VK_OBJECT_TYPE_PRIVATE_DATA_SLOT;
/// `1000307000`  
pub const VK_OBJECT_TYPE_CUDA_MODULE_NV: VkObjectType = VkObjectType(1000307000);
/// `1000307001`  
pub const VK_OBJECT_TYPE_CUDA_FUNCTION_NV: VkObjectType = VkObjectType(1000307001);
/// `1000366000`  
/// 
/// VkBufferCollectionFUCHSIA
pub const VK_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIA: VkObjectType = VkObjectType(1000366000);
/// `1000396000`  
pub const VK_OBJECT_TYPE_MICROMAP_EXT: VkObjectType = VkObjectType(1000396000);
/// `1000460000`  
pub const VK_OBJECT_TYPE_TENSOR_ARM: VkObjectType = VkObjectType(1000460000);
/// `1000460001`  
pub const VK_OBJECT_TYPE_TENSOR_VIEW_ARM: VkObjectType = VkObjectType(1000460001);
/// `1000464000`  
pub const VK_OBJECT_TYPE_OPTICAL_FLOW_SESSION_NV: VkObjectType = VkObjectType(1000464000);
/// `1000482000`  
pub const VK_OBJECT_TYPE_SHADER_EXT: VkObjectType = VkObjectType(1000482000);
/// `1000483000`  
pub const VK_OBJECT_TYPE_PIPELINE_BINARY_KHR: VkObjectType = VkObjectType(1000483000);
/// `1000489000`  
/// 
/// VkSemaphoreSciSyncPoolNV
pub const VK_OBJECT_TYPE_SEMAPHORE_SCI_SYNC_POOL_NV: VkObjectType = VkObjectType(1000489000);
/// `1000507000`  
pub const VK_OBJECT_TYPE_DATA_GRAPH_PIPELINE_SESSION_ARM: VkObjectType = VkObjectType(1000507000);
/// `1000556000`  
pub const VK_OBJECT_TYPE_EXTERNAL_COMPUTE_QUEUE_NV: VkObjectType = VkObjectType(1000556000);
/// `1000572000`  
pub const VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_EXT: VkObjectType = VkObjectType(1000572000);
/// `1000572001`  
pub const VK_OBJECT_TYPE_INDIRECT_EXECUTION_SET_EXT: VkObjectType = VkObjectType(1000572001);
/// `1000607000`  
pub const VK_OBJECT_TYPE_SHADER_INSTRUMENTATION_ARM: VkObjectType = VkObjectType(1000607000);

impl_enum_display!(VkObjectType { VK_OBJECT_TYPE_UNKNOWN, VK_OBJECT_TYPE_INSTANCE, VK_OBJECT_TYPE_PHYSICAL_DEVICE, VK_OBJECT_TYPE_DEVICE, VK_OBJECT_TYPE_QUEUE, VK_OBJECT_TYPE_SEMAPHORE, VK_OBJECT_TYPE_COMMAND_BUFFER, VK_OBJECT_TYPE_FENCE, VK_OBJECT_TYPE_DEVICE_MEMORY, VK_OBJECT_TYPE_BUFFER, VK_OBJECT_TYPE_IMAGE, VK_OBJECT_TYPE_EVENT, VK_OBJECT_TYPE_QUERY_POOL, VK_OBJECT_TYPE_BUFFER_VIEW, VK_OBJECT_TYPE_IMAGE_VIEW, VK_OBJECT_TYPE_SHADER_MODULE, VK_OBJECT_TYPE_PIPELINE_CACHE, VK_OBJECT_TYPE_PIPELINE_LAYOUT, VK_OBJECT_TYPE_RENDER_PASS, VK_OBJECT_TYPE_PIPELINE, VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT, VK_OBJECT_TYPE_SAMPLER, VK_OBJECT_TYPE_DESCRIPTOR_POOL, VK_OBJECT_TYPE_DESCRIPTOR_SET, VK_OBJECT_TYPE_FRAMEBUFFER, VK_OBJECT_TYPE_COMMAND_POOL, VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE, VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION, VK_OBJECT_TYPE_PRIVATE_DATA_SLOT, VK_OBJECT_TYPE_SURFACE_KHR, VK_OBJECT_TYPE_SWAPCHAIN_KHR, VK_OBJECT_TYPE_DISPLAY_KHR, VK_OBJECT_TYPE_DISPLAY_MODE_KHR, VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT, VK_OBJECT_TYPE_VIDEO_SESSION_KHR, VK_OBJECT_TYPE_VIDEO_SESSION_PARAMETERS_KHR, VK_OBJECT_TYPE_CU_MODULE_NVX, VK_OBJECT_TYPE_CU_FUNCTION_NVX, VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR, VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT, VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR, VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR, VK_OBJECT_TYPE_VALIDATION_CACHE_EXT, VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV, VK_OBJECT_TYPE_PERFORMANCE_CONFIGURATION_INTEL, VK_OBJECT_TYPE_DEFERRED_OPERATION_KHR, VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NV, VK_OBJECT_TYPE_PRIVATE_DATA_SLOT_EXT, VK_OBJECT_TYPE_CUDA_MODULE_NV, VK_OBJECT_TYPE_CUDA_FUNCTION_NV, VK_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIA, VK_OBJECT_TYPE_MICROMAP_EXT, VK_OBJECT_TYPE_TENSOR_ARM, VK_OBJECT_TYPE_TENSOR_VIEW_ARM, VK_OBJECT_TYPE_OPTICAL_FLOW_SESSION_NV, VK_OBJECT_TYPE_SHADER_EXT, VK_OBJECT_TYPE_PIPELINE_BINARY_KHR, VK_OBJECT_TYPE_SEMAPHORE_SCI_SYNC_POOL_NV, VK_OBJECT_TYPE_DATA_GRAPH_PIPELINE_SESSION_ARM, VK_OBJECT_TYPE_EXTERNAL_COMPUTE_QUEUE_NV, VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_EXT, VK_OBJECT_TYPE_INDIRECT_EXECUTION_SET_EXT, VK_OBJECT_TYPE_SHADER_INSTRUMENTATION_ARM });

/// `VkOffset2D`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkOffset2D {
    pub x: int32_t,
    pub y: int32_t,
}
impl_default_zeroed!(VkOffset2D);

/// `VkOffset3D`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkOffset3D {
    pub x: int32_t,
    pub y: int32_t,
    pub z: int32_t,
}
impl_default_zeroed!(VkOffset3D);

from_into_transparent!(VkOpacityMicromapFormatEXT: i32);
/// `VkOpacityMicromapFormatEXT`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkOpacityMicromapFormatEXT(pub i32);

/// `1`  
pub const VK_OPACITY_MICROMAP_FORMAT_2_STATE_EXT: VkOpacityMicromapFormatEXT = VkOpacityMicromapFormatEXT(1);
/// `2`  
pub const VK_OPACITY_MICROMAP_FORMAT_4_STATE_EXT: VkOpacityMicromapFormatEXT = VkOpacityMicromapFormatEXT(2);

impl_enum_display!(VkOpacityMicromapFormatEXT { VK_OPACITY_MICROMAP_FORMAT_2_STATE_EXT, VK_OPACITY_MICROMAP_FORMAT_4_STATE_EXT });

from_into_transparent!(VkOpacityMicromapSpecialIndexEXT: i32);
/// `VkOpacityMicromapSpecialIndexEXT`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkOpacityMicromapSpecialIndexEXT(pub i32);

/// `-1`  
pub const VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_TRANSPARENT_EXT: VkOpacityMicromapSpecialIndexEXT = VkOpacityMicromapSpecialIndexEXT(-1);
/// `-2`  
pub const VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_OPAQUE_EXT: VkOpacityMicromapSpecialIndexEXT = VkOpacityMicromapSpecialIndexEXT(-2);
/// `-3`  
pub const VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_UNKNOWN_TRANSPARENT_EXT: VkOpacityMicromapSpecialIndexEXT = VkOpacityMicromapSpecialIndexEXT(-3);
/// `-4`  
pub const VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_UNKNOWN_OPAQUE_EXT: VkOpacityMicromapSpecialIndexEXT = VkOpacityMicromapSpecialIndexEXT(-4);
/// `-5`  
pub const VK_OPACITY_MICROMAP_SPECIAL_INDEX_CLUSTER_GEOMETRY_DISABLE_OPACITY_MICROMAP_NV: VkOpacityMicromapSpecialIndexEXT = VkOpacityMicromapSpecialIndexEXT(-5);

impl_enum_display!(VkOpacityMicromapSpecialIndexEXT { VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_TRANSPARENT_EXT, VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_OPAQUE_EXT, VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_UNKNOWN_TRANSPARENT_EXT, VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_UNKNOWN_OPAQUE_EXT, VK_OPACITY_MICROMAP_SPECIAL_INDEX_CLUSTER_GEOMETRY_DISABLE_OPACITY_MICROMAP_NV });

/// `VkOpaqueCaptureDataCreateInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkOpaqueCaptureDataCreateInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub pData: *const VkHostAddressRangeConstEXT,
}
impl_default_zeroed_with_s_type!(VkOpaqueCaptureDataCreateInfoEXT : VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DATA_CREATE_INFO_EXT);
impl_extends!(VkOpaqueCaptureDataCreateInfoEXT : VkImageCreateInfo, VkTensorCreateInfoARM);

/// `VkOpaqueCaptureDescriptorDataCreateInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkOpaqueCaptureDescriptorDataCreateInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub opaqueCaptureDescriptorData: *const void,
}
impl_default_zeroed_with_s_type!(VkOpaqueCaptureDescriptorDataCreateInfoEXT : VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT);
impl_extends!(VkOpaqueCaptureDescriptorDataCreateInfoEXT : VkBufferCreateInfo, VkImageCreateInfo, VkImageViewCreateInfo, VkSamplerCreateInfo, VkAccelerationStructureCreateInfoKHR, VkAccelerationStructureCreateInfoNV, VkTensorCreateInfoARM, VkTensorViewCreateInfoARM);

flags!(VkOpticalFlowExecuteFlagsNV);
from_into_transparent!(VkOpticalFlowExecuteFlagsNV: i32);
/// `VkOpticalFlowExecuteFlagsNV`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkOpticalFlowExecuteFlagsNV(pub i32);

/// `1 << 0`  
pub const VK_OPTICAL_FLOW_EXECUTE_DISABLE_TEMPORAL_HINTS_BIT_NV: VkOpticalFlowExecuteFlagsNV = VkOpticalFlowExecuteFlagsNV(1 << 0);

impl_flags_display!(VkOpticalFlowExecuteFlagsNV { VK_OPTICAL_FLOW_EXECUTE_DISABLE_TEMPORAL_HINTS_BIT_NV });

/// `VkOpticalFlowExecuteInfoNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkOpticalFlowExecuteInfoNV {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub flags: VkOpticalFlowExecuteFlagsNV,
    pub regionCount: uint32_t,
    pub pRegions: *const VkRect2D,
}
impl_default_zeroed_with_s_type!(VkOpticalFlowExecuteInfoNV : VK_STRUCTURE_TYPE_OPTICAL_FLOW_EXECUTE_INFO_NV);

flags!(VkOpticalFlowGridSizeFlagsNV);
from_into_transparent!(VkOpticalFlowGridSizeFlagsNV: i32);
/// `VkOpticalFlowGridSizeFlagsNV`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkOpticalFlowGridSizeFlagsNV(pub i32);

/// `0`  
pub const VK_OPTICAL_FLOW_GRID_SIZE_UNKNOWN_NV: VkOpticalFlowGridSizeFlagsNV = VkOpticalFlowGridSizeFlagsNV(0);
/// `1 << 0`  
pub const VK_OPTICAL_FLOW_GRID_SIZE_1X1_BIT_NV: VkOpticalFlowGridSizeFlagsNV = VkOpticalFlowGridSizeFlagsNV(1 << 0);
/// `1 << 1`  
pub const VK_OPTICAL_FLOW_GRID_SIZE_2X2_BIT_NV: VkOpticalFlowGridSizeFlagsNV = VkOpticalFlowGridSizeFlagsNV(1 << 1);
/// `1 << 2`  
pub const VK_OPTICAL_FLOW_GRID_SIZE_4X4_BIT_NV: VkOpticalFlowGridSizeFlagsNV = VkOpticalFlowGridSizeFlagsNV(1 << 2);
/// `1 << 3`  
pub const VK_OPTICAL_FLOW_GRID_SIZE_8X8_BIT_NV: VkOpticalFlowGridSizeFlagsNV = VkOpticalFlowGridSizeFlagsNV(1 << 3);

impl_flags_display!(VkOpticalFlowGridSizeFlagsNV { VK_OPTICAL_FLOW_GRID_SIZE_UNKNOWN_NV, VK_OPTICAL_FLOW_GRID_SIZE_1X1_BIT_NV, VK_OPTICAL_FLOW_GRID_SIZE_2X2_BIT_NV, VK_OPTICAL_FLOW_GRID_SIZE_4X4_BIT_NV, VK_OPTICAL_FLOW_GRID_SIZE_8X8_BIT_NV });

/// `VkOpticalFlowImageFormatInfoNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkOpticalFlowImageFormatInfoNV {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub usage: VkOpticalFlowUsageFlagsNV,
}
impl_default_zeroed_with_s_type!(VkOpticalFlowImageFormatInfoNV : VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV);
impl_extends!(VkOpticalFlowImageFormatInfoNV : VkPhysicalDeviceImageFormatInfo2, VkImageCreateInfo);

/// `VkOpticalFlowImageFormatPropertiesNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkOpticalFlowImageFormatPropertiesNV {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub format: VkFormat,
}
impl_default_zeroed_with_s_type!(VkOpticalFlowImageFormatPropertiesNV : VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_PROPERTIES_NV);

from_into_transparent!(VkOpticalFlowPerformanceLevelNV: i32);
/// `VkOpticalFlowPerformanceLevelNV`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkOpticalFlowPerformanceLevelNV(pub i32);

/// `0`  
pub const VK_OPTICAL_FLOW_PERFORMANCE_LEVEL_UNKNOWN_NV: VkOpticalFlowPerformanceLevelNV = VkOpticalFlowPerformanceLevelNV(0);
/// `1`  
pub const VK_OPTICAL_FLOW_PERFORMANCE_LEVEL_SLOW_NV: VkOpticalFlowPerformanceLevelNV = VkOpticalFlowPerformanceLevelNV(1);
/// `2`  
pub const VK_OPTICAL_FLOW_PERFORMANCE_LEVEL_MEDIUM_NV: VkOpticalFlowPerformanceLevelNV = VkOpticalFlowPerformanceLevelNV(2);
/// `3`  
pub const VK_OPTICAL_FLOW_PERFORMANCE_LEVEL_FAST_NV: VkOpticalFlowPerformanceLevelNV = VkOpticalFlowPerformanceLevelNV(3);

impl_enum_display!(VkOpticalFlowPerformanceLevelNV { VK_OPTICAL_FLOW_PERFORMANCE_LEVEL_UNKNOWN_NV, VK_OPTICAL_FLOW_PERFORMANCE_LEVEL_SLOW_NV, VK_OPTICAL_FLOW_PERFORMANCE_LEVEL_MEDIUM_NV, VK_OPTICAL_FLOW_PERFORMANCE_LEVEL_FAST_NV });

from_into_transparent!(VkOpticalFlowSessionBindingPointNV: i32);
/// `VkOpticalFlowSessionBindingPointNV`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkOpticalFlowSessionBindingPointNV(pub i32);

/// `0`  
pub const VK_OPTICAL_FLOW_SESSION_BINDING_POINT_UNKNOWN_NV: VkOpticalFlowSessionBindingPointNV = VkOpticalFlowSessionBindingPointNV(0);
/// `1`  
pub const VK_OPTICAL_FLOW_SESSION_BINDING_POINT_INPUT_NV: VkOpticalFlowSessionBindingPointNV = VkOpticalFlowSessionBindingPointNV(1);
/// `2`  
pub const VK_OPTICAL_FLOW_SESSION_BINDING_POINT_REFERENCE_NV: VkOpticalFlowSessionBindingPointNV = VkOpticalFlowSessionBindingPointNV(2);
/// `3`  
pub const VK_OPTICAL_FLOW_SESSION_BINDING_POINT_HINT_NV: VkOpticalFlowSessionBindingPointNV = VkOpticalFlowSessionBindingPointNV(3);
/// `4`  
pub const VK_OPTICAL_FLOW_SESSION_BINDING_POINT_FLOW_VECTOR_NV: VkOpticalFlowSessionBindingPointNV = VkOpticalFlowSessionBindingPointNV(4);
/// `5`  
pub const VK_OPTICAL_FLOW_SESSION_BINDING_POINT_BACKWARD_FLOW_VECTOR_NV: VkOpticalFlowSessionBindingPointNV = VkOpticalFlowSessionBindingPointNV(5);
/// `6`  
pub const VK_OPTICAL_FLOW_SESSION_BINDING_POINT_COST_NV: VkOpticalFlowSessionBindingPointNV = VkOpticalFlowSessionBindingPointNV(6);
/// `7`  
pub const VK_OPTICAL_FLOW_SESSION_BINDING_POINT_BACKWARD_COST_NV: VkOpticalFlowSessionBindingPointNV = VkOpticalFlowSessionBindingPointNV(7);
/// `8`  
pub const VK_OPTICAL_FLOW_SESSION_BINDING_POINT_GLOBAL_FLOW_NV: VkOpticalFlowSessionBindingPointNV = VkOpticalFlowSessionBindingPointNV(8);

impl_enum_display!(VkOpticalFlowSessionBindingPointNV { VK_OPTICAL_FLOW_SESSION_BINDING_POINT_UNKNOWN_NV, VK_OPTICAL_FLOW_SESSION_BINDING_POINT_INPUT_NV, VK_OPTICAL_FLOW_SESSION_BINDING_POINT_REFERENCE_NV, VK_OPTICAL_FLOW_SESSION_BINDING_POINT_HINT_NV, VK_OPTICAL_FLOW_SESSION_BINDING_POINT_FLOW_VECTOR_NV, VK_OPTICAL_FLOW_SESSION_BINDING_POINT_BACKWARD_FLOW_VECTOR_NV, VK_OPTICAL_FLOW_SESSION_BINDING_POINT_COST_NV, VK_OPTICAL_FLOW_SESSION_BINDING_POINT_BACKWARD_COST_NV, VK_OPTICAL_FLOW_SESSION_BINDING_POINT_GLOBAL_FLOW_NV });

flags!(VkOpticalFlowSessionCreateFlagsNV);
from_into_transparent!(VkOpticalFlowSessionCreateFlagsNV: i32);
/// `VkOpticalFlowSessionCreateFlagsNV`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkOpticalFlowSessionCreateFlagsNV(pub i32);

/// `1 << 0`  
pub const VK_OPTICAL_FLOW_SESSION_CREATE_ENABLE_HINT_BIT_NV: VkOpticalFlowSessionCreateFlagsNV = VkOpticalFlowSessionCreateFlagsNV(1 << 0);
/// `1 << 1`  
pub const VK_OPTICAL_FLOW_SESSION_CREATE_ENABLE_COST_BIT_NV: VkOpticalFlowSessionCreateFlagsNV = VkOpticalFlowSessionCreateFlagsNV(1 << 1);
/// `1 << 2`  
pub const VK_OPTICAL_FLOW_SESSION_CREATE_ENABLE_GLOBAL_FLOW_BIT_NV: VkOpticalFlowSessionCreateFlagsNV = VkOpticalFlowSessionCreateFlagsNV(1 << 2);
/// `1 << 3`  
pub const VK_OPTICAL_FLOW_SESSION_CREATE_ALLOW_REGIONS_BIT_NV: VkOpticalFlowSessionCreateFlagsNV = VkOpticalFlowSessionCreateFlagsNV(1 << 3);
/// `1 << 4`  
pub const VK_OPTICAL_FLOW_SESSION_CREATE_BOTH_DIRECTIONS_BIT_NV: VkOpticalFlowSessionCreateFlagsNV = VkOpticalFlowSessionCreateFlagsNV(1 << 4);

impl_flags_display!(VkOpticalFlowSessionCreateFlagsNV { VK_OPTICAL_FLOW_SESSION_CREATE_ENABLE_HINT_BIT_NV, VK_OPTICAL_FLOW_SESSION_CREATE_ENABLE_COST_BIT_NV, VK_OPTICAL_FLOW_SESSION_CREATE_ENABLE_GLOBAL_FLOW_BIT_NV, VK_OPTICAL_FLOW_SESSION_CREATE_ALLOW_REGIONS_BIT_NV, VK_OPTICAL_FLOW_SESSION_CREATE_BOTH_DIRECTIONS_BIT_NV });

/// `VkOpticalFlowSessionCreateInfoNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkOpticalFlowSessionCreateInfoNV {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub width: uint32_t,
    pub height: uint32_t,
    pub imageFormat: VkFormat,
    pub flowVectorFormat: VkFormat,
    pub costFormat: VkFormat,
    pub outputGridSize: VkOpticalFlowGridSizeFlagsNV,
    pub hintGridSize: VkOpticalFlowGridSizeFlagsNV,
    pub performanceLevel: VkOpticalFlowPerformanceLevelNV,
    pub flags: VkOpticalFlowSessionCreateFlagsNV,
}
impl_default_zeroed_with_s_type!(VkOpticalFlowSessionCreateInfoNV : VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_INFO_NV);

/// `VkOpticalFlowSessionCreatePrivateDataInfoNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkOpticalFlowSessionCreatePrivateDataInfoNV {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub id: uint32_t,
    pub size: uint32_t,
    pub pPrivateData: *const void,
}
impl_default_zeroed_with_s_type!(VkOpticalFlowSessionCreatePrivateDataInfoNV : VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV);
impl_extends!(VkOpticalFlowSessionCreatePrivateDataInfoNV : VkOpticalFlowSessionCreateInfoNV);

/// `VkOpticalFlowSessionNV` : `VkDevice`
#[repr(transparent)]
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkOpticalFlowSessionNV(pub u64);
from_into_transparent!(VkOpticalFlowSessionNV: u64);
impl_handle!(VkOpticalFlowSessionNV: VK_OBJECT_TYPE_OPTICAL_FLOW_SESSION_NV; SubHandle = VkDevice);

flags!(VkOpticalFlowUsageFlagsNV);
from_into_transparent!(VkOpticalFlowUsageFlagsNV: i32);
/// `VkOpticalFlowUsageFlagsNV`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkOpticalFlowUsageFlagsNV(pub i32);

/// `0`  
pub const VK_OPTICAL_FLOW_USAGE_UNKNOWN_NV: VkOpticalFlowUsageFlagsNV = VkOpticalFlowUsageFlagsNV(0);
/// `1 << 0`  
pub const VK_OPTICAL_FLOW_USAGE_INPUT_BIT_NV: VkOpticalFlowUsageFlagsNV = VkOpticalFlowUsageFlagsNV(1 << 0);
/// `1 << 1`  
pub const VK_OPTICAL_FLOW_USAGE_OUTPUT_BIT_NV: VkOpticalFlowUsageFlagsNV = VkOpticalFlowUsageFlagsNV(1 << 1);
/// `1 << 2`  
pub const VK_OPTICAL_FLOW_USAGE_HINT_BIT_NV: VkOpticalFlowUsageFlagsNV = VkOpticalFlowUsageFlagsNV(1 << 2);
/// `1 << 3`  
pub const VK_OPTICAL_FLOW_USAGE_COST_BIT_NV: VkOpticalFlowUsageFlagsNV = VkOpticalFlowUsageFlagsNV(1 << 3);
/// `1 << 4`  
pub const VK_OPTICAL_FLOW_USAGE_GLOBAL_FLOW_BIT_NV: VkOpticalFlowUsageFlagsNV = VkOpticalFlowUsageFlagsNV(1 << 4);

impl_flags_display!(VkOpticalFlowUsageFlagsNV { VK_OPTICAL_FLOW_USAGE_UNKNOWN_NV, VK_OPTICAL_FLOW_USAGE_INPUT_BIT_NV, VK_OPTICAL_FLOW_USAGE_OUTPUT_BIT_NV, VK_OPTICAL_FLOW_USAGE_HINT_BIT_NV, VK_OPTICAL_FLOW_USAGE_COST_BIT_NV, VK_OPTICAL_FLOW_USAGE_GLOBAL_FLOW_BIT_NV });

/// `VkOutOfBandQueueTypeInfoNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkOutOfBandQueueTypeInfoNV {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub queueType: VkOutOfBandQueueTypeNV,
}
impl_default_zeroed_with_s_type!(VkOutOfBandQueueTypeInfoNV : VK_STRUCTURE_TYPE_OUT_OF_BAND_QUEUE_TYPE_INFO_NV);

from_into_transparent!(VkOutOfBandQueueTypeNV: i32);
/// `VkOutOfBandQueueTypeNV`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkOutOfBandQueueTypeNV(pub i32);

/// `0`  
pub const VK_OUT_OF_BAND_QUEUE_TYPE_RENDER_NV: VkOutOfBandQueueTypeNV = VkOutOfBandQueueTypeNV(0);
/// `1`  
pub const VK_OUT_OF_BAND_QUEUE_TYPE_PRESENT_NV: VkOutOfBandQueueTypeNV = VkOutOfBandQueueTypeNV(1);

impl_enum_display!(VkOutOfBandQueueTypeNV { VK_OUT_OF_BAND_QUEUE_TYPE_RENDER_NV, VK_OUT_OF_BAND_QUEUE_TYPE_PRESENT_NV });

/// `VkPartitionedAccelerationStructureFlagsNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPartitionedAccelerationStructureFlagsNV {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub enablePartitionTranslation: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPartitionedAccelerationStructureFlagsNV : VK_STRUCTURE_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_FLAGS_NV);
impl_extends!(VkPartitionedAccelerationStructureFlagsNV : VkPartitionedAccelerationStructureInstancesInputNV);

flags!(VkPartitionedAccelerationStructureInstanceFlagsNV);
from_into_transparent!(VkPartitionedAccelerationStructureInstanceFlagsNV: i32);
/// `VkPartitionedAccelerationStructureInstanceFlagsNV`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkPartitionedAccelerationStructureInstanceFlagsNV(pub i32);

/// `1 << 0`  
pub const VK_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCE_FLAG_TRIANGLE_FACING_CULL_DISABLE_BIT_NV: VkPartitionedAccelerationStructureInstanceFlagsNV = VkPartitionedAccelerationStructureInstanceFlagsNV(1 << 0);
/// `1 << 1`  
pub const VK_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCE_FLAG_TRIANGLE_FLIP_FACING_BIT_NV: VkPartitionedAccelerationStructureInstanceFlagsNV = VkPartitionedAccelerationStructureInstanceFlagsNV(1 << 1);
/// `1 << 2`  
pub const VK_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCE_FLAG_FORCE_OPAQUE_BIT_NV: VkPartitionedAccelerationStructureInstanceFlagsNV = VkPartitionedAccelerationStructureInstanceFlagsNV(1 << 2);
/// `1 << 3`  
pub const VK_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCE_FLAG_FORCE_NO_OPAQUE_BIT_NV: VkPartitionedAccelerationStructureInstanceFlagsNV = VkPartitionedAccelerationStructureInstanceFlagsNV(1 << 3);
/// `1 << 4`  
pub const VK_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCE_FLAG_ENABLE_EXPLICIT_BOUNDING_BOX_NV: VkPartitionedAccelerationStructureInstanceFlagsNV = VkPartitionedAccelerationStructureInstanceFlagsNV(1 << 4);

impl_flags_display!(VkPartitionedAccelerationStructureInstanceFlagsNV { VK_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCE_FLAG_TRIANGLE_FACING_CULL_DISABLE_BIT_NV, VK_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCE_FLAG_TRIANGLE_FLIP_FACING_BIT_NV, VK_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCE_FLAG_FORCE_OPAQUE_BIT_NV, VK_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCE_FLAG_FORCE_NO_OPAQUE_BIT_NV, VK_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCE_FLAG_ENABLE_EXPLICIT_BOUNDING_BOX_NV });

/// `VkPartitionedAccelerationStructureInstancesInputNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPartitionedAccelerationStructureInstancesInputNV {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub flags: VkBuildAccelerationStructureFlagsKHR,
    pub instanceCount: uint32_t,
    pub maxInstancePerPartitionCount: uint32_t,
    pub partitionCount: uint32_t,
    pub maxInstanceInGlobalPartitionCount: uint32_t,
}
impl_default_zeroed_with_s_type!(VkPartitionedAccelerationStructureInstancesInputNV : VK_STRUCTURE_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCES_INPUT_NV);

from_into_transparent!(VkPartitionedAccelerationStructureOpTypeNV: i32);
/// `VkPartitionedAccelerationStructureOpTypeNV`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkPartitionedAccelerationStructureOpTypeNV(pub i32);

/// `0`  
pub const VK_PARTITIONED_ACCELERATION_STRUCTURE_OP_TYPE_WRITE_INSTANCE_NV: VkPartitionedAccelerationStructureOpTypeNV = VkPartitionedAccelerationStructureOpTypeNV(0);
/// `1`  
pub const VK_PARTITIONED_ACCELERATION_STRUCTURE_OP_TYPE_UPDATE_INSTANCE_NV: VkPartitionedAccelerationStructureOpTypeNV = VkPartitionedAccelerationStructureOpTypeNV(1);
/// `2`  
pub const VK_PARTITIONED_ACCELERATION_STRUCTURE_OP_TYPE_WRITE_PARTITION_TRANSLATION_NV: VkPartitionedAccelerationStructureOpTypeNV = VkPartitionedAccelerationStructureOpTypeNV(2);

impl_enum_display!(VkPartitionedAccelerationStructureOpTypeNV { VK_PARTITIONED_ACCELERATION_STRUCTURE_OP_TYPE_WRITE_INSTANCE_NV, VK_PARTITIONED_ACCELERATION_STRUCTURE_OP_TYPE_UPDATE_INSTANCE_NV, VK_PARTITIONED_ACCELERATION_STRUCTURE_OP_TYPE_WRITE_PARTITION_TRANSLATION_NV });

/// `VkPartitionedAccelerationStructureUpdateInstanceDataNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPartitionedAccelerationStructureUpdateInstanceDataNV {
    pub instanceIndex: uint32_t,
    pub instanceContributionToHitGroupIndex: uint32_t,
    pub accelerationStructure: VkDeviceAddress,
}
impl_default_zeroed!(VkPartitionedAccelerationStructureUpdateInstanceDataNV);

/// `VkPartitionedAccelerationStructureWriteInstanceDataNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPartitionedAccelerationStructureWriteInstanceDataNV {
    pub transform: VkTransformMatrixKHR,
    pub explicitAABB: [float; 6 as usize],
    pub instanceID: uint32_t,
    pub instanceMask: uint32_t,
    pub instanceContributionToHitGroupIndex: uint32_t,
    pub instanceFlags: VkPartitionedAccelerationStructureInstanceFlagsNV,
    pub instanceIndex: uint32_t,
    pub partitionIndex: uint32_t,
    pub accelerationStructure: VkDeviceAddress,
}
impl_default_zeroed!(VkPartitionedAccelerationStructureWriteInstanceDataNV);

/// `VkPartitionedAccelerationStructureWritePartitionTranslationDataNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPartitionedAccelerationStructureWritePartitionTranslationDataNV {
    pub partitionIndex: uint32_t,
    pub partitionTranslation: [float; 3 as usize],
}
impl_default_zeroed!(VkPartitionedAccelerationStructureWritePartitionTranslationDataNV);

/// `VkPastPresentationTimingEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPastPresentationTimingEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    /// Application-provided identifier, previously given to vkQueuePresentKHR
    pub presentId: uint64_t,
    /// Application-provided present time
    pub targetTime: uint64_t,
    /// Number of present stages results available in pPresentStages
    pub presentStageCount: uint32_t,
    /// Reported timings for each present stage
    pub pPresentStages: *mut VkPresentStageTimeEXT,
    /// Time domain of the present stages
    pub timeDomain: VkTimeDomainKHR,
    /// Time domain id of the present stages
    pub timeDomainId: uint64_t,
    /// VK_TRUE if all the present stages have been reported
    pub reportComplete: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPastPresentationTimingEXT : VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_EXT);

flags!(VkPastPresentationTimingFlagsEXT);
from_into_transparent!(VkPastPresentationTimingFlagsEXT: i32);
/// `VkPastPresentationTimingFlagsEXT`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkPastPresentationTimingFlagsEXT(pub i32);

/// `1 << 0`  
pub const VK_PAST_PRESENTATION_TIMING_ALLOW_PARTIAL_RESULTS_BIT_EXT: VkPastPresentationTimingFlagsEXT = VkPastPresentationTimingFlagsEXT(1 << 0);
/// `1 << 1`  
pub const VK_PAST_PRESENTATION_TIMING_ALLOW_OUT_OF_ORDER_RESULTS_BIT_EXT: VkPastPresentationTimingFlagsEXT = VkPastPresentationTimingFlagsEXT(1 << 1);

impl_flags_display!(VkPastPresentationTimingFlagsEXT { VK_PAST_PRESENTATION_TIMING_ALLOW_PARTIAL_RESULTS_BIT_EXT, VK_PAST_PRESENTATION_TIMING_ALLOW_OUT_OF_ORDER_RESULTS_BIT_EXT });

/// `VkPastPresentationTimingGOOGLE`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPastPresentationTimingGOOGLE {
    /// Application-provided identifier, previously given to vkQueuePresentKHR
    pub presentID: uint32_t,
    /// Earliest time an image should have been presented, previously given to vkQueuePresentKHR
    pub desiredPresentTime: uint64_t,
    /// Time the image was actually displayed
    pub actualPresentTime: uint64_t,
    /// Earliest time the image could have been displayed
    pub earliestPresentTime: uint64_t,
    /// How early vkQueuePresentKHR was processed vs. how soon it needed to be and make earliestPresentTime
    pub presentMargin: uint64_t,
}
impl_default_zeroed!(VkPastPresentationTimingGOOGLE);

/// `VkPastPresentationTimingInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPastPresentationTimingInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub flags: VkPastPresentationTimingFlagsEXT,
    pub swapchain: VkSwapchainKHR,
}
impl_default_zeroed_with_s_type!(VkPastPresentationTimingInfoEXT : VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_INFO_EXT);

/// `VkPastPresentationTimingPropertiesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPastPresentationTimingPropertiesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub timingPropertiesCounter: uint64_t,
    pub timeDomainsCounter: uint64_t,
    pub presentationTimingCount: uint32_t,
    pub pPresentationTimings: *mut VkPastPresentationTimingEXT,
}
impl_default_zeroed_with_s_type!(VkPastPresentationTimingPropertiesEXT : VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_PROPERTIES_EXT);

flags!(VkPeerMemoryFeatureFlags);
from_into_transparent!(VkPeerMemoryFeatureFlags: i32);
/// `VkPeerMemoryFeatureFlags`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkPeerMemoryFeatureFlags(pub i32);

/// `1 << 0`  
/// 
/// Can read with vkCmdCopy commands
pub const VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT: VkPeerMemoryFeatureFlags = VkPeerMemoryFeatureFlags(1 << 0);
/// `1 << 1`  
/// 
/// Can write with vkCmdCopy commands
pub const VK_PEER_MEMORY_FEATURE_COPY_DST_BIT: VkPeerMemoryFeatureFlags = VkPeerMemoryFeatureFlags(1 << 1);
/// `1 << 2`  
/// 
/// Can read with any access type/command
pub const VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT: VkPeerMemoryFeatureFlags = VkPeerMemoryFeatureFlags(1 << 2);
/// `1 << 3`  
/// 
/// Can write with and access type/command
pub const VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT: VkPeerMemoryFeatureFlags = VkPeerMemoryFeatureFlags(1 << 3);
/// `VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT`  
pub const VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT_KHR: VkPeerMemoryFeatureFlags = VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT;
/// `VK_PEER_MEMORY_FEATURE_COPY_DST_BIT`  
pub const VK_PEER_MEMORY_FEATURE_COPY_DST_BIT_KHR: VkPeerMemoryFeatureFlags = VK_PEER_MEMORY_FEATURE_COPY_DST_BIT;
/// `VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT`  
pub const VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT_KHR: VkPeerMemoryFeatureFlags = VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT;
/// `VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT`  
pub const VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT_KHR: VkPeerMemoryFeatureFlags = VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT;

impl_flags_display!(VkPeerMemoryFeatureFlags { VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT, VK_PEER_MEMORY_FEATURE_COPY_DST_BIT, VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT, VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT, VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT_KHR, VK_PEER_MEMORY_FEATURE_COPY_DST_BIT_KHR, VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT_KHR, VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT_KHR });

/// `VkPeerMemoryFeatureFlags`
pub type VkPeerMemoryFeatureFlagsKHR = VkPeerMemoryFeatureFlags;

/// `VkPerTileBeginInfoQCOM`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPerTileBeginInfoQCOM {
    pub sType: VkStructureType,
    pub pNext: *const void,
}
impl_default_zeroed_with_s_type!(VkPerTileBeginInfoQCOM : VK_STRUCTURE_TYPE_PER_TILE_BEGIN_INFO_QCOM);

/// `VkPerTileEndInfoQCOM`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPerTileEndInfoQCOM {
    pub sType: VkStructureType,
    pub pNext: *const void,
}
impl_default_zeroed_with_s_type!(VkPerTileEndInfoQCOM : VK_STRUCTURE_TYPE_PER_TILE_END_INFO_QCOM);

/// `VkPerformanceConfigurationAcquireInfoINTEL`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPerformanceConfigurationAcquireInfoINTEL {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub r#type: VkPerformanceConfigurationTypeINTEL,
}
impl_default_zeroed_with_s_type!(VkPerformanceConfigurationAcquireInfoINTEL : VK_STRUCTURE_TYPE_PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL);

/// `VkPerformanceConfigurationINTEL` : `VkDevice`
#[repr(transparent)]
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkPerformanceConfigurationINTEL(pub u64);
from_into_transparent!(VkPerformanceConfigurationINTEL: u64);
impl_handle!(VkPerformanceConfigurationINTEL: VK_OBJECT_TYPE_PERFORMANCE_CONFIGURATION_INTEL; SubHandle = VkDevice);

from_into_transparent!(VkPerformanceConfigurationTypeINTEL: i32);
/// `VkPerformanceConfigurationTypeINTEL`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkPerformanceConfigurationTypeINTEL(pub i32);

/// `0`  
pub const VK_PERFORMANCE_CONFIGURATION_TYPE_COMMAND_QUEUE_METRICS_DISCOVERY_ACTIVATED_INTEL: VkPerformanceConfigurationTypeINTEL = VkPerformanceConfigurationTypeINTEL(0);

impl_enum_display!(VkPerformanceConfigurationTypeINTEL { VK_PERFORMANCE_CONFIGURATION_TYPE_COMMAND_QUEUE_METRICS_DISCOVERY_ACTIVATED_INTEL });

/// `VkPerformanceCounterARM`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPerformanceCounterARM {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub counterID: uint32_t,
}
impl_default_zeroed_with_s_type!(VkPerformanceCounterARM : VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_ARM);

/// `VkPerformanceCounterDescriptionARM`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPerformanceCounterDescriptionARM {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub flags: VkPerformanceCounterDescriptionFlagsARM,
    pub name: [c_char; VK_MAX_DESCRIPTION_SIZE as usize],
}
impl_default_zeroed_with_s_type!(VkPerformanceCounterDescriptionARM : VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_ARM);

flags!(VkPerformanceCounterDescriptionFlagsARM);
from_into_transparent!(VkPerformanceCounterDescriptionFlagsARM: i32);
/// `VkPerformanceCounterDescriptionFlagsARM`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkPerformanceCounterDescriptionFlagsARM(pub i32);

impl_flags_display!(VkPerformanceCounterDescriptionFlagsARM {  });

flags!(VkPerformanceCounterDescriptionFlagsKHR);
from_into_transparent!(VkPerformanceCounterDescriptionFlagsKHR: i32);
/// `VkPerformanceCounterDescriptionFlagsKHR`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkPerformanceCounterDescriptionFlagsKHR(pub i32);

/// `1 << 0`  
pub const VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_BIT_KHR: VkPerformanceCounterDescriptionFlagsKHR = VkPerformanceCounterDescriptionFlagsKHR(1 << 0);
/// `VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_BIT_KHR`  
pub const VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_KHR: VkPerformanceCounterDescriptionFlagsKHR = VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_BIT_KHR;
/// `1 << 1`  
pub const VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_BIT_KHR: VkPerformanceCounterDescriptionFlagsKHR = VkPerformanceCounterDescriptionFlagsKHR(1 << 1);
/// `VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_BIT_KHR`  
pub const VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_KHR: VkPerformanceCounterDescriptionFlagsKHR = VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_BIT_KHR;

impl_flags_display!(VkPerformanceCounterDescriptionFlagsKHR { VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_BIT_KHR, VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_KHR, VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_BIT_KHR, VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_KHR });

/// `VkPerformanceCounterDescriptionKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPerformanceCounterDescriptionKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub flags: VkPerformanceCounterDescriptionFlagsKHR,
    pub name: [c_char; VK_MAX_DESCRIPTION_SIZE as usize],
    pub category: [c_char; VK_MAX_DESCRIPTION_SIZE as usize],
    pub description: [c_char; VK_MAX_DESCRIPTION_SIZE as usize],
}
impl_default_zeroed_with_s_type!(VkPerformanceCounterDescriptionKHR : VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_KHR);

/// `VkPerformanceCounterKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPerformanceCounterKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub unit: VkPerformanceCounterUnitKHR,
    pub scope: VkPerformanceCounterScopeKHR,
    pub storage: VkPerformanceCounterStorageKHR,
    pub uuid: [uint8_t; VK_UUID_SIZE as usize],
}
impl_default_zeroed_with_s_type!(VkPerformanceCounterKHR : VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_KHR);

/// `VkPerformanceCounterResultKHR`
/// 
/// // Union of all the possible return types a counter result could return
#[repr(C)]
#[derive(Clone, Copy)]
pub union VkPerformanceCounterResultKHR {
    pub int32: int32_t,
    pub int64: int64_t,
    pub uint32: uint32_t,
    pub uint64: uint64_t,
    pub float32: float,
    pub float64: double,
}
impl_debug_for_union!(VkPerformanceCounterResultKHR);
impl_default_zeroed!(VkPerformanceCounterResultKHR);

from_into_transparent!(VkPerformanceCounterScopeKHR: i32);
/// `VkPerformanceCounterScopeKHR`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkPerformanceCounterScopeKHR(pub i32);

/// `0`  
pub const VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_BUFFER_KHR: VkPerformanceCounterScopeKHR = VkPerformanceCounterScopeKHR(0);
/// `1`  
pub const VK_PERFORMANCE_COUNTER_SCOPE_RENDER_PASS_KHR: VkPerformanceCounterScopeKHR = VkPerformanceCounterScopeKHR(1);
/// `2`  
pub const VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_KHR: VkPerformanceCounterScopeKHR = VkPerformanceCounterScopeKHR(2);
/// `VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_BUFFER_KHR`  
pub const VK_QUERY_SCOPE_COMMAND_BUFFER_KHR: VkPerformanceCounterScopeKHR = VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_BUFFER_KHR;
/// `VK_PERFORMANCE_COUNTER_SCOPE_RENDER_PASS_KHR`  
pub const VK_QUERY_SCOPE_RENDER_PASS_KHR: VkPerformanceCounterScopeKHR = VK_PERFORMANCE_COUNTER_SCOPE_RENDER_PASS_KHR;
/// `VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_KHR`  
pub const VK_QUERY_SCOPE_COMMAND_KHR: VkPerformanceCounterScopeKHR = VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_KHR;

impl_enum_display!(VkPerformanceCounterScopeKHR { VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_BUFFER_KHR, VK_PERFORMANCE_COUNTER_SCOPE_RENDER_PASS_KHR, VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_KHR, VK_QUERY_SCOPE_COMMAND_BUFFER_KHR, VK_QUERY_SCOPE_RENDER_PASS_KHR, VK_QUERY_SCOPE_COMMAND_KHR });

from_into_transparent!(VkPerformanceCounterStorageKHR: i32);
/// `VkPerformanceCounterStorageKHR`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkPerformanceCounterStorageKHR(pub i32);

/// `0`  
pub const VK_PERFORMANCE_COUNTER_STORAGE_INT32_KHR: VkPerformanceCounterStorageKHR = VkPerformanceCounterStorageKHR(0);
/// `1`  
pub const VK_PERFORMANCE_COUNTER_STORAGE_INT64_KHR: VkPerformanceCounterStorageKHR = VkPerformanceCounterStorageKHR(1);
/// `2`  
pub const VK_PERFORMANCE_COUNTER_STORAGE_UINT32_KHR: VkPerformanceCounterStorageKHR = VkPerformanceCounterStorageKHR(2);
/// `3`  
pub const VK_PERFORMANCE_COUNTER_STORAGE_UINT64_KHR: VkPerformanceCounterStorageKHR = VkPerformanceCounterStorageKHR(3);
/// `4`  
pub const VK_PERFORMANCE_COUNTER_STORAGE_FLOAT32_KHR: VkPerformanceCounterStorageKHR = VkPerformanceCounterStorageKHR(4);
/// `5`  
pub const VK_PERFORMANCE_COUNTER_STORAGE_FLOAT64_KHR: VkPerformanceCounterStorageKHR = VkPerformanceCounterStorageKHR(5);

impl_enum_display!(VkPerformanceCounterStorageKHR { VK_PERFORMANCE_COUNTER_STORAGE_INT32_KHR, VK_PERFORMANCE_COUNTER_STORAGE_INT64_KHR, VK_PERFORMANCE_COUNTER_STORAGE_UINT32_KHR, VK_PERFORMANCE_COUNTER_STORAGE_UINT64_KHR, VK_PERFORMANCE_COUNTER_STORAGE_FLOAT32_KHR, VK_PERFORMANCE_COUNTER_STORAGE_FLOAT64_KHR });

from_into_transparent!(VkPerformanceCounterUnitKHR: i32);
/// `VkPerformanceCounterUnitKHR`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkPerformanceCounterUnitKHR(pub i32);

/// `0`  
pub const VK_PERFORMANCE_COUNTER_UNIT_GENERIC_KHR: VkPerformanceCounterUnitKHR = VkPerformanceCounterUnitKHR(0);
/// `1`  
pub const VK_PERFORMANCE_COUNTER_UNIT_PERCENTAGE_KHR: VkPerformanceCounterUnitKHR = VkPerformanceCounterUnitKHR(1);
/// `2`  
pub const VK_PERFORMANCE_COUNTER_UNIT_NANOSECONDS_KHR: VkPerformanceCounterUnitKHR = VkPerformanceCounterUnitKHR(2);
/// `3`  
pub const VK_PERFORMANCE_COUNTER_UNIT_BYTES_KHR: VkPerformanceCounterUnitKHR = VkPerformanceCounterUnitKHR(3);
/// `4`  
pub const VK_PERFORMANCE_COUNTER_UNIT_BYTES_PER_SECOND_KHR: VkPerformanceCounterUnitKHR = VkPerformanceCounterUnitKHR(4);
/// `5`  
pub const VK_PERFORMANCE_COUNTER_UNIT_KELVIN_KHR: VkPerformanceCounterUnitKHR = VkPerformanceCounterUnitKHR(5);
/// `6`  
pub const VK_PERFORMANCE_COUNTER_UNIT_WATTS_KHR: VkPerformanceCounterUnitKHR = VkPerformanceCounterUnitKHR(6);
/// `7`  
pub const VK_PERFORMANCE_COUNTER_UNIT_VOLTS_KHR: VkPerformanceCounterUnitKHR = VkPerformanceCounterUnitKHR(7);
/// `8`  
pub const VK_PERFORMANCE_COUNTER_UNIT_AMPS_KHR: VkPerformanceCounterUnitKHR = VkPerformanceCounterUnitKHR(8);
/// `9`  
pub const VK_PERFORMANCE_COUNTER_UNIT_HERTZ_KHR: VkPerformanceCounterUnitKHR = VkPerformanceCounterUnitKHR(9);
/// `10`  
pub const VK_PERFORMANCE_COUNTER_UNIT_CYCLES_KHR: VkPerformanceCounterUnitKHR = VkPerformanceCounterUnitKHR(10);

impl_enum_display!(VkPerformanceCounterUnitKHR { VK_PERFORMANCE_COUNTER_UNIT_GENERIC_KHR, VK_PERFORMANCE_COUNTER_UNIT_PERCENTAGE_KHR, VK_PERFORMANCE_COUNTER_UNIT_NANOSECONDS_KHR, VK_PERFORMANCE_COUNTER_UNIT_BYTES_KHR, VK_PERFORMANCE_COUNTER_UNIT_BYTES_PER_SECOND_KHR, VK_PERFORMANCE_COUNTER_UNIT_KELVIN_KHR, VK_PERFORMANCE_COUNTER_UNIT_WATTS_KHR, VK_PERFORMANCE_COUNTER_UNIT_VOLTS_KHR, VK_PERFORMANCE_COUNTER_UNIT_AMPS_KHR, VK_PERFORMANCE_COUNTER_UNIT_HERTZ_KHR, VK_PERFORMANCE_COUNTER_UNIT_CYCLES_KHR });

/// `VkPerformanceMarkerInfoINTEL`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPerformanceMarkerInfoINTEL {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub marker: uint64_t,
}
impl_default_zeroed_with_s_type!(VkPerformanceMarkerInfoINTEL : VK_STRUCTURE_TYPE_PERFORMANCE_MARKER_INFO_INTEL);

/// `VkPerformanceOverrideInfoINTEL`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPerformanceOverrideInfoINTEL {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub r#type: VkPerformanceOverrideTypeINTEL,
    pub enable: VkBool32,
    pub parameter: uint64_t,
}
impl_default_zeroed_with_s_type!(VkPerformanceOverrideInfoINTEL : VK_STRUCTURE_TYPE_PERFORMANCE_OVERRIDE_INFO_INTEL);

from_into_transparent!(VkPerformanceOverrideTypeINTEL: i32);
/// `VkPerformanceOverrideTypeINTEL`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkPerformanceOverrideTypeINTEL(pub i32);

/// `0`  
pub const VK_PERFORMANCE_OVERRIDE_TYPE_NULL_HARDWARE_INTEL: VkPerformanceOverrideTypeINTEL = VkPerformanceOverrideTypeINTEL(0);
/// `1`  
pub const VK_PERFORMANCE_OVERRIDE_TYPE_FLUSH_GPU_CACHES_INTEL: VkPerformanceOverrideTypeINTEL = VkPerformanceOverrideTypeINTEL(1);

impl_enum_display!(VkPerformanceOverrideTypeINTEL { VK_PERFORMANCE_OVERRIDE_TYPE_NULL_HARDWARE_INTEL, VK_PERFORMANCE_OVERRIDE_TYPE_FLUSH_GPU_CACHES_INTEL });

from_into_transparent!(VkPerformanceParameterTypeINTEL: i32);
/// `VkPerformanceParameterTypeINTEL`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkPerformanceParameterTypeINTEL(pub i32);

/// `0`  
pub const VK_PERFORMANCE_PARAMETER_TYPE_HW_COUNTERS_SUPPORTED_INTEL: VkPerformanceParameterTypeINTEL = VkPerformanceParameterTypeINTEL(0);
/// `1`  
pub const VK_PERFORMANCE_PARAMETER_TYPE_STREAM_MARKER_VALID_BITS_INTEL: VkPerformanceParameterTypeINTEL = VkPerformanceParameterTypeINTEL(1);

impl_enum_display!(VkPerformanceParameterTypeINTEL { VK_PERFORMANCE_PARAMETER_TYPE_HW_COUNTERS_SUPPORTED_INTEL, VK_PERFORMANCE_PARAMETER_TYPE_STREAM_MARKER_VALID_BITS_INTEL });

/// `VkPerformanceQueryReservationInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPerformanceQueryReservationInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    /// Maximum number of VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR queries in a query pool
    pub maxPerformanceQueriesPerPool: uint32_t,
}
impl_default_zeroed_with_s_type!(VkPerformanceQueryReservationInfoKHR : VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_RESERVATION_INFO_KHR);
impl_extends!(VkPerformanceQueryReservationInfoKHR : VkDeviceCreateInfo);

/// `VkPerformanceQuerySubmitInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPerformanceQuerySubmitInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    /// Index for which counter pass to submit
    pub counterPassIndex: uint32_t,
}
impl_default_zeroed_with_s_type!(VkPerformanceQuerySubmitInfoKHR : VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR);
impl_extends!(VkPerformanceQuerySubmitInfoKHR : VkSubmitInfo, VkSubmitInfo2);

/// `VkPerformanceStreamMarkerInfoINTEL`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPerformanceStreamMarkerInfoINTEL {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub marker: uint32_t,
}
impl_default_zeroed_with_s_type!(VkPerformanceStreamMarkerInfoINTEL : VK_STRUCTURE_TYPE_PERFORMANCE_STREAM_MARKER_INFO_INTEL);

/// `VkPerformanceValueDataINTEL`
#[repr(C)]
#[derive(Clone, Copy)]
pub union VkPerformanceValueDataINTEL {
    pub value32: uint32_t,
    pub value64: uint64_t,
    pub valueFloat: float,
    pub valueBool: VkBool32,
    pub valueString: *const c_char,
}
impl_debug_for_union!(VkPerformanceValueDataINTEL);
impl_default_zeroed!(VkPerformanceValueDataINTEL);

/// `VkPerformanceValueINTEL`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPerformanceValueINTEL {
    pub r#type: VkPerformanceValueTypeINTEL,
    pub data: VkPerformanceValueDataINTEL,
}
impl_default_zeroed!(VkPerformanceValueINTEL);

from_into_transparent!(VkPerformanceValueTypeINTEL: i32);
/// `VkPerformanceValueTypeINTEL`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkPerformanceValueTypeINTEL(pub i32);

/// `0`  
pub const VK_PERFORMANCE_VALUE_TYPE_UINT32_INTEL: VkPerformanceValueTypeINTEL = VkPerformanceValueTypeINTEL(0);
/// `1`  
pub const VK_PERFORMANCE_VALUE_TYPE_UINT64_INTEL: VkPerformanceValueTypeINTEL = VkPerformanceValueTypeINTEL(1);
/// `2`  
pub const VK_PERFORMANCE_VALUE_TYPE_FLOAT_INTEL: VkPerformanceValueTypeINTEL = VkPerformanceValueTypeINTEL(2);
/// `3`  
pub const VK_PERFORMANCE_VALUE_TYPE_BOOL_INTEL: VkPerformanceValueTypeINTEL = VkPerformanceValueTypeINTEL(3);
/// `4`  
pub const VK_PERFORMANCE_VALUE_TYPE_STRING_INTEL: VkPerformanceValueTypeINTEL = VkPerformanceValueTypeINTEL(4);

impl_enum_display!(VkPerformanceValueTypeINTEL { VK_PERFORMANCE_VALUE_TYPE_UINT32_INTEL, VK_PERFORMANCE_VALUE_TYPE_UINT64_INTEL, VK_PERFORMANCE_VALUE_TYPE_FLOAT_INTEL, VK_PERFORMANCE_VALUE_TYPE_BOOL_INTEL, VK_PERFORMANCE_VALUE_TYPE_STRING_INTEL });

/// `VkPhysicalDevice` : `VkInstance`
#[repr(transparent)]
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkPhysicalDevice(pub *mut void);
from_into_transparent!(VkPhysicalDevice: *mut void);
from_into_transparent!(VkPhysicalDevice: u64);
impl_handle!(VkPhysicalDevice: VK_OBJECT_TYPE_PHYSICAL_DEVICE; SubHandle = VkInstance);

/// `VkPhysicalDevice16BitStorageFeatures`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDevice16BitStorageFeatures {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    /// 16-bit integer/floating-point variables supported in BufferBlock
    pub storageBuffer16BitAccess: VkBool32,
    /// 16-bit integer/floating-point variables supported in BufferBlock and Block
    pub uniformAndStorageBuffer16BitAccess: VkBool32,
    /// 16-bit integer/floating-point variables supported in PushConstant
    pub storagePushConstant16: VkBool32,
    /// 16-bit integer/floating-point variables supported in shader inputs and outputs
    pub storageInputOutput16: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDevice16BitStorageFeatures : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES);
impl_extends!(VkPhysicalDevice16BitStorageFeatures : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDevice16BitStorageFeatures`
pub type VkPhysicalDevice16BitStorageFeaturesKHR = VkPhysicalDevice16BitStorageFeatures;

/// `VkPhysicalDevice4444FormatsFeaturesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDevice4444FormatsFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub formatA4R4G4B4: VkBool32,
    pub formatA4B4G4R4: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDevice4444FormatsFeaturesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT);
impl_extends!(VkPhysicalDevice4444FormatsFeaturesEXT : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDevice8BitStorageFeatures`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDevice8BitStorageFeatures {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    /// 8-bit integer variables supported in StorageBuffer
    pub storageBuffer8BitAccess: VkBool32,
    /// 8-bit integer variables supported in StorageBuffer and Uniform
    pub uniformAndStorageBuffer8BitAccess: VkBool32,
    /// 8-bit integer variables supported in PushConstant
    pub storagePushConstant8: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDevice8BitStorageFeatures : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES);
impl_extends!(VkPhysicalDevice8BitStorageFeatures : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDevice8BitStorageFeatures`
pub type VkPhysicalDevice8BitStorageFeaturesKHR = VkPhysicalDevice8BitStorageFeatures;

/// `VkPhysicalDeviceASTCDecodeFeaturesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceASTCDecodeFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub decodeModeSharedExponent: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceASTCDecodeFeaturesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT);
impl_extends!(VkPhysicalDeviceASTCDecodeFeaturesEXT : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceAccelerationStructureFeaturesKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceAccelerationStructureFeaturesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub accelerationStructure: VkBool32,
    pub accelerationStructureCaptureReplay: VkBool32,
    pub accelerationStructureIndirectBuild: VkBool32,
    pub accelerationStructureHostCommands: VkBool32,
    pub descriptorBindingAccelerationStructureUpdateAfterBind: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceAccelerationStructureFeaturesKHR : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR);
impl_extends!(VkPhysicalDeviceAccelerationStructureFeaturesKHR : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceAccelerationStructurePropertiesKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceAccelerationStructurePropertiesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub maxGeometryCount: uint64_t,
    pub maxInstanceCount: uint64_t,
    pub maxPrimitiveCount: uint64_t,
    pub maxPerStageDescriptorAccelerationStructures: uint32_t,
    pub maxPerStageDescriptorUpdateAfterBindAccelerationStructures: uint32_t,
    pub maxDescriptorSetAccelerationStructures: uint32_t,
    pub maxDescriptorSetUpdateAfterBindAccelerationStructures: uint32_t,
    pub minAccelerationStructureScratchOffsetAlignment: uint32_t,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceAccelerationStructurePropertiesKHR : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR);
impl_extends!(VkPhysicalDeviceAccelerationStructurePropertiesKHR : VkPhysicalDeviceProperties2);

/// `VkPhysicalDeviceAddressBindingReportFeaturesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceAddressBindingReportFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub reportAddressBinding: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceAddressBindingReportFeaturesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT);
impl_extends!(VkPhysicalDeviceAddressBindingReportFeaturesEXT : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceAmigoProfilingFeaturesSEC`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceAmigoProfilingFeaturesSEC {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub amigoProfiling: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceAmigoProfilingFeaturesSEC : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC);
impl_extends!(VkPhysicalDeviceAmigoProfilingFeaturesSEC : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceAntiLagFeaturesAMD`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceAntiLagFeaturesAMD {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub antiLag: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceAntiLagFeaturesAMD : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD);
impl_extends!(VkPhysicalDeviceAntiLagFeaturesAMD : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub attachmentFeedbackLoopDynamicState: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT);
impl_extends!(VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub attachmentFeedbackLoopLayout: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT);
impl_extends!(VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub advancedBlendCoherentOperations: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT);
impl_extends!(VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub advancedBlendMaxColorAttachments: uint32_t,
    pub advancedBlendIndependentBlend: VkBool32,
    pub advancedBlendNonPremultipliedSrcColor: VkBool32,
    pub advancedBlendNonPremultipliedDstColor: VkBool32,
    pub advancedBlendCorrelatedOverlap: VkBool32,
    pub advancedBlendAllOperations: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT);
impl_extends!(VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT : VkPhysicalDeviceProperties2);

/// `VkPhysicalDeviceBorderColorSwizzleFeaturesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceBorderColorSwizzleFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub borderColorSwizzle: VkBool32,
    pub borderColorSwizzleFromImage: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceBorderColorSwizzleFeaturesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT);
impl_extends!(VkPhysicalDeviceBorderColorSwizzleFeaturesEXT : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceBufferDeviceAddressFeaturesEXT`
pub type VkPhysicalDeviceBufferAddressFeaturesEXT = VkPhysicalDeviceBufferDeviceAddressFeaturesEXT;

/// `VkPhysicalDeviceBufferDeviceAddressFeatures`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceBufferDeviceAddressFeatures {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub bufferDeviceAddress: VkBool32,
    pub bufferDeviceAddressCaptureReplay: VkBool32,
    pub bufferDeviceAddressMultiDevice: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceBufferDeviceAddressFeatures : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES);
impl_extends!(VkPhysicalDeviceBufferDeviceAddressFeatures : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceBufferDeviceAddressFeaturesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceBufferDeviceAddressFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub bufferDeviceAddress: VkBool32,
    pub bufferDeviceAddressCaptureReplay: VkBool32,
    pub bufferDeviceAddressMultiDevice: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceBufferDeviceAddressFeaturesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT);
impl_extends!(VkPhysicalDeviceBufferDeviceAddressFeaturesEXT : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceBufferDeviceAddressFeatures`
pub type VkPhysicalDeviceBufferDeviceAddressFeaturesKHR = VkPhysicalDeviceBufferDeviceAddressFeatures;

/// `VkPhysicalDeviceClusterAccelerationStructureFeaturesNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceClusterAccelerationStructureFeaturesNV {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub clusterAccelerationStructure: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceClusterAccelerationStructureFeaturesNV : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_FEATURES_NV);
impl_extends!(VkPhysicalDeviceClusterAccelerationStructureFeaturesNV : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceClusterAccelerationStructurePropertiesNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceClusterAccelerationStructurePropertiesNV {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub maxVerticesPerCluster: uint32_t,
    pub maxTrianglesPerCluster: uint32_t,
    pub clusterScratchByteAlignment: uint32_t,
    pub clusterByteAlignment: uint32_t,
    pub clusterTemplateByteAlignment: uint32_t,
    pub clusterBottomLevelByteAlignment: uint32_t,
    pub clusterTemplateBoundsByteAlignment: uint32_t,
    pub maxClusterGeometryIndex: uint32_t,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceClusterAccelerationStructurePropertiesNV : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_PROPERTIES_NV);
impl_extends!(VkPhysicalDeviceClusterAccelerationStructurePropertiesNV : VkPhysicalDeviceProperties2);

/// `VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub clustercullingShader: VkBool32,
    pub multiviewClusterCullingShader: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI);
impl_extends!(VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub maxWorkGroupCount: [uint32_t; 3 as usize],
    pub maxWorkGroupSize: [uint32_t; 3 as usize],
    pub maxOutputClusterCount: uint32_t,
    pub indirectBufferOffsetAlignment: VkDeviceSize,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI);
impl_extends!(VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI : VkPhysicalDeviceProperties2);

/// `VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub clusterShadingRate: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_VRS_FEATURES_HUAWEI);
impl_extends!(VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI : VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI);

/// `VkPhysicalDeviceCoherentMemoryFeaturesAMD`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceCoherentMemoryFeaturesAMD {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub deviceCoherentMemory: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceCoherentMemoryFeaturesAMD : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD);
impl_extends!(VkPhysicalDeviceCoherentMemoryFeaturesAMD : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceColorWriteEnableFeaturesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceColorWriteEnableFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub colorWriteEnable: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceColorWriteEnableFeaturesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT);
impl_extends!(VkPhysicalDeviceColorWriteEnableFeaturesEXT : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceCommandBufferInheritanceFeaturesNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceCommandBufferInheritanceFeaturesNV {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub commandBufferInheritance: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceCommandBufferInheritanceFeaturesNV : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV);
impl_extends!(VkPhysicalDeviceCommandBufferInheritanceFeaturesNV : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceComputeOccupancyPriorityFeaturesNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceComputeOccupancyPriorityFeaturesNV {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub computeOccupancyPriority: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceComputeOccupancyPriorityFeaturesNV : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_OCCUPANCY_PRIORITY_FEATURES_NV);
impl_extends!(VkPhysicalDeviceComputeOccupancyPriorityFeaturesNV : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub computeDerivativeGroupQuads: VkBool32,
    pub computeDerivativeGroupLinear: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR);
impl_extends!(VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR`
pub type VkPhysicalDeviceComputeShaderDerivativesFeaturesNV = VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR;

/// `VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub meshAndTaskShaderDerivatives: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_PROPERTIES_KHR);
impl_extends!(VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR : VkPhysicalDeviceProperties2);

/// `VkPhysicalDeviceConditionalRenderingFeaturesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceConditionalRenderingFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub conditionalRendering: VkBool32,
    pub inheritedConditionalRendering: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceConditionalRenderingFeaturesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT);
impl_extends!(VkPhysicalDeviceConditionalRenderingFeaturesEXT : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceConservativeRasterizationPropertiesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceConservativeRasterizationPropertiesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    /// The size in pixels the primitive is enlarged at each edge during conservative rasterization
    pub primitiveOverestimationSize: float,
    /// The maximum additional overestimation the client can specify in the pipeline state
    pub maxExtraPrimitiveOverestimationSize: float,
    /// The granularity of extra overestimation sizes the implementations supports between 0 and maxExtraOverestimationSize
    pub extraPrimitiveOverestimationSizeGranularity: float,
    /// true if the implementation supports conservative rasterization underestimation mode
    pub primitiveUnderestimation: VkBool32,
    /// true if conservative rasterization also applies to points and lines
    pub conservativePointAndLineRasterization: VkBool32,
    /// true if degenerate triangles (those with zero area after snap) are rasterized
    pub degenerateTrianglesRasterized: VkBool32,
    /// true if degenerate lines (those with zero length after snap) are rasterized
    pub degenerateLinesRasterized: VkBool32,
    /// true if the implementation supports the FullyCoveredEXT SPIR-V builtin fragment shader input variable
    pub fullyCoveredFragmentShaderInputVariable: VkBool32,
    /// true if the implementation supports both conservative rasterization and post depth coverage sample coverage mask
    pub conservativeRasterizationPostDepthCoverage: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceConservativeRasterizationPropertiesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT);
impl_extends!(VkPhysicalDeviceConservativeRasterizationPropertiesEXT : VkPhysicalDeviceProperties2);

/// `VkPhysicalDeviceCooperativeMatrix2FeaturesNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceCooperativeMatrix2FeaturesNV {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub cooperativeMatrixWorkgroupScope: VkBool32,
    pub cooperativeMatrixFlexibleDimensions: VkBool32,
    pub cooperativeMatrixReductions: VkBool32,
    pub cooperativeMatrixConversions: VkBool32,
    pub cooperativeMatrixPerElementOperations: VkBool32,
    pub cooperativeMatrixTensorAddressing: VkBool32,
    pub cooperativeMatrixBlockLoads: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceCooperativeMatrix2FeaturesNV : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV);
impl_extends!(VkPhysicalDeviceCooperativeMatrix2FeaturesNV : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceCooperativeMatrix2PropertiesNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceCooperativeMatrix2PropertiesNV {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub cooperativeMatrixWorkgroupScopeMaxWorkgroupSize: uint32_t,
    pub cooperativeMatrixFlexibleDimensionsMaxDimension: uint32_t,
    pub cooperativeMatrixWorkgroupScopeReservedSharedMemory: uint32_t,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceCooperativeMatrix2PropertiesNV : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_PROPERTIES_NV);
impl_extends!(VkPhysicalDeviceCooperativeMatrix2PropertiesNV : VkPhysicalDeviceProperties2);

/// `VkPhysicalDeviceCooperativeMatrixConversionFeaturesQCOM`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceCooperativeMatrixConversionFeaturesQCOM {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub cooperativeMatrixConversion: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceCooperativeMatrixConversionFeaturesQCOM : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_CONVERSION_FEATURES_QCOM);
impl_extends!(VkPhysicalDeviceCooperativeMatrixConversionFeaturesQCOM : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceCooperativeMatrixFeaturesKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceCooperativeMatrixFeaturesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub cooperativeMatrix: VkBool32,
    pub cooperativeMatrixRobustBufferAccess: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceCooperativeMatrixFeaturesKHR : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR);
impl_extends!(VkPhysicalDeviceCooperativeMatrixFeaturesKHR : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceCooperativeMatrixFeaturesNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceCooperativeMatrixFeaturesNV {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub cooperativeMatrix: VkBool32,
    pub cooperativeMatrixRobustBufferAccess: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceCooperativeMatrixFeaturesNV : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV);
impl_extends!(VkPhysicalDeviceCooperativeMatrixFeaturesNV : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceCooperativeMatrixPropertiesKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceCooperativeMatrixPropertiesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub cooperativeMatrixSupportedStages: VkShaderStageFlags,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceCooperativeMatrixPropertiesKHR : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR);
impl_extends!(VkPhysicalDeviceCooperativeMatrixPropertiesKHR : VkPhysicalDeviceProperties2);

/// `VkPhysicalDeviceCooperativeMatrixPropertiesNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceCooperativeMatrixPropertiesNV {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub cooperativeMatrixSupportedStages: VkShaderStageFlags,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceCooperativeMatrixPropertiesNV : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV);
impl_extends!(VkPhysicalDeviceCooperativeMatrixPropertiesNV : VkPhysicalDeviceProperties2);

/// `VkPhysicalDeviceCooperativeVectorFeaturesNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceCooperativeVectorFeaturesNV {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub cooperativeVector: VkBool32,
    pub cooperativeVectorTraining: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceCooperativeVectorFeaturesNV : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_FEATURES_NV);
impl_extends!(VkPhysicalDeviceCooperativeVectorFeaturesNV : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceCooperativeVectorPropertiesNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceCooperativeVectorPropertiesNV {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub cooperativeVectorSupportedStages: VkShaderStageFlags,
    pub cooperativeVectorTrainingFloat16Accumulation: VkBool32,
    pub cooperativeVectorTrainingFloat32Accumulation: VkBool32,
    pub maxCooperativeVectorComponents: uint32_t,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceCooperativeVectorPropertiesNV : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_PROPERTIES_NV);
impl_extends!(VkPhysicalDeviceCooperativeVectorPropertiesNV : VkPhysicalDeviceProperties2);

/// `VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub indirectMemoryCopy: VkBool32,
    pub indirectMemoryToImageCopy: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_KHR);
impl_extends!(VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceCopyMemoryIndirectFeaturesNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceCopyMemoryIndirectFeaturesNV {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub indirectCopy: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceCopyMemoryIndirectFeaturesNV : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV);
impl_extends!(VkPhysicalDeviceCopyMemoryIndirectFeaturesNV : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    /// Bitmask of VkQueueFlagBits indicating the family of queues that support indirect copy
    pub supportedQueues: VkQueueFlags,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_KHR);
impl_extends!(VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR : VkPhysicalDeviceProperties2);

/// `VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR`
pub type VkPhysicalDeviceCopyMemoryIndirectPropertiesNV = VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR;

/// `VkPhysicalDeviceCornerSampledImageFeaturesNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceCornerSampledImageFeaturesNV {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub cornerSampledImage: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceCornerSampledImageFeaturesNV : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV);
impl_extends!(VkPhysicalDeviceCornerSampledImageFeaturesNV : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceCoverageReductionModeFeaturesNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceCoverageReductionModeFeaturesNV {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub coverageReductionMode: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceCoverageReductionModeFeaturesNV : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV);
impl_extends!(VkPhysicalDeviceCoverageReductionModeFeaturesNV : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceCubicClampFeaturesQCOM`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceCubicClampFeaturesQCOM {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub cubicRangeClamp: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceCubicClampFeaturesQCOM : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM);
impl_extends!(VkPhysicalDeviceCubicClampFeaturesQCOM : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceCubicWeightsFeaturesQCOM`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceCubicWeightsFeaturesQCOM {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub selectableCubicWeights: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceCubicWeightsFeaturesQCOM : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES_QCOM);
impl_extends!(VkPhysicalDeviceCubicWeightsFeaturesQCOM : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceCudaKernelLaunchFeaturesNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceCudaKernelLaunchFeaturesNV {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub cudaKernelLaunchFeatures: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceCudaKernelLaunchFeaturesNV : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_FEATURES_NV);
impl_extends!(VkPhysicalDeviceCudaKernelLaunchFeaturesNV : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceCudaKernelLaunchPropertiesNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceCudaKernelLaunchPropertiesNV {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub computeCapabilityMinor: uint32_t,
    pub computeCapabilityMajor: uint32_t,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceCudaKernelLaunchPropertiesNV : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_PROPERTIES_NV);
impl_extends!(VkPhysicalDeviceCudaKernelLaunchPropertiesNV : VkPhysicalDeviceProperties2);

/// `VkPhysicalDeviceCustomBorderColorFeaturesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceCustomBorderColorFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub customBorderColors: VkBool32,
    pub customBorderColorWithoutFormat: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceCustomBorderColorFeaturesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT);
impl_extends!(VkPhysicalDeviceCustomBorderColorFeaturesEXT : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceCustomBorderColorPropertiesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceCustomBorderColorPropertiesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub maxCustomBorderColorSamplers: uint32_t,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceCustomBorderColorPropertiesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT);
impl_extends!(VkPhysicalDeviceCustomBorderColorPropertiesEXT : VkPhysicalDeviceProperties2);

/// `VkPhysicalDeviceCustomResolveFeaturesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceCustomResolveFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub customResolve: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceCustomResolveFeaturesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_RESOLVE_FEATURES_EXT);
impl_extends!(VkPhysicalDeviceCustomResolveFeaturesEXT : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceDataGraphFeaturesARM`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceDataGraphFeaturesARM {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub dataGraph: VkBool32,
    pub dataGraphUpdateAfterBind: VkBool32,
    pub dataGraphSpecializationConstants: VkBool32,
    pub dataGraphDescriptorBuffer: VkBool32,
    pub dataGraphShaderModule: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceDataGraphFeaturesARM : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_FEATURES_ARM);
impl_extends!(VkPhysicalDeviceDataGraphFeaturesARM : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceDataGraphModelFeaturesQCOM`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceDataGraphModelFeaturesQCOM {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub dataGraphModel: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceDataGraphModelFeaturesQCOM : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_MODEL_FEATURES_QCOM);
impl_extends!(VkPhysicalDeviceDataGraphModelFeaturesQCOM : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceDataGraphOperationSupportARM`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceDataGraphOperationSupportARM {
    pub operationType: VkPhysicalDeviceDataGraphOperationTypeARM,
    pub name: [c_char; VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM as usize],
    pub version: uint32_t,
}
impl_default_zeroed!(VkPhysicalDeviceDataGraphOperationSupportARM);

from_into_transparent!(VkPhysicalDeviceDataGraphOperationTypeARM: i32);
/// `VkPhysicalDeviceDataGraphOperationTypeARM`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkPhysicalDeviceDataGraphOperationTypeARM(pub i32);

/// `0`  
pub const VK_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_TYPE_SPIRV_EXTENDED_INSTRUCTION_SET_ARM: VkPhysicalDeviceDataGraphOperationTypeARM = VkPhysicalDeviceDataGraphOperationTypeARM(0);
/// `1000629000`  
pub const VK_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_TYPE_NEURAL_MODEL_QCOM: VkPhysicalDeviceDataGraphOperationTypeARM = VkPhysicalDeviceDataGraphOperationTypeARM(1000629000);
/// `1000629001`  
pub const VK_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_TYPE_BUILTIN_MODEL_QCOM: VkPhysicalDeviceDataGraphOperationTypeARM = VkPhysicalDeviceDataGraphOperationTypeARM(1000629001);

impl_enum_display!(VkPhysicalDeviceDataGraphOperationTypeARM { VK_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_TYPE_SPIRV_EXTENDED_INSTRUCTION_SET_ARM, VK_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_TYPE_NEURAL_MODEL_QCOM, VK_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_TYPE_BUILTIN_MODEL_QCOM });

/// `VkPhysicalDeviceDataGraphProcessingEngineARM`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceDataGraphProcessingEngineARM {
    pub r#type: VkPhysicalDeviceDataGraphProcessingEngineTypeARM,
    pub isForeign: VkBool32,
}
impl_default_zeroed!(VkPhysicalDeviceDataGraphProcessingEngineARM);

from_into_transparent!(VkPhysicalDeviceDataGraphProcessingEngineTypeARM: i32);
/// `VkPhysicalDeviceDataGraphProcessingEngineTypeARM`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkPhysicalDeviceDataGraphProcessingEngineTypeARM(pub i32);

/// `0`  
pub const VK_PHYSICAL_DEVICE_DATA_GRAPH_PROCESSING_ENGINE_TYPE_DEFAULT_ARM: VkPhysicalDeviceDataGraphProcessingEngineTypeARM = VkPhysicalDeviceDataGraphProcessingEngineTypeARM(0);
/// `1000629000`  
pub const VK_PHYSICAL_DEVICE_DATA_GRAPH_PROCESSING_ENGINE_TYPE_NEURAL_QCOM: VkPhysicalDeviceDataGraphProcessingEngineTypeARM = VkPhysicalDeviceDataGraphProcessingEngineTypeARM(1000629000);
/// `1000629001`  
pub const VK_PHYSICAL_DEVICE_DATA_GRAPH_PROCESSING_ENGINE_TYPE_COMPUTE_QCOM: VkPhysicalDeviceDataGraphProcessingEngineTypeARM = VkPhysicalDeviceDataGraphProcessingEngineTypeARM(1000629001);

impl_enum_display!(VkPhysicalDeviceDataGraphProcessingEngineTypeARM { VK_PHYSICAL_DEVICE_DATA_GRAPH_PROCESSING_ENGINE_TYPE_DEFAULT_ARM, VK_PHYSICAL_DEVICE_DATA_GRAPH_PROCESSING_ENGINE_TYPE_NEURAL_QCOM, VK_PHYSICAL_DEVICE_DATA_GRAPH_PROCESSING_ENGINE_TYPE_COMPUTE_QCOM });

/// `VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub dedicatedAllocationImageAliasing: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV);
impl_extends!(VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub denseGeometryFormat: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DENSE_GEOMETRY_FORMAT_FEATURES_AMDX);
impl_extends!(VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceDepthBiasControlFeaturesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceDepthBiasControlFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub depthBiasControl: VkBool32,
    pub leastRepresentableValueForceUnormRepresentation: VkBool32,
    pub floatRepresentation: VkBool32,
    pub depthBiasExact: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceDepthBiasControlFeaturesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT);
impl_extends!(VkPhysicalDeviceDepthBiasControlFeaturesEXT : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceDepthClampControlFeaturesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceDepthClampControlFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub depthClampControl: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceDepthClampControlFeaturesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT);
impl_extends!(VkPhysicalDeviceDepthClampControlFeaturesEXT : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceDepthClampZeroOneFeaturesKHR`
pub type VkPhysicalDeviceDepthClampZeroOneFeaturesEXT = VkPhysicalDeviceDepthClampZeroOneFeaturesKHR;

/// `VkPhysicalDeviceDepthClampZeroOneFeaturesKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceDepthClampZeroOneFeaturesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub depthClampZeroOne: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceDepthClampZeroOneFeaturesKHR : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR);
impl_extends!(VkPhysicalDeviceDepthClampZeroOneFeaturesKHR : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceDepthClipControlFeaturesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceDepthClipControlFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub depthClipControl: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceDepthClipControlFeaturesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT);
impl_extends!(VkPhysicalDeviceDepthClipControlFeaturesEXT : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceDepthClipEnableFeaturesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceDepthClipEnableFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub depthClipEnable: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceDepthClipEnableFeaturesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT);
impl_extends!(VkPhysicalDeviceDepthClipEnableFeaturesEXT : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceDepthStencilResolveProperties`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceDepthStencilResolveProperties {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    /// supported depth resolve modes
    pub supportedDepthResolveModes: VkResolveModeFlags,
    /// supported stencil resolve modes
    pub supportedStencilResolveModes: VkResolveModeFlags,
    /// depth and stencil resolve modes can be set independently if one of them is none
    pub independentResolveNone: VkBool32,
    /// depth and stencil resolve modes can be set independently
    pub independentResolve: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceDepthStencilResolveProperties : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES);
impl_extends!(VkPhysicalDeviceDepthStencilResolveProperties : VkPhysicalDeviceProperties2);

/// `VkPhysicalDeviceDepthStencilResolveProperties`
pub type VkPhysicalDeviceDepthStencilResolvePropertiesKHR = VkPhysicalDeviceDepthStencilResolveProperties;

/// `VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub combinedImageSamplerDensityMapDescriptorSize: size_t,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT);
impl_extends!(VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT : VkPhysicalDeviceProperties2);

/// `VkPhysicalDeviceDescriptorBufferFeaturesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceDescriptorBufferFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub descriptorBuffer: VkBool32,
    pub descriptorBufferCaptureReplay: VkBool32,
    pub descriptorBufferImageLayoutIgnored: VkBool32,
    pub descriptorBufferPushDescriptors: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceDescriptorBufferFeaturesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT);
impl_extends!(VkPhysicalDeviceDescriptorBufferFeaturesEXT : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceDescriptorBufferPropertiesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceDescriptorBufferPropertiesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub combinedImageSamplerDescriptorSingleArray: VkBool32,
    pub bufferlessPushDescriptors: VkBool32,
    pub allowSamplerImageViewPostSubmitCreation: VkBool32,
    pub descriptorBufferOffsetAlignment: VkDeviceSize,
    pub maxDescriptorBufferBindings: uint32_t,
    pub maxResourceDescriptorBufferBindings: uint32_t,
    pub maxSamplerDescriptorBufferBindings: uint32_t,
    pub maxEmbeddedImmutableSamplerBindings: uint32_t,
    pub maxEmbeddedImmutableSamplers: uint32_t,
    pub bufferCaptureReplayDescriptorDataSize: size_t,
    pub imageCaptureReplayDescriptorDataSize: size_t,
    pub imageViewCaptureReplayDescriptorDataSize: size_t,
    pub samplerCaptureReplayDescriptorDataSize: size_t,
    pub accelerationStructureCaptureReplayDescriptorDataSize: size_t,
    pub samplerDescriptorSize: size_t,
    pub combinedImageSamplerDescriptorSize: size_t,
    pub sampledImageDescriptorSize: size_t,
    pub storageImageDescriptorSize: size_t,
    pub uniformTexelBufferDescriptorSize: size_t,
    pub robustUniformTexelBufferDescriptorSize: size_t,
    pub storageTexelBufferDescriptorSize: size_t,
    pub robustStorageTexelBufferDescriptorSize: size_t,
    pub uniformBufferDescriptorSize: size_t,
    pub robustUniformBufferDescriptorSize: size_t,
    pub storageBufferDescriptorSize: size_t,
    pub robustStorageBufferDescriptorSize: size_t,
    pub inputAttachmentDescriptorSize: size_t,
    pub accelerationStructureDescriptorSize: size_t,
    pub maxSamplerDescriptorBufferRange: VkDeviceSize,
    pub maxResourceDescriptorBufferRange: VkDeviceSize,
    pub samplerDescriptorBufferAddressSpaceSize: VkDeviceSize,
    pub resourceDescriptorBufferAddressSpaceSize: VkDeviceSize,
    pub descriptorBufferAddressSpaceSize: VkDeviceSize,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceDescriptorBufferPropertiesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT);
impl_extends!(VkPhysicalDeviceDescriptorBufferPropertiesEXT : VkPhysicalDeviceProperties2);

/// `VkPhysicalDeviceDescriptorBufferTensorFeaturesARM`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceDescriptorBufferTensorFeaturesARM {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub descriptorBufferTensorDescriptors: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceDescriptorBufferTensorFeaturesARM : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_FEATURES_ARM);
impl_extends!(VkPhysicalDeviceDescriptorBufferTensorFeaturesARM : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceDescriptorBufferTensorPropertiesARM`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceDescriptorBufferTensorPropertiesARM {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub tensorCaptureReplayDescriptorDataSize: size_t,
    pub tensorViewCaptureReplayDescriptorDataSize: size_t,
    pub tensorDescriptorSize: size_t,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceDescriptorBufferTensorPropertiesARM : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_PROPERTIES_ARM);
impl_extends!(VkPhysicalDeviceDescriptorBufferTensorPropertiesARM : VkPhysicalDeviceProperties2);

/// `VkPhysicalDeviceDescriptorHeapFeaturesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceDescriptorHeapFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub descriptorHeap: VkBool32,
    pub descriptorHeapCaptureReplay: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceDescriptorHeapFeaturesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_FEATURES_EXT);
impl_extends!(VkPhysicalDeviceDescriptorHeapFeaturesEXT : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceDescriptorHeapPropertiesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceDescriptorHeapPropertiesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub samplerHeapAlignment: VkDeviceSize,
    pub resourceHeapAlignment: VkDeviceSize,
    pub maxSamplerHeapSize: VkDeviceSize,
    pub maxResourceHeapSize: VkDeviceSize,
    pub minSamplerHeapReservedRange: VkDeviceSize,
    pub minSamplerHeapReservedRangeWithEmbedded: VkDeviceSize,
    pub minResourceHeapReservedRange: VkDeviceSize,
    pub samplerDescriptorSize: VkDeviceSize,
    pub imageDescriptorSize: VkDeviceSize,
    pub bufferDescriptorSize: VkDeviceSize,
    pub samplerDescriptorAlignment: VkDeviceSize,
    pub imageDescriptorAlignment: VkDeviceSize,
    pub bufferDescriptorAlignment: VkDeviceSize,
    pub maxPushDataSize: VkDeviceSize,
    pub imageCaptureReplayOpaqueDataSize: size_t,
    pub maxDescriptorHeapEmbeddedSamplers: uint32_t,
    pub samplerYcbcrConversionCount: uint32_t,
    pub sparseDescriptorHeaps: VkBool32,
    pub protectedDescriptorHeaps: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceDescriptorHeapPropertiesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_PROPERTIES_EXT);
impl_extends!(VkPhysicalDeviceDescriptorHeapPropertiesEXT : VkPhysicalDeviceProperties2);

/// `VkPhysicalDeviceDescriptorHeapTensorPropertiesARM`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceDescriptorHeapTensorPropertiesARM {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub tensorDescriptorSize: VkDeviceSize,
    pub tensorDescriptorAlignment: VkDeviceSize,
    pub tensorCaptureReplayOpaqueDataSize: size_t,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceDescriptorHeapTensorPropertiesARM : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_TENSOR_PROPERTIES_ARM);
impl_extends!(VkPhysicalDeviceDescriptorHeapTensorPropertiesARM : VkPhysicalDeviceProperties2);

/// `VkPhysicalDeviceDescriptorIndexingFeatures`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceDescriptorIndexingFeatures {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub shaderInputAttachmentArrayDynamicIndexing: VkBool32,
    pub shaderUniformTexelBufferArrayDynamicIndexing: VkBool32,
    pub shaderStorageTexelBufferArrayDynamicIndexing: VkBool32,
    pub shaderUniformBufferArrayNonUniformIndexing: VkBool32,
    pub shaderSampledImageArrayNonUniformIndexing: VkBool32,
    pub shaderStorageBufferArrayNonUniformIndexing: VkBool32,
    pub shaderStorageImageArrayNonUniformIndexing: VkBool32,
    pub shaderInputAttachmentArrayNonUniformIndexing: VkBool32,
    pub shaderUniformTexelBufferArrayNonUniformIndexing: VkBool32,
    pub shaderStorageTexelBufferArrayNonUniformIndexing: VkBool32,
    pub descriptorBindingUniformBufferUpdateAfterBind: VkBool32,
    pub descriptorBindingSampledImageUpdateAfterBind: VkBool32,
    pub descriptorBindingStorageImageUpdateAfterBind: VkBool32,
    pub descriptorBindingStorageBufferUpdateAfterBind: VkBool32,
    pub descriptorBindingUniformTexelBufferUpdateAfterBind: VkBool32,
    pub descriptorBindingStorageTexelBufferUpdateAfterBind: VkBool32,
    pub descriptorBindingUpdateUnusedWhilePending: VkBool32,
    pub descriptorBindingPartiallyBound: VkBool32,
    pub descriptorBindingVariableDescriptorCount: VkBool32,
    pub runtimeDescriptorArray: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceDescriptorIndexingFeatures : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES);
impl_extends!(VkPhysicalDeviceDescriptorIndexingFeatures : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceDescriptorIndexingFeatures`
pub type VkPhysicalDeviceDescriptorIndexingFeaturesEXT = VkPhysicalDeviceDescriptorIndexingFeatures;

/// `VkPhysicalDeviceDescriptorIndexingProperties`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceDescriptorIndexingProperties {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub maxUpdateAfterBindDescriptorsInAllPools: uint32_t,
    pub shaderUniformBufferArrayNonUniformIndexingNative: VkBool32,
    pub shaderSampledImageArrayNonUniformIndexingNative: VkBool32,
    pub shaderStorageBufferArrayNonUniformIndexingNative: VkBool32,
    pub shaderStorageImageArrayNonUniformIndexingNative: VkBool32,
    pub shaderInputAttachmentArrayNonUniformIndexingNative: VkBool32,
    pub robustBufferAccessUpdateAfterBind: VkBool32,
    pub quadDivergentImplicitLod: VkBool32,
    pub maxPerStageDescriptorUpdateAfterBindSamplers: uint32_t,
    pub maxPerStageDescriptorUpdateAfterBindUniformBuffers: uint32_t,
    pub maxPerStageDescriptorUpdateAfterBindStorageBuffers: uint32_t,
    pub maxPerStageDescriptorUpdateAfterBindSampledImages: uint32_t,
    pub maxPerStageDescriptorUpdateAfterBindStorageImages: uint32_t,
    pub maxPerStageDescriptorUpdateAfterBindInputAttachments: uint32_t,
    pub maxPerStageUpdateAfterBindResources: uint32_t,
    pub maxDescriptorSetUpdateAfterBindSamplers: uint32_t,
    pub maxDescriptorSetUpdateAfterBindUniformBuffers: uint32_t,
    pub maxDescriptorSetUpdateAfterBindUniformBuffersDynamic: uint32_t,
    pub maxDescriptorSetUpdateAfterBindStorageBuffers: uint32_t,
    pub maxDescriptorSetUpdateAfterBindStorageBuffersDynamic: uint32_t,
    pub maxDescriptorSetUpdateAfterBindSampledImages: uint32_t,
    pub maxDescriptorSetUpdateAfterBindStorageImages: uint32_t,
    pub maxDescriptorSetUpdateAfterBindInputAttachments: uint32_t,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceDescriptorIndexingProperties : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES);
impl_extends!(VkPhysicalDeviceDescriptorIndexingProperties : VkPhysicalDeviceProperties2);

/// `VkPhysicalDeviceDescriptorIndexingProperties`
pub type VkPhysicalDeviceDescriptorIndexingPropertiesEXT = VkPhysicalDeviceDescriptorIndexingProperties;

/// `VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub descriptorPoolOverallocation: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV);
impl_extends!(VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub descriptorSetHostMapping: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE);
impl_extends!(VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub deviceGeneratedCompute: VkBool32,
    pub deviceGeneratedComputePipelines: VkBool32,
    pub deviceGeneratedComputeCaptureReplay: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV);
impl_extends!(VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub deviceGeneratedCommands: VkBool32,
    pub dynamicGeneratedPipelineLayout: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT);
impl_extends!(VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub deviceGeneratedCommands: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV);
impl_extends!(VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub maxIndirectPipelineCount: uint32_t,
    pub maxIndirectShaderObjectCount: uint32_t,
    pub maxIndirectSequenceCount: uint32_t,
    pub maxIndirectCommandsTokenCount: uint32_t,
    pub maxIndirectCommandsTokenOffset: uint32_t,
    pub maxIndirectCommandsIndirectStride: uint32_t,
    pub supportedIndirectCommandsInputModes: VkIndirectCommandsInputModeFlagsEXT,
    pub supportedIndirectCommandsShaderStages: VkShaderStageFlags,
    pub supportedIndirectCommandsShaderStagesPipelineBinding: VkShaderStageFlags,
    pub supportedIndirectCommandsShaderStagesShaderBinding: VkShaderStageFlags,
    pub deviceGeneratedCommandsTransformFeedback: VkBool32,
    pub deviceGeneratedCommandsMultiDrawIndirectCount: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT);
impl_extends!(VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT : VkPhysicalDeviceProperties2);

/// `VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub maxGraphicsShaderGroupCount: uint32_t,
    pub maxIndirectSequenceCount: uint32_t,
    pub maxIndirectCommandsTokenCount: uint32_t,
    pub maxIndirectCommandsStreamCount: uint32_t,
    pub maxIndirectCommandsTokenOffset: uint32_t,
    pub maxIndirectCommandsStreamStride: uint32_t,
    pub minSequencesCountBufferOffsetAlignment: uint32_t,
    pub minSequencesIndexBufferOffsetAlignment: uint32_t,
    pub minIndirectCommandsBufferOffsetAlignment: uint32_t,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV);
impl_extends!(VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV : VkPhysicalDeviceProperties2);

/// `VkPhysicalDeviceDeviceMemoryReportFeaturesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceDeviceMemoryReportFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub deviceMemoryReport: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceDeviceMemoryReportFeaturesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT);
impl_extends!(VkPhysicalDeviceDeviceMemoryReportFeaturesEXT : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceDiagnosticsConfigFeaturesNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceDiagnosticsConfigFeaturesNV {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub diagnosticsConfig: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceDiagnosticsConfigFeaturesNV : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV);
impl_extends!(VkPhysicalDeviceDiagnosticsConfigFeaturesNV : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceDiscardRectanglePropertiesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceDiscardRectanglePropertiesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    /// max number of active discard rectangles
    pub maxDiscardRectangles: uint32_t,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceDiscardRectanglePropertiesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT);
impl_extends!(VkPhysicalDeviceDiscardRectanglePropertiesEXT : VkPhysicalDeviceProperties2);

/// `VkPhysicalDeviceDisplacementMicromapFeaturesNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceDisplacementMicromapFeaturesNV {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub displacementMicromap: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceDisplacementMicromapFeaturesNV : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_FEATURES_NV);
impl_extends!(VkPhysicalDeviceDisplacementMicromapFeaturesNV : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceDisplacementMicromapPropertiesNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceDisplacementMicromapPropertiesNV {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub maxDisplacementMicromapSubdivisionLevel: uint32_t,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceDisplacementMicromapPropertiesNV : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_PROPERTIES_NV);
impl_extends!(VkPhysicalDeviceDisplacementMicromapPropertiesNV : VkPhysicalDeviceProperties2);

/// `VkPhysicalDeviceDriverProperties`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceDriverProperties {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub driverID: VkDriverId,
    pub driverName: [c_char; VK_MAX_DRIVER_NAME_SIZE as usize],
    pub driverInfo: [c_char; VK_MAX_DRIVER_INFO_SIZE as usize],
    pub conformanceVersion: VkConformanceVersion,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceDriverProperties : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES);
impl_extends!(VkPhysicalDeviceDriverProperties : VkPhysicalDeviceProperties2);

/// `VkPhysicalDeviceDriverProperties`
pub type VkPhysicalDeviceDriverPropertiesKHR = VkPhysicalDeviceDriverProperties;

/// `VkPhysicalDeviceDrmPropertiesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceDrmPropertiesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub hasPrimary: VkBool32,
    pub hasRender: VkBool32,
    pub primaryMajor: int64_t,
    pub primaryMinor: int64_t,
    pub renderMajor: int64_t,
    pub renderMinor: int64_t,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceDrmPropertiesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT);
impl_extends!(VkPhysicalDeviceDrmPropertiesEXT : VkPhysicalDeviceProperties2);

/// `VkPhysicalDeviceDynamicRenderingFeatures`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceDynamicRenderingFeatures {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub dynamicRendering: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceDynamicRenderingFeatures : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES);
impl_extends!(VkPhysicalDeviceDynamicRenderingFeatures : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceDynamicRenderingFeatures`
pub type VkPhysicalDeviceDynamicRenderingFeaturesKHR = VkPhysicalDeviceDynamicRenderingFeatures;

/// `VkPhysicalDeviceDynamicRenderingLocalReadFeatures`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceDynamicRenderingLocalReadFeatures {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub dynamicRenderingLocalRead: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceDynamicRenderingLocalReadFeatures : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES);
impl_extends!(VkPhysicalDeviceDynamicRenderingLocalReadFeatures : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceDynamicRenderingLocalReadFeatures`
pub type VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR = VkPhysicalDeviceDynamicRenderingLocalReadFeatures;

/// `VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub dynamicRenderingUnusedAttachments: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT);
impl_extends!(VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceExclusiveScissorFeaturesNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceExclusiveScissorFeaturesNV {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub exclusiveScissor: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceExclusiveScissorFeaturesNV : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV);
impl_extends!(VkPhysicalDeviceExclusiveScissorFeaturesNV : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceExtendedDynamicState2FeaturesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceExtendedDynamicState2FeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub extendedDynamicState2: VkBool32,
    pub extendedDynamicState2LogicOp: VkBool32,
    pub extendedDynamicState2PatchControlPoints: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceExtendedDynamicState2FeaturesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT);
impl_extends!(VkPhysicalDeviceExtendedDynamicState2FeaturesEXT : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceExtendedDynamicState3FeaturesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceExtendedDynamicState3FeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub extendedDynamicState3TessellationDomainOrigin: VkBool32,
    pub extendedDynamicState3DepthClampEnable: VkBool32,
    pub extendedDynamicState3PolygonMode: VkBool32,
    pub extendedDynamicState3RasterizationSamples: VkBool32,
    pub extendedDynamicState3SampleMask: VkBool32,
    pub extendedDynamicState3AlphaToCoverageEnable: VkBool32,
    pub extendedDynamicState3AlphaToOneEnable: VkBool32,
    pub extendedDynamicState3LogicOpEnable: VkBool32,
    pub extendedDynamicState3ColorBlendEnable: VkBool32,
    pub extendedDynamicState3ColorBlendEquation: VkBool32,
    pub extendedDynamicState3ColorWriteMask: VkBool32,
    pub extendedDynamicState3RasterizationStream: VkBool32,
    pub extendedDynamicState3ConservativeRasterizationMode: VkBool32,
    pub extendedDynamicState3ExtraPrimitiveOverestimationSize: VkBool32,
    pub extendedDynamicState3DepthClipEnable: VkBool32,
    pub extendedDynamicState3SampleLocationsEnable: VkBool32,
    pub extendedDynamicState3ColorBlendAdvanced: VkBool32,
    pub extendedDynamicState3ProvokingVertexMode: VkBool32,
    pub extendedDynamicState3LineRasterizationMode: VkBool32,
    pub extendedDynamicState3LineStippleEnable: VkBool32,
    pub extendedDynamicState3DepthClipNegativeOneToOne: VkBool32,
    pub extendedDynamicState3ViewportWScalingEnable: VkBool32,
    pub extendedDynamicState3ViewportSwizzle: VkBool32,
    pub extendedDynamicState3CoverageToColorEnable: VkBool32,
    pub extendedDynamicState3CoverageToColorLocation: VkBool32,
    pub extendedDynamicState3CoverageModulationMode: VkBool32,
    pub extendedDynamicState3CoverageModulationTableEnable: VkBool32,
    pub extendedDynamicState3CoverageModulationTable: VkBool32,
    pub extendedDynamicState3CoverageReductionMode: VkBool32,
    pub extendedDynamicState3RepresentativeFragmentTestEnable: VkBool32,
    pub extendedDynamicState3ShadingRateImageEnable: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceExtendedDynamicState3FeaturesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT);
impl_extends!(VkPhysicalDeviceExtendedDynamicState3FeaturesEXT : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceExtendedDynamicState3PropertiesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceExtendedDynamicState3PropertiesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub dynamicPrimitiveTopologyUnrestricted: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceExtendedDynamicState3PropertiesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT);
impl_extends!(VkPhysicalDeviceExtendedDynamicState3PropertiesEXT : VkPhysicalDeviceProperties2);

/// `VkPhysicalDeviceExtendedDynamicStateFeaturesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceExtendedDynamicStateFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub extendedDynamicState: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceExtendedDynamicStateFeaturesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT);
impl_extends!(VkPhysicalDeviceExtendedDynamicStateFeaturesEXT : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub extendedSparseAddressSpace: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV);
impl_extends!(VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    /// Total address space available for extended sparse allocations (bytes)
    pub extendedSparseAddressSpaceSize: VkDeviceSize,
    /// Bitfield of which image usages are supported for extended sparse allocations
    pub extendedSparseImageUsageFlags: VkImageUsageFlags,
    /// Bitfield of which buffer usages are supported for extended sparse allocations
    pub extendedSparseBufferUsageFlags: VkBufferUsageFlags,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_PROPERTIES_NV);
impl_extends!(VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV : VkPhysicalDeviceProperties2);

/// `VkPhysicalDeviceExternalBufferInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceExternalBufferInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub flags: VkBufferCreateFlags,
    pub usage: VkBufferUsageFlags,
    pub handleType: VkExternalMemoryHandleTypeFlags,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceExternalBufferInfo : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO);

/// `VkPhysicalDeviceExternalBufferInfo`
pub type VkPhysicalDeviceExternalBufferInfoKHR = VkPhysicalDeviceExternalBufferInfo;

/// `VkPhysicalDeviceExternalComputeQueuePropertiesNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceExternalComputeQueuePropertiesNV {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub externalDataSize: uint32_t,
    pub maxExternalQueues: uint32_t,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceExternalComputeQueuePropertiesNV : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_COMPUTE_QUEUE_PROPERTIES_NV);
impl_extends!(VkPhysicalDeviceExternalComputeQueuePropertiesNV : VkPhysicalDeviceProperties2);

/// `VkPhysicalDeviceExternalFenceInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceExternalFenceInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub handleType: VkExternalFenceHandleTypeFlags,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceExternalFenceInfo : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO);

/// `VkPhysicalDeviceExternalFenceInfo`
pub type VkPhysicalDeviceExternalFenceInfoKHR = VkPhysicalDeviceExternalFenceInfo;

/// `VkPhysicalDeviceExternalFormatResolveFeaturesANDROID`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceExternalFormatResolveFeaturesANDROID {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub externalFormatResolve: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceExternalFormatResolveFeaturesANDROID : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_FEATURES_ANDROID);
impl_extends!(VkPhysicalDeviceExternalFormatResolveFeaturesANDROID : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceExternalFormatResolvePropertiesANDROID`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceExternalFormatResolvePropertiesANDROID {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub nullColorAttachmentWithExternalFormatResolve: VkBool32,
    pub externalFormatResolveChromaOffsetX: VkChromaLocation,
    pub externalFormatResolveChromaOffsetY: VkChromaLocation,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceExternalFormatResolvePropertiesANDROID : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_PROPERTIES_ANDROID);
impl_extends!(VkPhysicalDeviceExternalFormatResolvePropertiesANDROID : VkPhysicalDeviceProperties2);

/// `VkPhysicalDeviceExternalImageFormatInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceExternalImageFormatInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub handleType: VkExternalMemoryHandleTypeFlags,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceExternalImageFormatInfo : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO);
impl_extends!(VkPhysicalDeviceExternalImageFormatInfo : VkPhysicalDeviceImageFormatInfo2);

/// `VkPhysicalDeviceExternalImageFormatInfo`
pub type VkPhysicalDeviceExternalImageFormatInfoKHR = VkPhysicalDeviceExternalImageFormatInfo;

/// `VkPhysicalDeviceExternalMemoryHostPropertiesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceExternalMemoryHostPropertiesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub minImportedHostPointerAlignment: VkDeviceSize,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceExternalMemoryHostPropertiesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT);
impl_extends!(VkPhysicalDeviceExternalMemoryHostPropertiesEXT : VkPhysicalDeviceProperties2);

/// `VkPhysicalDeviceExternalMemoryRDMAFeaturesNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceExternalMemoryRDMAFeaturesNV {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub externalMemoryRDMA: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceExternalMemoryRDMAFeaturesNV : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV);
impl_extends!(VkPhysicalDeviceExternalMemoryRDMAFeaturesNV : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceExternalMemorySciBufFeaturesNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceExternalMemorySciBufFeaturesNV {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub sciBufImport: VkBool32,
    pub sciBufExport: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceExternalMemorySciBufFeaturesNV : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCI_BUF_FEATURES_NV);
impl_extends!(VkPhysicalDeviceExternalMemorySciBufFeaturesNV : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub screenBufferImport: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCREEN_BUFFER_FEATURES_QNX);
impl_extends!(VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceExternalMemorySciBufFeaturesNV`
pub type VkPhysicalDeviceExternalSciBufFeaturesNV = VkPhysicalDeviceExternalMemorySciBufFeaturesNV;

/// `VkPhysicalDeviceExternalSciSync2FeaturesNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceExternalSciSync2FeaturesNV {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub sciSyncFence: VkBool32,
    pub sciSyncSemaphore2: VkBool32,
    pub sciSyncImport: VkBool32,
    pub sciSyncExport: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceExternalSciSync2FeaturesNV : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SCI_SYNC_2_FEATURES_NV);
impl_extends!(VkPhysicalDeviceExternalSciSync2FeaturesNV : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceExternalSciSyncFeaturesNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceExternalSciSyncFeaturesNV {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub sciSyncFence: VkBool32,
    pub sciSyncSemaphore: VkBool32,
    pub sciSyncImport: VkBool32,
    pub sciSyncExport: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceExternalSciSyncFeaturesNV : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SCI_SYNC_FEATURES_NV);
impl_extends!(VkPhysicalDeviceExternalSciSyncFeaturesNV : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceExternalSemaphoreInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceExternalSemaphoreInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub handleType: VkExternalSemaphoreHandleTypeFlags,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceExternalSemaphoreInfo : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO);

/// `VkPhysicalDeviceExternalSemaphoreInfo`
pub type VkPhysicalDeviceExternalSemaphoreInfoKHR = VkPhysicalDeviceExternalSemaphoreInfo;

/// `VkPhysicalDeviceExternalTensorInfoARM`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceExternalTensorInfoARM {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub flags: VkTensorCreateFlagsARM,
    pub pDescription: *const VkTensorDescriptionARM,
    pub handleType: VkExternalMemoryHandleTypeFlags,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceExternalTensorInfoARM : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_TENSOR_INFO_ARM);

/// `VkPhysicalDeviceFaultFeaturesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceFaultFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub deviceFault: VkBool32,
    pub deviceFaultVendorBinary: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceFaultFeaturesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT);
impl_extends!(VkPhysicalDeviceFaultFeaturesEXT : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceFeatures`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceFeatures {
    /// out of bounds buffer accesses are well defined
    pub robustBufferAccess: VkBool32,
    /// full 32-bit range of indices for indexed draw calls
    pub fullDrawIndexUint32: VkBool32,
    /// image views which are arrays of cube maps
    pub imageCubeArray: VkBool32,
    /// blending operations are controlled per-attachment
    pub independentBlend: VkBool32,
    /// geometry stage
    pub geometryShader: VkBool32,
    /// tessellation control and evaluation stage
    pub tessellationShader: VkBool32,
    /// per-sample shading and interpolation
    pub sampleRateShading: VkBool32,
    /// blend operations which take two sources
    pub dualSrcBlend: VkBool32,
    /// logic operations
    pub logicOp: VkBool32,
    /// multi draw indirect
    pub multiDrawIndirect: VkBool32,
    /// indirect drawing can use non-zero firstInstance
    pub drawIndirectFirstInstance: VkBool32,
    /// depth clamping
    pub depthClamp: VkBool32,
    /// depth bias clamping
    pub depthBiasClamp: VkBool32,
    /// point and wireframe fill modes
    pub fillModeNonSolid: VkBool32,
    /// depth bounds test
    pub depthBounds: VkBool32,
    /// lines with width greater than 1
    pub wideLines: VkBool32,
    /// points with size greater than 1
    pub largePoints: VkBool32,
    /// the fragment alpha component can be forced to maximum representable alpha value
    pub alphaToOne: VkBool32,
    /// viewport arrays
    pub multiViewport: VkBool32,
    /// anisotropic sampler filtering
    pub samplerAnisotropy: VkBool32,
    /// ETC texture compression formats
    pub textureCompressionETC2: VkBool32,
    /// ASTC LDR texture compression formats
    pub textureCompressionASTC_LDR: VkBool32,
    /// BC1-7 texture compressed formats
    pub textureCompressionBC: VkBool32,
    /// precise occlusion queries returning actual sample counts
    pub occlusionQueryPrecise: VkBool32,
    /// pipeline statistics query
    pub pipelineStatisticsQuery: VkBool32,
    /// stores and atomic ops on storage buffers and images are supported in vertex, tessellation, and geometry stages
    pub vertexPipelineStoresAndAtomics: VkBool32,
    /// stores and atomic ops on storage buffers and images are supported in the fragment stage
    pub fragmentStoresAndAtomics: VkBool32,
    /// tessellation and geometry stages can export point size
    pub shaderTessellationAndGeometryPointSize: VkBool32,
    /// image gather with runtime values and independent offsets
    pub shaderImageGatherExtended: VkBool32,
    /// the extended set of formats can be used for storage images
    pub shaderStorageImageExtendedFormats: VkBool32,
    /// multisample images can be used for storage images
    pub shaderStorageImageMultisample: VkBool32,
    /// read from storage image does not require format qualifier
    pub shaderStorageImageReadWithoutFormat: VkBool32,
    /// write to storage image does not require format qualifier
    pub shaderStorageImageWriteWithoutFormat: VkBool32,
    /// arrays of uniform buffers can be accessed with dynamically uniform indices
    pub shaderUniformBufferArrayDynamicIndexing: VkBool32,
    /// arrays of sampled images can be accessed with dynamically uniform indices
    pub shaderSampledImageArrayDynamicIndexing: VkBool32,
    /// arrays of storage buffers can be accessed with dynamically uniform indices
    pub shaderStorageBufferArrayDynamicIndexing: VkBool32,
    /// arrays of storage images can be accessed with dynamically uniform indices
    pub shaderStorageImageArrayDynamicIndexing: VkBool32,
    /// clip distance in shaders
    pub shaderClipDistance: VkBool32,
    /// cull distance in shaders
    pub shaderCullDistance: VkBool32,
    /// 64-bit floats (doubles) in shaders
    pub shaderFloat64: VkBool32,
    /// 64-bit integers in shaders
    pub shaderInt64: VkBool32,
    /// 16-bit integers in shaders
    pub shaderInt16: VkBool32,
    /// shader can use texture operations that return resource residency information (requires sparseNonResident support)
    pub shaderResourceResidency: VkBool32,
    /// shader can use texture operations that specify minimum resource LOD
    pub shaderResourceMinLod: VkBool32,
    /// Sparse resources support: Resource memory can be managed at opaque page level rather than object level
    pub sparseBinding: VkBool32,
    /// Sparse resources support: GPU can access partially resident buffers 
    pub sparseResidencyBuffer: VkBool32,
    /// Sparse resources support: GPU can access partially resident 2D (non-MSAA non-depth/stencil) images 
    pub sparseResidencyImage2D: VkBool32,
    /// Sparse resources support: GPU can access partially resident 3D images 
    pub sparseResidencyImage3D: VkBool32,
    /// Sparse resources support: GPU can access partially resident MSAA 2D images with 2 samples
    pub sparseResidency2Samples: VkBool32,
    /// Sparse resources support: GPU can access partially resident MSAA 2D images with 4 samples
    pub sparseResidency4Samples: VkBool32,
    /// Sparse resources support: GPU can access partially resident MSAA 2D images with 8 samples
    pub sparseResidency8Samples: VkBool32,
    /// Sparse resources support: GPU can access partially resident MSAA 2D images with 16 samples
    pub sparseResidency16Samples: VkBool32,
    /// Sparse resources support: GPU can correctly access data aliased into multiple locations (opt-in)
    pub sparseResidencyAliased: VkBool32,
    /// multisample rate must be the same for all pipelines in a subpass
    pub variableMultisampleRate: VkBool32,
    /// Queries may be inherited from primary to secondary command buffers
    pub inheritedQueries: VkBool32,
}
impl_default_zeroed!(VkPhysicalDeviceFeatures);

/// `VkPhysicalDeviceFeatures2`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceFeatures2 {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub features: VkPhysicalDeviceFeatures,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceFeatures2 : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2);
impl_extends!(VkPhysicalDeviceFeatures2 : VkDeviceCreateInfo);

/// `VkPhysicalDeviceFeatures2`
pub type VkPhysicalDeviceFeatures2KHR = VkPhysicalDeviceFeatures2;

/// `VkPhysicalDeviceShaderFloat16Int8Features`
pub type VkPhysicalDeviceFloat16Int8FeaturesKHR = VkPhysicalDeviceShaderFloat16Int8Features;

/// `VkPhysicalDeviceFloatControlsProperties`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceFloatControlsProperties {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub denormBehaviorIndependence: VkShaderFloatControlsIndependence,
    pub roundingModeIndependence: VkShaderFloatControlsIndependence,
    /// An implementation can preserve signed zero, nan, inf
    pub shaderSignedZeroInfNanPreserveFloat16: VkBool32,
    /// An implementation can preserve signed zero, nan, inf
    pub shaderSignedZeroInfNanPreserveFloat32: VkBool32,
    /// An implementation can preserve signed zero, nan, inf
    pub shaderSignedZeroInfNanPreserveFloat64: VkBool32,
    /// An implementation can preserve  denormals
    pub shaderDenormPreserveFloat16: VkBool32,
    /// An implementation can preserve  denormals
    pub shaderDenormPreserveFloat32: VkBool32,
    /// An implementation can preserve  denormals
    pub shaderDenormPreserveFloat64: VkBool32,
    /// An implementation can flush to zero  denormals
    pub shaderDenormFlushToZeroFloat16: VkBool32,
    /// An implementation can flush to zero  denormals
    pub shaderDenormFlushToZeroFloat32: VkBool32,
    /// An implementation can flush to zero  denormals
    pub shaderDenormFlushToZeroFloat64: VkBool32,
    /// An implementation can support RTE
    pub shaderRoundingModeRTEFloat16: VkBool32,
    /// An implementation can support RTE
    pub shaderRoundingModeRTEFloat32: VkBool32,
    /// An implementation can support RTE
    pub shaderRoundingModeRTEFloat64: VkBool32,
    /// An implementation can support RTZ
    pub shaderRoundingModeRTZFloat16: VkBool32,
    /// An implementation can support RTZ
    pub shaderRoundingModeRTZFloat32: VkBool32,
    /// An implementation can support RTZ
    pub shaderRoundingModeRTZFloat64: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceFloatControlsProperties : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES);
impl_extends!(VkPhysicalDeviceFloatControlsProperties : VkPhysicalDeviceProperties2);

/// `VkPhysicalDeviceFloatControlsProperties`
pub type VkPhysicalDeviceFloatControlsPropertiesKHR = VkPhysicalDeviceFloatControlsProperties;

/// `VkPhysicalDeviceFormatPackFeaturesARM`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceFormatPackFeaturesARM {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub formatPack: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceFormatPackFeaturesARM : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FORMAT_PACK_FEATURES_ARM);
impl_extends!(VkPhysicalDeviceFormatPackFeaturesARM : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceFragmentDensityMap2FeaturesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceFragmentDensityMap2FeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub fragmentDensityMapDeferred: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceFragmentDensityMap2FeaturesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT);
impl_extends!(VkPhysicalDeviceFragmentDensityMap2FeaturesEXT : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceFragmentDensityMap2PropertiesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceFragmentDensityMap2PropertiesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub subsampledLoads: VkBool32,
    pub subsampledCoarseReconstructionEarlyAccess: VkBool32,
    pub maxSubsampledArrayLayers: uint32_t,
    pub maxDescriptorSetSubsampledSamplers: uint32_t,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceFragmentDensityMap2PropertiesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT);
impl_extends!(VkPhysicalDeviceFragmentDensityMap2PropertiesEXT : VkPhysicalDeviceProperties2);

/// `VkPhysicalDeviceFragmentDensityMapFeaturesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceFragmentDensityMapFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub fragmentDensityMap: VkBool32,
    pub fragmentDensityMapDynamic: VkBool32,
    pub fragmentDensityMapNonSubsampledImages: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceFragmentDensityMapFeaturesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT);
impl_extends!(VkPhysicalDeviceFragmentDensityMapFeaturesEXT : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub fragmentDensityMapLayered: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_FEATURES_VALVE);
impl_extends!(VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub maxFragmentDensityMapLayers: uint32_t,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_PROPERTIES_VALVE);
impl_extends!(VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE : VkPhysicalDeviceProperties2);

/// `VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub fragmentDensityMapOffset: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_EXT);
impl_extends!(VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT`
pub type VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM = VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT;

/// `VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub fragmentDensityOffsetGranularity: VkExtent2D,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_EXT);
impl_extends!(VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT : VkPhysicalDeviceProperties2);

/// `VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT`
pub type VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM = VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT;

/// `VkPhysicalDeviceFragmentDensityMapPropertiesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceFragmentDensityMapPropertiesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub minFragmentDensityTexelSize: VkExtent2D,
    pub maxFragmentDensityTexelSize: VkExtent2D,
    pub fragmentDensityInvocations: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceFragmentDensityMapPropertiesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT);
impl_extends!(VkPhysicalDeviceFragmentDensityMapPropertiesEXT : VkPhysicalDeviceProperties2);

/// `VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub fragmentShaderBarycentric: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR);
impl_extends!(VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR`
pub type VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV = VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR;

/// `VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub triStripVertexOrderIndependentOfProvokingVertex: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR);
impl_extends!(VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR : VkPhysicalDeviceProperties2);

/// `VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT {
    pub sType: VkStructureType,
    /// Pointer to next structure
    pub pNext: *mut void,
    pub fragmentShaderSampleInterlock: VkBool32,
    pub fragmentShaderPixelInterlock: VkBool32,
    pub fragmentShaderShadingRateInterlock: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT);
impl_extends!(VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub fragmentShadingRateEnums: VkBool32,
    pub supersampleFragmentShadingRates: VkBool32,
    pub noInvocationFragmentShadingRates: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV);
impl_extends!(VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub maxFragmentShadingRateInvocationCount: VkSampleCountFlags,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV);
impl_extends!(VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV : VkPhysicalDeviceProperties2);

/// `VkPhysicalDeviceFragmentShadingRateFeaturesKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceFragmentShadingRateFeaturesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub pipelineFragmentShadingRate: VkBool32,
    pub primitiveFragmentShadingRate: VkBool32,
    pub attachmentFragmentShadingRate: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceFragmentShadingRateFeaturesKHR : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR);
impl_extends!(VkPhysicalDeviceFragmentShadingRateFeaturesKHR : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceFragmentShadingRateKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceFragmentShadingRateKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub sampleCounts: VkSampleCountFlags,
    pub fragmentSize: VkExtent2D,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceFragmentShadingRateKHR : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR);

/// `VkPhysicalDeviceFragmentShadingRatePropertiesKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceFragmentShadingRatePropertiesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub minFragmentShadingRateAttachmentTexelSize: VkExtent2D,
    pub maxFragmentShadingRateAttachmentTexelSize: VkExtent2D,
    pub maxFragmentShadingRateAttachmentTexelSizeAspectRatio: uint32_t,
    pub primitiveFragmentShadingRateWithMultipleViewports: VkBool32,
    pub layeredShadingRateAttachments: VkBool32,
    pub fragmentShadingRateNonTrivialCombinerOps: VkBool32,
    pub maxFragmentSize: VkExtent2D,
    pub maxFragmentSizeAspectRatio: uint32_t,
    pub maxFragmentShadingRateCoverageSamples: uint32_t,
    pub maxFragmentShadingRateRasterizationSamples: VkSampleCountFlags,
    pub fragmentShadingRateWithShaderDepthStencilWrites: VkBool32,
    pub fragmentShadingRateWithSampleMask: VkBool32,
    pub fragmentShadingRateWithShaderSampleMask: VkBool32,
    pub fragmentShadingRateWithConservativeRasterization: VkBool32,
    pub fragmentShadingRateWithFragmentShaderInterlock: VkBool32,
    pub fragmentShadingRateWithCustomSampleLocations: VkBool32,
    pub fragmentShadingRateStrictMultiplyCombiner: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceFragmentShadingRatePropertiesKHR : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR);
impl_extends!(VkPhysicalDeviceFragmentShadingRatePropertiesKHR : VkPhysicalDeviceProperties2);

/// `VkPhysicalDeviceFrameBoundaryFeaturesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceFrameBoundaryFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub frameBoundary: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceFrameBoundaryFeaturesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT);
impl_extends!(VkPhysicalDeviceFrameBoundaryFeaturesEXT : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceGlobalPriorityQueryFeatures`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceGlobalPriorityQueryFeatures {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub globalPriorityQuery: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceGlobalPriorityQueryFeatures : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES);
impl_extends!(VkPhysicalDeviceGlobalPriorityQueryFeatures : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceGlobalPriorityQueryFeatures`
pub type VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT = VkPhysicalDeviceGlobalPriorityQueryFeatures;

/// `VkPhysicalDeviceGlobalPriorityQueryFeatures`
pub type VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR = VkPhysicalDeviceGlobalPriorityQueryFeatures;

/// `VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub graphicsPipelineLibrary: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT);
impl_extends!(VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub graphicsPipelineLibraryFastLinking: VkBool32,
    pub graphicsPipelineLibraryIndependentInterpolationDecoration: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT);
impl_extends!(VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT : VkPhysicalDeviceProperties2);

/// `VkPhysicalDeviceGroupProperties`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceGroupProperties {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub physicalDeviceCount: uint32_t,
    pub physicalDevices: [VkPhysicalDevice; VK_MAX_DEVICE_GROUP_SIZE as usize],
    pub subsetAllocation: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceGroupProperties : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES);

/// `VkPhysicalDeviceGroupProperties`
pub type VkPhysicalDeviceGroupPropertiesKHR = VkPhysicalDeviceGroupProperties;

/// `VkPhysicalDeviceHdrVividFeaturesHUAWEI`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceHdrVividFeaturesHUAWEI {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub hdrVivid: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceHdrVividFeaturesHUAWEI : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI);
impl_extends!(VkPhysicalDeviceHdrVividFeaturesHUAWEI : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceHostImageCopyFeatures`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceHostImageCopyFeatures {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub hostImageCopy: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceHostImageCopyFeatures : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES);
impl_extends!(VkPhysicalDeviceHostImageCopyFeatures : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceHostImageCopyFeatures`
pub type VkPhysicalDeviceHostImageCopyFeaturesEXT = VkPhysicalDeviceHostImageCopyFeatures;

/// `VkPhysicalDeviceHostImageCopyProperties`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceHostImageCopyProperties {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub copySrcLayoutCount: uint32_t,
    pub pCopySrcLayouts: *mut VkImageLayout,
    pub copyDstLayoutCount: uint32_t,
    pub pCopyDstLayouts: *mut VkImageLayout,
    pub optimalTilingLayoutUUID: [uint8_t; VK_UUID_SIZE as usize],
    pub identicalMemoryTypeRequirements: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceHostImageCopyProperties : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES);
impl_extends!(VkPhysicalDeviceHostImageCopyProperties : VkPhysicalDeviceProperties2);

/// `VkPhysicalDeviceHostImageCopyProperties`
pub type VkPhysicalDeviceHostImageCopyPropertiesEXT = VkPhysicalDeviceHostImageCopyProperties;

/// `VkPhysicalDeviceHostQueryResetFeatures`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceHostQueryResetFeatures {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub hostQueryReset: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceHostQueryResetFeatures : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES);
impl_extends!(VkPhysicalDeviceHostQueryResetFeatures : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceHostQueryResetFeatures`
pub type VkPhysicalDeviceHostQueryResetFeaturesEXT = VkPhysicalDeviceHostQueryResetFeatures;

/// `VkPhysicalDeviceIDProperties`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceIDProperties {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub deviceUUID: [uint8_t; VK_UUID_SIZE as usize],
    pub driverUUID: [uint8_t; VK_UUID_SIZE as usize],
    pub deviceLUID: [uint8_t; VK_LUID_SIZE as usize],
    pub deviceNodeMask: uint32_t,
    pub deviceLUIDValid: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceIDProperties : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES);
impl_extends!(VkPhysicalDeviceIDProperties : VkPhysicalDeviceProperties2);

/// `VkPhysicalDeviceIDProperties`
pub type VkPhysicalDeviceIDPropertiesKHR = VkPhysicalDeviceIDProperties;

/// `VkPhysicalDeviceImage2DViewOf3DFeaturesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceImage2DViewOf3DFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub image2DViewOf3D: VkBool32,
    pub sampler2DViewOf3D: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceImage2DViewOf3DFeaturesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT);
impl_extends!(VkPhysicalDeviceImage2DViewOf3DFeaturesEXT : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceImageAlignmentControlFeaturesMESA`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceImageAlignmentControlFeaturesMESA {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub imageAlignmentControl: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceImageAlignmentControlFeaturesMESA : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA);
impl_extends!(VkPhysicalDeviceImageAlignmentControlFeaturesMESA : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceImageAlignmentControlPropertiesMESA`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceImageAlignmentControlPropertiesMESA {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub supportedImageAlignmentMask: uint32_t,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceImageAlignmentControlPropertiesMESA : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_PROPERTIES_MESA);
impl_extends!(VkPhysicalDeviceImageAlignmentControlPropertiesMESA : VkPhysicalDeviceProperties2);

/// `VkPhysicalDeviceImageCompressionControlFeaturesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceImageCompressionControlFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub imageCompressionControl: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceImageCompressionControlFeaturesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT);
impl_extends!(VkPhysicalDeviceImageCompressionControlFeaturesEXT : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub imageCompressionControlSwapchain: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT);
impl_extends!(VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceImageDrmFormatModifierInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceImageDrmFormatModifierInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub drmFormatModifier: uint64_t,
    pub sharingMode: VkSharingMode,
    pub queueFamilyIndexCount: uint32_t,
    pub pQueueFamilyIndices: *const uint32_t,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceImageDrmFormatModifierInfoEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT);
impl_extends!(VkPhysicalDeviceImageDrmFormatModifierInfoEXT : VkPhysicalDeviceImageFormatInfo2);

/// `VkPhysicalDeviceImageFormatInfo2`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceImageFormatInfo2 {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub format: VkFormat,
    pub r#type: VkImageType,
    pub tiling: VkImageTiling,
    pub usage: VkImageUsageFlags,
    pub flags: VkImageCreateFlags,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceImageFormatInfo2 : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2);

/// `VkPhysicalDeviceImageFormatInfo2`
pub type VkPhysicalDeviceImageFormatInfo2KHR = VkPhysicalDeviceImageFormatInfo2;

/// `VkPhysicalDeviceImageProcessing2FeaturesQCOM`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceImageProcessing2FeaturesQCOM {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub textureBlockMatch2: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceImageProcessing2FeaturesQCOM : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM);
impl_extends!(VkPhysicalDeviceImageProcessing2FeaturesQCOM : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceImageProcessing2PropertiesQCOM`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceImageProcessing2PropertiesQCOM {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub maxBlockMatchWindow: VkExtent2D,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceImageProcessing2PropertiesQCOM : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_PROPERTIES_QCOM);
impl_extends!(VkPhysicalDeviceImageProcessing2PropertiesQCOM : VkPhysicalDeviceProperties2);

/// `VkPhysicalDeviceImageProcessingFeaturesQCOM`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceImageProcessingFeaturesQCOM {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub textureSampleWeighted: VkBool32,
    pub textureBoxFilter: VkBool32,
    pub textureBlockMatch: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceImageProcessingFeaturesQCOM : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM);
impl_extends!(VkPhysicalDeviceImageProcessingFeaturesQCOM : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceImageProcessingPropertiesQCOM`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceImageProcessingPropertiesQCOM {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub maxWeightFilterPhases: uint32_t,
    pub maxWeightFilterDimension: VkExtent2D,
    pub maxBlockMatchRegion: VkExtent2D,
    pub maxBoxFilterBlockSize: VkExtent2D,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceImageProcessingPropertiesQCOM : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM);
impl_extends!(VkPhysicalDeviceImageProcessingPropertiesQCOM : VkPhysicalDeviceProperties2);

/// `VkPhysicalDeviceImageRobustnessFeatures`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceImageRobustnessFeatures {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub robustImageAccess: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceImageRobustnessFeatures : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES);
impl_extends!(VkPhysicalDeviceImageRobustnessFeatures : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceImageRobustnessFeatures`
pub type VkPhysicalDeviceImageRobustnessFeaturesEXT = VkPhysicalDeviceImageRobustnessFeatures;

/// `VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub imageSlicedViewOf3D: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT);
impl_extends!(VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceImageViewImageFormatInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceImageViewImageFormatInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub imageViewType: VkImageViewType,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceImageViewImageFormatInfoEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT);
impl_extends!(VkPhysicalDeviceImageViewImageFormatInfoEXT : VkPhysicalDeviceImageFormatInfo2);

/// `VkPhysicalDeviceImageViewMinLodFeaturesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceImageViewMinLodFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub minLod: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceImageViewMinLodFeaturesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT);
impl_extends!(VkPhysicalDeviceImageViewMinLodFeaturesEXT : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceImagelessFramebufferFeatures`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceImagelessFramebufferFeatures {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub imagelessFramebuffer: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceImagelessFramebufferFeatures : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES);
impl_extends!(VkPhysicalDeviceImagelessFramebufferFeatures : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceImagelessFramebufferFeatures`
pub type VkPhysicalDeviceImagelessFramebufferFeaturesKHR = VkPhysicalDeviceImagelessFramebufferFeatures;

/// `VkPhysicalDeviceIndexTypeUint8Features`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceIndexTypeUint8Features {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub indexTypeUint8: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceIndexTypeUint8Features : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES);
impl_extends!(VkPhysicalDeviceIndexTypeUint8Features : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceIndexTypeUint8Features`
pub type VkPhysicalDeviceIndexTypeUint8FeaturesEXT = VkPhysicalDeviceIndexTypeUint8Features;

/// `VkPhysicalDeviceIndexTypeUint8Features`
pub type VkPhysicalDeviceIndexTypeUint8FeaturesKHR = VkPhysicalDeviceIndexTypeUint8Features;

/// `VkPhysicalDeviceInheritedViewportScissorFeaturesNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceInheritedViewportScissorFeaturesNV {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub inheritedViewportScissor2D: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceInheritedViewportScissorFeaturesNV : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV);
impl_extends!(VkPhysicalDeviceInheritedViewportScissorFeaturesNV : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceInlineUniformBlockFeatures`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceInlineUniformBlockFeatures {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub inlineUniformBlock: VkBool32,
    pub descriptorBindingInlineUniformBlockUpdateAfterBind: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceInlineUniformBlockFeatures : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES);
impl_extends!(VkPhysicalDeviceInlineUniformBlockFeatures : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceInlineUniformBlockFeatures`
pub type VkPhysicalDeviceInlineUniformBlockFeaturesEXT = VkPhysicalDeviceInlineUniformBlockFeatures;

/// `VkPhysicalDeviceInlineUniformBlockProperties`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceInlineUniformBlockProperties {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub maxInlineUniformBlockSize: uint32_t,
    pub maxPerStageDescriptorInlineUniformBlocks: uint32_t,
    pub maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks: uint32_t,
    pub maxDescriptorSetInlineUniformBlocks: uint32_t,
    pub maxDescriptorSetUpdateAfterBindInlineUniformBlocks: uint32_t,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceInlineUniformBlockProperties : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES);
impl_extends!(VkPhysicalDeviceInlineUniformBlockProperties : VkPhysicalDeviceProperties2);

/// `VkPhysicalDeviceInlineUniformBlockProperties`
pub type VkPhysicalDeviceInlineUniformBlockPropertiesEXT = VkPhysicalDeviceInlineUniformBlockProperties;

/// `VkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub internallySynchronizedQueues: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INTERNALLY_SYNCHRONIZED_QUEUES_FEATURES_KHR);
impl_extends!(VkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceInvocationMaskFeaturesHUAWEI`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceInvocationMaskFeaturesHUAWEI {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub invocationMask: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceInvocationMaskFeaturesHUAWEI : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI);
impl_extends!(VkPhysicalDeviceInvocationMaskFeaturesHUAWEI : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

from_into_transparent!(VkPhysicalDeviceLayeredApiKHR: i32);
/// `VkPhysicalDeviceLayeredApiKHR`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkPhysicalDeviceLayeredApiKHR(pub i32);

/// `0`  
pub const VK_PHYSICAL_DEVICE_LAYERED_API_VULKAN_KHR: VkPhysicalDeviceLayeredApiKHR = VkPhysicalDeviceLayeredApiKHR(0);
/// `1`  
pub const VK_PHYSICAL_DEVICE_LAYERED_API_D3D12_KHR: VkPhysicalDeviceLayeredApiKHR = VkPhysicalDeviceLayeredApiKHR(1);
/// `2`  
pub const VK_PHYSICAL_DEVICE_LAYERED_API_METAL_KHR: VkPhysicalDeviceLayeredApiKHR = VkPhysicalDeviceLayeredApiKHR(2);
/// `3`  
pub const VK_PHYSICAL_DEVICE_LAYERED_API_OPENGL_KHR: VkPhysicalDeviceLayeredApiKHR = VkPhysicalDeviceLayeredApiKHR(3);
/// `4`  
pub const VK_PHYSICAL_DEVICE_LAYERED_API_OPENGLES_KHR: VkPhysicalDeviceLayeredApiKHR = VkPhysicalDeviceLayeredApiKHR(4);

impl_enum_display!(VkPhysicalDeviceLayeredApiKHR { VK_PHYSICAL_DEVICE_LAYERED_API_VULKAN_KHR, VK_PHYSICAL_DEVICE_LAYERED_API_D3D12_KHR, VK_PHYSICAL_DEVICE_LAYERED_API_METAL_KHR, VK_PHYSICAL_DEVICE_LAYERED_API_OPENGL_KHR, VK_PHYSICAL_DEVICE_LAYERED_API_OPENGLES_KHR });

/// `VkPhysicalDeviceLayeredApiPropertiesKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceLayeredApiPropertiesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub vendorID: uint32_t,
    pub deviceID: uint32_t,
    pub layeredAPI: VkPhysicalDeviceLayeredApiKHR,
    pub deviceName: [c_char; VK_MAX_PHYSICAL_DEVICE_NAME_SIZE as usize],
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceLayeredApiPropertiesKHR : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_KHR);

/// `VkPhysicalDeviceLayeredApiPropertiesListKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceLayeredApiPropertiesListKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub layeredApiCount: uint32_t,
    /// Output list of layered implementations underneath the physical device
    pub pLayeredApis: *mut VkPhysicalDeviceLayeredApiPropertiesKHR,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceLayeredApiPropertiesListKHR : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_LIST_KHR);
impl_extends!(VkPhysicalDeviceLayeredApiPropertiesListKHR : VkPhysicalDeviceProperties2);

/// `VkPhysicalDeviceLayeredApiVulkanPropertiesKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceLayeredApiVulkanPropertiesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub properties: VkPhysicalDeviceProperties2,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceLayeredApiVulkanPropertiesKHR : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_VULKAN_PROPERTIES_KHR);
impl_extends!(VkPhysicalDeviceLayeredApiVulkanPropertiesKHR : VkPhysicalDeviceLayeredApiPropertiesKHR);

/// `VkPhysicalDeviceLayeredDriverPropertiesMSFT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceLayeredDriverPropertiesMSFT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub underlyingAPI: VkLayeredDriverUnderlyingApiMSFT,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceLayeredDriverPropertiesMSFT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT);
impl_extends!(VkPhysicalDeviceLayeredDriverPropertiesMSFT : VkPhysicalDeviceProperties2);

/// `VkPhysicalDeviceLegacyDitheringFeaturesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceLegacyDitheringFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub legacyDithering: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceLegacyDitheringFeaturesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT);
impl_extends!(VkPhysicalDeviceLegacyDitheringFeaturesEXT : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub legacyVertexAttributes: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_FEATURES_EXT);
impl_extends!(VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub nativeUnalignedPerformance: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_PROPERTIES_EXT);
impl_extends!(VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT : VkPhysicalDeviceProperties2);

/// `VkPhysicalDeviceLimits`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceLimits {
    /// max 1D image dimension
    pub maxImageDimension1D: uint32_t,
    /// max 2D image dimension
    pub maxImageDimension2D: uint32_t,
    /// max 3D image dimension
    pub maxImageDimension3D: uint32_t,
    /// max cube map image dimension
    pub maxImageDimensionCube: uint32_t,
    /// max layers for image arrays
    pub maxImageArrayLayers: uint32_t,
    /// max texel buffer size (fstexels)
    pub maxTexelBufferElements: uint32_t,
    /// max uniform buffer range (bytes)
    pub maxUniformBufferRange: uint32_t,
    /// max storage buffer range (bytes)
    pub maxStorageBufferRange: uint32_t,
    /// max size of the push constants pool (bytes)
    pub maxPushConstantsSize: uint32_t,
    /// max number of device memory allocations supported
    pub maxMemoryAllocationCount: uint32_t,
    /// max number of samplers that can be allocated on a device
    pub maxSamplerAllocationCount: uint32_t,
    /// Granularity (in bytes) at which buffers and images can be bound to adjacent memory for simultaneous usage
    pub bufferImageGranularity: VkDeviceSize,
    /// Total address space available for sparse allocations (bytes)
    pub sparseAddressSpaceSize: VkDeviceSize,
    /// max number of descriptors sets that can be bound to a pipeline
    pub maxBoundDescriptorSets: uint32_t,
    /// max number of samplers allowed per-stage in a descriptor set
    pub maxPerStageDescriptorSamplers: uint32_t,
    /// max number of uniform buffers allowed per-stage in a descriptor set
    pub maxPerStageDescriptorUniformBuffers: uint32_t,
    /// max number of storage buffers allowed per-stage in a descriptor set
    pub maxPerStageDescriptorStorageBuffers: uint32_t,
    /// max number of sampled images allowed per-stage in a descriptor set
    pub maxPerStageDescriptorSampledImages: uint32_t,
    /// max number of storage images allowed per-stage in a descriptor set
    pub maxPerStageDescriptorStorageImages: uint32_t,
    /// max number of input attachments allowed per-stage in a descriptor set
    pub maxPerStageDescriptorInputAttachments: uint32_t,
    /// max number of resources allowed by a single stage
    pub maxPerStageResources: uint32_t,
    /// max number of samplers allowed in all stages in a descriptor set
    pub maxDescriptorSetSamplers: uint32_t,
    /// max number of uniform buffers allowed in all stages in a descriptor set
    pub maxDescriptorSetUniformBuffers: uint32_t,
    /// max number of dynamic uniform buffers allowed in all stages in a descriptor set
    pub maxDescriptorSetUniformBuffersDynamic: uint32_t,
    /// max number of storage buffers allowed in all stages in a descriptor set
    pub maxDescriptorSetStorageBuffers: uint32_t,
    /// max number of dynamic storage buffers allowed in all stages in a descriptor set
    pub maxDescriptorSetStorageBuffersDynamic: uint32_t,
    /// max number of sampled images allowed in all stages in a descriptor set
    pub maxDescriptorSetSampledImages: uint32_t,
    /// max number of storage images allowed in all stages in a descriptor set
    pub maxDescriptorSetStorageImages: uint32_t,
    /// max number of input attachments allowed in all stages in a descriptor set
    pub maxDescriptorSetInputAttachments: uint32_t,
    /// max number of vertex input attribute slots
    pub maxVertexInputAttributes: uint32_t,
    /// max number of vertex input binding slots
    pub maxVertexInputBindings: uint32_t,
    /// max vertex input attribute offset added to vertex buffer offset
    pub maxVertexInputAttributeOffset: uint32_t,
    /// max vertex input binding stride
    pub maxVertexInputBindingStride: uint32_t,
    /// max number of output components written by vertex shader
    pub maxVertexOutputComponents: uint32_t,
    /// max level supported by tessellation primitive generator
    pub maxTessellationGenerationLevel: uint32_t,
    /// max patch size (vertices)
    pub maxTessellationPatchSize: uint32_t,
    /// max number of input components per-vertex in TCS
    pub maxTessellationControlPerVertexInputComponents: uint32_t,
    /// max number of output components per-vertex in TCS
    pub maxTessellationControlPerVertexOutputComponents: uint32_t,
    /// max number of output components per-patch in TCS
    pub maxTessellationControlPerPatchOutputComponents: uint32_t,
    /// max total number of per-vertex and per-patch output components in TCS
    pub maxTessellationControlTotalOutputComponents: uint32_t,
    /// max number of input components per vertex in TES
    pub maxTessellationEvaluationInputComponents: uint32_t,
    /// max number of output components per vertex in TES
    pub maxTessellationEvaluationOutputComponents: uint32_t,
    /// max invocation count supported in geometry shader
    pub maxGeometryShaderInvocations: uint32_t,
    /// max number of input components read in geometry stage
    pub maxGeometryInputComponents: uint32_t,
    /// max number of output components written in geometry stage
    pub maxGeometryOutputComponents: uint32_t,
    /// max number of vertices that can be emitted in geometry stage
    pub maxGeometryOutputVertices: uint32_t,
    /// max total number of components (all vertices) written in geometry stage
    pub maxGeometryTotalOutputComponents: uint32_t,
    /// max number of input components read in fragment stage
    pub maxFragmentInputComponents: uint32_t,
    /// max number of output attachments written in fragment stage
    pub maxFragmentOutputAttachments: uint32_t,
    /// max number of output attachments written when using dual source blending
    pub maxFragmentDualSrcAttachments: uint32_t,
    /// max total number of storage buffers, storage images and output buffers
    pub maxFragmentCombinedOutputResources: uint32_t,
    /// max total storage size of work group local storage (bytes)
    pub maxComputeSharedMemorySize: uint32_t,
    /// max num of compute work groups that may be dispatched by a single command (x,y,z)
    pub maxComputeWorkGroupCount: [uint32_t; 3 as usize],
    /// max total compute invocations in a single local work group
    pub maxComputeWorkGroupInvocations: uint32_t,
    /// max local size of a compute work group (x,y,z)
    pub maxComputeWorkGroupSize: [uint32_t; 3 as usize],
    /// number bits of subpixel precision in screen x and y
    pub subPixelPrecisionBits: uint32_t,
    /// number bits of precision for selecting texel weights
    pub subTexelPrecisionBits: uint32_t,
    /// number bits of precision for selecting mipmap weights
    pub mipmapPrecisionBits: uint32_t,
    /// max index value for indexed draw calls (for 32-bit indices)
    pub maxDrawIndexedIndexValue: uint32_t,
    /// max draw count for indirect drawing calls
    pub maxDrawIndirectCount: uint32_t,
    /// max absolute sampler LOD bias
    pub maxSamplerLodBias: float,
    /// max degree of sampler anisotropy
    pub maxSamplerAnisotropy: float,
    /// max number of active viewports
    pub maxViewports: uint32_t,
    /// max viewport dimensions (x,y)
    pub maxViewportDimensions: [uint32_t; 2 as usize],
    /// viewport bounds range (min,max)
    pub viewportBoundsRange: [float; 2 as usize],
    /// number bits of subpixel precision for viewport
    pub viewportSubPixelBits: uint32_t,
    /// min required alignment of pointers returned by MapMemory (bytes)
    pub minMemoryMapAlignment: size_t,
    /// min required alignment for texel buffer offsets (bytes) 
    pub minTexelBufferOffsetAlignment: VkDeviceSize,
    /// min required alignment for uniform buffer sizes and offsets (bytes)
    pub minUniformBufferOffsetAlignment: VkDeviceSize,
    /// min required alignment for storage buffer offsets (bytes)
    pub minStorageBufferOffsetAlignment: VkDeviceSize,
    /// min texel offset for OpTextureSampleOffset
    pub minTexelOffset: int32_t,
    /// max texel offset for OpTextureSampleOffset
    pub maxTexelOffset: uint32_t,
    /// min texel offset for OpTextureGatherOffset
    pub minTexelGatherOffset: int32_t,
    /// max texel offset for OpTextureGatherOffset
    pub maxTexelGatherOffset: uint32_t,
    /// furthest negative offset for interpolateAtOffset
    pub minInterpolationOffset: float,
    /// furthest positive offset for interpolateAtOffset
    pub maxInterpolationOffset: float,
    /// number of subpixel bits for interpolateAtOffset
    pub subPixelInterpolationOffsetBits: uint32_t,
    /// max width for a framebuffer
    pub maxFramebufferWidth: uint32_t,
    /// max height for a framebuffer
    pub maxFramebufferHeight: uint32_t,
    /// max layer count for a layered framebuffer
    pub maxFramebufferLayers: uint32_t,
    /// supported color sample counts for a framebuffer
    pub framebufferColorSampleCounts: VkSampleCountFlags,
    /// supported depth sample counts for a framebuffer
    pub framebufferDepthSampleCounts: VkSampleCountFlags,
    /// supported stencil sample counts for a framebuffer
    pub framebufferStencilSampleCounts: VkSampleCountFlags,
    /// supported sample counts for a subpass which uses no attachments
    pub framebufferNoAttachmentsSampleCounts: VkSampleCountFlags,
    /// max number of color attachments per subpass
    pub maxColorAttachments: uint32_t,
    /// supported color sample counts for a non-integer sampled image
    pub sampledImageColorSampleCounts: VkSampleCountFlags,
    /// supported sample counts for an integer image
    pub sampledImageIntegerSampleCounts: VkSampleCountFlags,
    /// supported depth sample counts for a sampled image
    pub sampledImageDepthSampleCounts: VkSampleCountFlags,
    /// supported stencil sample counts for a sampled image
    pub sampledImageStencilSampleCounts: VkSampleCountFlags,
    /// supported sample counts for a storage image
    pub storageImageSampleCounts: VkSampleCountFlags,
    /// max number of sample mask words
    pub maxSampleMaskWords: uint32_t,
    /// timestamps on graphics and compute queues
    pub timestampComputeAndGraphics: VkBool32,
    /// number of nanoseconds it takes for timestamp query value to increment by 1
    pub timestampPeriod: float,
    /// max number of clip distances
    pub maxClipDistances: uint32_t,
    /// max number of cull distances
    pub maxCullDistances: uint32_t,
    /// max combined number of user clipping
    pub maxCombinedClipAndCullDistances: uint32_t,
    /// distinct queue priorities available 
    pub discreteQueuePriorities: uint32_t,
    /// range (min,max) of supported point sizes
    pub pointSizeRange: [float; 2 as usize],
    /// range (min,max) of supported line widths
    pub lineWidthRange: [float; 2 as usize],
    /// granularity of supported point sizes
    pub pointSizeGranularity: float,
    /// granularity of supported line widths
    pub lineWidthGranularity: float,
    /// line rasterization follows preferred rules
    pub strictLines: VkBool32,
    /// supports standard sample locations for all supported sample counts
    pub standardSampleLocations: VkBool32,
    /// optimal offset of buffer copies
    pub optimalBufferCopyOffsetAlignment: VkDeviceSize,
    /// optimal pitch of buffer copies
    pub optimalBufferCopyRowPitchAlignment: VkDeviceSize,
    /// minimum size and alignment for non-coherent host-mapped device memory access
    pub nonCoherentAtomSize: VkDeviceSize,
}
impl_default_zeroed!(VkPhysicalDeviceLimits);

/// `VkPhysicalDeviceLineRasterizationFeatures`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceLineRasterizationFeatures {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub rectangularLines: VkBool32,
    pub bresenhamLines: VkBool32,
    pub smoothLines: VkBool32,
    pub stippledRectangularLines: VkBool32,
    pub stippledBresenhamLines: VkBool32,
    pub stippledSmoothLines: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceLineRasterizationFeatures : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES);
impl_extends!(VkPhysicalDeviceLineRasterizationFeatures : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceLineRasterizationFeatures`
pub type VkPhysicalDeviceLineRasterizationFeaturesEXT = VkPhysicalDeviceLineRasterizationFeatures;

/// `VkPhysicalDeviceLineRasterizationFeatures`
pub type VkPhysicalDeviceLineRasterizationFeaturesKHR = VkPhysicalDeviceLineRasterizationFeatures;

/// `VkPhysicalDeviceLineRasterizationProperties`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceLineRasterizationProperties {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub lineSubPixelPrecisionBits: uint32_t,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceLineRasterizationProperties : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES);
impl_extends!(VkPhysicalDeviceLineRasterizationProperties : VkPhysicalDeviceProperties2);

/// `VkPhysicalDeviceLineRasterizationProperties`
pub type VkPhysicalDeviceLineRasterizationPropertiesEXT = VkPhysicalDeviceLineRasterizationProperties;

/// `VkPhysicalDeviceLineRasterizationProperties`
pub type VkPhysicalDeviceLineRasterizationPropertiesKHR = VkPhysicalDeviceLineRasterizationProperties;

/// `VkPhysicalDeviceLinearColorAttachmentFeaturesNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceLinearColorAttachmentFeaturesNV {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub linearColorAttachment: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceLinearColorAttachmentFeaturesNV : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV);
impl_extends!(VkPhysicalDeviceLinearColorAttachmentFeaturesNV : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceMaintenance10FeaturesKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceMaintenance10FeaturesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub maintenance10: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceMaintenance10FeaturesKHR : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_10_FEATURES_KHR);
impl_extends!(VkPhysicalDeviceMaintenance10FeaturesKHR : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceMaintenance10PropertiesKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceMaintenance10PropertiesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub rgba4OpaqueBlackSwizzled: VkBool32,
    pub resolveSrgbFormatAppliesTransferFunction: VkBool32,
    pub resolveSrgbFormatSupportsTransferFunctionControl: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceMaintenance10PropertiesKHR : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_10_PROPERTIES_KHR);
impl_extends!(VkPhysicalDeviceMaintenance10PropertiesKHR : VkPhysicalDeviceProperties2);

/// `VkPhysicalDeviceMaintenance3Properties`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceMaintenance3Properties {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub maxPerSetDescriptors: uint32_t,
    pub maxMemoryAllocationSize: VkDeviceSize,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceMaintenance3Properties : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES);
impl_extends!(VkPhysicalDeviceMaintenance3Properties : VkPhysicalDeviceProperties2);

/// `VkPhysicalDeviceMaintenance3Properties`
pub type VkPhysicalDeviceMaintenance3PropertiesKHR = VkPhysicalDeviceMaintenance3Properties;

/// `VkPhysicalDeviceMaintenance4Features`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceMaintenance4Features {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub maintenance4: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceMaintenance4Features : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES);
impl_extends!(VkPhysicalDeviceMaintenance4Features : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceMaintenance4Features`
pub type VkPhysicalDeviceMaintenance4FeaturesKHR = VkPhysicalDeviceMaintenance4Features;

/// `VkPhysicalDeviceMaintenance4Properties`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceMaintenance4Properties {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub maxBufferSize: VkDeviceSize,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceMaintenance4Properties : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES);
impl_extends!(VkPhysicalDeviceMaintenance4Properties : VkPhysicalDeviceProperties2);

/// `VkPhysicalDeviceMaintenance4Properties`
pub type VkPhysicalDeviceMaintenance4PropertiesKHR = VkPhysicalDeviceMaintenance4Properties;

/// `VkPhysicalDeviceMaintenance5Features`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceMaintenance5Features {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub maintenance5: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceMaintenance5Features : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES);
impl_extends!(VkPhysicalDeviceMaintenance5Features : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceMaintenance5Features`
pub type VkPhysicalDeviceMaintenance5FeaturesKHR = VkPhysicalDeviceMaintenance5Features;

/// `VkPhysicalDeviceMaintenance5Properties`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceMaintenance5Properties {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub earlyFragmentMultisampleCoverageAfterSampleCounting: VkBool32,
    pub earlyFragmentSampleMaskTestBeforeSampleCounting: VkBool32,
    pub depthStencilSwizzleOneSupport: VkBool32,
    pub polygonModePointSize: VkBool32,
    pub nonStrictSinglePixelWideLinesUseParallelogram: VkBool32,
    pub nonStrictWideLinesUseParallelogram: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceMaintenance5Properties : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES);
impl_extends!(VkPhysicalDeviceMaintenance5Properties : VkPhysicalDeviceProperties2);

/// `VkPhysicalDeviceMaintenance5Properties`
pub type VkPhysicalDeviceMaintenance5PropertiesKHR = VkPhysicalDeviceMaintenance5Properties;

/// `VkPhysicalDeviceMaintenance6Features`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceMaintenance6Features {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub maintenance6: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceMaintenance6Features : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES);
impl_extends!(VkPhysicalDeviceMaintenance6Features : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceMaintenance6Features`
pub type VkPhysicalDeviceMaintenance6FeaturesKHR = VkPhysicalDeviceMaintenance6Features;

/// `VkPhysicalDeviceMaintenance6Properties`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceMaintenance6Properties {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub blockTexelViewCompatibleMultipleLayers: VkBool32,
    pub maxCombinedImageSamplerDescriptorCount: uint32_t,
    pub fragmentShadingRateClampCombinerInputs: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceMaintenance6Properties : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES);
impl_extends!(VkPhysicalDeviceMaintenance6Properties : VkPhysicalDeviceProperties2);

/// `VkPhysicalDeviceMaintenance6Properties`
pub type VkPhysicalDeviceMaintenance6PropertiesKHR = VkPhysicalDeviceMaintenance6Properties;

/// `VkPhysicalDeviceMaintenance7FeaturesKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceMaintenance7FeaturesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub maintenance7: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceMaintenance7FeaturesKHR : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_FEATURES_KHR);
impl_extends!(VkPhysicalDeviceMaintenance7FeaturesKHR : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceMaintenance7PropertiesKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceMaintenance7PropertiesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub robustFragmentShadingRateAttachmentAccess: VkBool32,
    pub separateDepthStencilAttachmentAccess: VkBool32,
    pub maxDescriptorSetTotalUniformBuffersDynamic: uint32_t,
    pub maxDescriptorSetTotalStorageBuffersDynamic: uint32_t,
    pub maxDescriptorSetTotalBuffersDynamic: uint32_t,
    pub maxDescriptorSetUpdateAfterBindTotalUniformBuffersDynamic: uint32_t,
    pub maxDescriptorSetUpdateAfterBindTotalStorageBuffersDynamic: uint32_t,
    pub maxDescriptorSetUpdateAfterBindTotalBuffersDynamic: uint32_t,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceMaintenance7PropertiesKHR : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_PROPERTIES_KHR);
impl_extends!(VkPhysicalDeviceMaintenance7PropertiesKHR : VkPhysicalDeviceProperties2);

/// `VkPhysicalDeviceMaintenance8FeaturesKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceMaintenance8FeaturesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub maintenance8: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceMaintenance8FeaturesKHR : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR);
impl_extends!(VkPhysicalDeviceMaintenance8FeaturesKHR : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceMaintenance9FeaturesKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceMaintenance9FeaturesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub maintenance9: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceMaintenance9FeaturesKHR : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR);
impl_extends!(VkPhysicalDeviceMaintenance9FeaturesKHR : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceMaintenance9PropertiesKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceMaintenance9PropertiesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub image2DViewOf3DSparse: VkBool32,
    pub defaultVertexAttributeValue: VkDefaultVertexAttributeValueKHR,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceMaintenance9PropertiesKHR : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_PROPERTIES_KHR);
impl_extends!(VkPhysicalDeviceMaintenance9PropertiesKHR : VkPhysicalDeviceProperties2);

/// `VkPhysicalDeviceMapMemoryPlacedFeaturesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceMapMemoryPlacedFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub memoryMapPlaced: VkBool32,
    pub memoryMapRangePlaced: VkBool32,
    pub memoryUnmapReserve: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceMapMemoryPlacedFeaturesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT);
impl_extends!(VkPhysicalDeviceMapMemoryPlacedFeaturesEXT : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceMapMemoryPlacedPropertiesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceMapMemoryPlacedPropertiesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub minPlacedMemoryMapAlignment: VkDeviceSize,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceMapMemoryPlacedPropertiesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_PROPERTIES_EXT);
impl_extends!(VkPhysicalDeviceMapMemoryPlacedPropertiesEXT : VkPhysicalDeviceProperties2);

/// `VkPhysicalDeviceMemoryBudgetPropertiesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceMemoryBudgetPropertiesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub heapBudget: [VkDeviceSize; VK_MAX_MEMORY_HEAPS as usize],
    pub heapUsage: [VkDeviceSize; VK_MAX_MEMORY_HEAPS as usize],
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceMemoryBudgetPropertiesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT);
impl_extends!(VkPhysicalDeviceMemoryBudgetPropertiesEXT : VkPhysicalDeviceMemoryProperties2);

/// `VkPhysicalDeviceMemoryDecompressionFeaturesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceMemoryDecompressionFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub memoryDecompression: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceMemoryDecompressionFeaturesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_EXT);
impl_extends!(VkPhysicalDeviceMemoryDecompressionFeaturesEXT : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceMemoryDecompressionFeaturesEXT`
pub type VkPhysicalDeviceMemoryDecompressionFeaturesNV = VkPhysicalDeviceMemoryDecompressionFeaturesEXT;

/// `VkPhysicalDeviceMemoryDecompressionPropertiesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceMemoryDecompressionPropertiesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub decompressionMethods: VkMemoryDecompressionMethodFlagsEXT,
    pub maxDecompressionIndirectCount: uint64_t,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceMemoryDecompressionPropertiesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_EXT);
impl_extends!(VkPhysicalDeviceMemoryDecompressionPropertiesEXT : VkPhysicalDeviceProperties2);

/// `VkPhysicalDeviceMemoryDecompressionPropertiesEXT`
pub type VkPhysicalDeviceMemoryDecompressionPropertiesNV = VkPhysicalDeviceMemoryDecompressionPropertiesEXT;

/// `VkPhysicalDeviceMemoryPriorityFeaturesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceMemoryPriorityFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub memoryPriority: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceMemoryPriorityFeaturesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT);
impl_extends!(VkPhysicalDeviceMemoryPriorityFeaturesEXT : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceMemoryProperties`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceMemoryProperties {
    pub memoryTypeCount: uint32_t,
    pub memoryTypes: [VkMemoryType; VK_MAX_MEMORY_TYPES as usize],
    pub memoryHeapCount: uint32_t,
    pub memoryHeaps: [VkMemoryHeap; VK_MAX_MEMORY_HEAPS as usize],
}
impl_default_zeroed!(VkPhysicalDeviceMemoryProperties);

/// `VkPhysicalDeviceMemoryProperties2`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceMemoryProperties2 {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub memoryProperties: VkPhysicalDeviceMemoryProperties,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceMemoryProperties2 : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2);

/// `VkPhysicalDeviceMemoryProperties2`
pub type VkPhysicalDeviceMemoryProperties2KHR = VkPhysicalDeviceMemoryProperties2;

/// `VkPhysicalDeviceMeshShaderFeaturesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceMeshShaderFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub taskShader: VkBool32,
    pub meshShader: VkBool32,
    pub multiviewMeshShader: VkBool32,
    pub primitiveFragmentShadingRateMeshShader: VkBool32,
    pub meshShaderQueries: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceMeshShaderFeaturesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT);
impl_extends!(VkPhysicalDeviceMeshShaderFeaturesEXT : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceMeshShaderFeaturesNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceMeshShaderFeaturesNV {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub taskShader: VkBool32,
    pub meshShader: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceMeshShaderFeaturesNV : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV);
impl_extends!(VkPhysicalDeviceMeshShaderFeaturesNV : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceMeshShaderPropertiesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceMeshShaderPropertiesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub maxTaskWorkGroupTotalCount: uint32_t,
    pub maxTaskWorkGroupCount: [uint32_t; 3 as usize],
    pub maxTaskWorkGroupInvocations: uint32_t,
    pub maxTaskWorkGroupSize: [uint32_t; 3 as usize],
    pub maxTaskPayloadSize: uint32_t,
    pub maxTaskSharedMemorySize: uint32_t,
    pub maxTaskPayloadAndSharedMemorySize: uint32_t,
    pub maxMeshWorkGroupTotalCount: uint32_t,
    pub maxMeshWorkGroupCount: [uint32_t; 3 as usize],
    pub maxMeshWorkGroupInvocations: uint32_t,
    pub maxMeshWorkGroupSize: [uint32_t; 3 as usize],
    pub maxMeshSharedMemorySize: uint32_t,
    pub maxMeshPayloadAndSharedMemorySize: uint32_t,
    pub maxMeshOutputMemorySize: uint32_t,
    pub maxMeshPayloadAndOutputMemorySize: uint32_t,
    pub maxMeshOutputComponents: uint32_t,
    pub maxMeshOutputVertices: uint32_t,
    pub maxMeshOutputPrimitives: uint32_t,
    pub maxMeshOutputLayers: uint32_t,
    pub maxMeshMultiviewViewCount: uint32_t,
    pub meshOutputPerVertexGranularity: uint32_t,
    pub meshOutputPerPrimitiveGranularity: uint32_t,
    pub maxPreferredTaskWorkGroupInvocations: uint32_t,
    pub maxPreferredMeshWorkGroupInvocations: uint32_t,
    pub prefersLocalInvocationVertexOutput: VkBool32,
    pub prefersLocalInvocationPrimitiveOutput: VkBool32,
    pub prefersCompactVertexOutput: VkBool32,
    pub prefersCompactPrimitiveOutput: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceMeshShaderPropertiesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT);
impl_extends!(VkPhysicalDeviceMeshShaderPropertiesEXT : VkPhysicalDeviceProperties2);

/// `VkPhysicalDeviceMeshShaderPropertiesNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceMeshShaderPropertiesNV {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub maxDrawMeshTasksCount: uint32_t,
    pub maxTaskWorkGroupInvocations: uint32_t,
    pub maxTaskWorkGroupSize: [uint32_t; 3 as usize],
    pub maxTaskTotalMemorySize: uint32_t,
    pub maxTaskOutputCount: uint32_t,
    pub maxMeshWorkGroupInvocations: uint32_t,
    pub maxMeshWorkGroupSize: [uint32_t; 3 as usize],
    pub maxMeshTotalMemorySize: uint32_t,
    pub maxMeshOutputVertices: uint32_t,
    pub maxMeshOutputPrimitives: uint32_t,
    pub maxMeshMultiviewViewCount: uint32_t,
    pub meshOutputPerVertexGranularity: uint32_t,
    pub meshOutputPerPrimitiveGranularity: uint32_t,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceMeshShaderPropertiesNV : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV);
impl_extends!(VkPhysicalDeviceMeshShaderPropertiesNV : VkPhysicalDeviceProperties2);

/// `VkPhysicalDeviceMultiDrawFeaturesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceMultiDrawFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub multiDraw: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceMultiDrawFeaturesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT);
impl_extends!(VkPhysicalDeviceMultiDrawFeaturesEXT : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceMultiDrawPropertiesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceMultiDrawPropertiesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub maxMultiDrawCount: uint32_t,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceMultiDrawPropertiesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT);
impl_extends!(VkPhysicalDeviceMultiDrawPropertiesEXT : VkPhysicalDeviceProperties2);

/// `VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub multisampledRenderToSingleSampled: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT);
impl_extends!(VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceMultiviewFeatures`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceMultiviewFeatures {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    /// Multiple views in a render pass
    pub multiview: VkBool32,
    /// Multiple views in a render pass w/ geometry shader
    pub multiviewGeometryShader: VkBool32,
    /// Multiple views in a render pass w/ tessellation shader
    pub multiviewTessellationShader: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceMultiviewFeatures : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES);
impl_extends!(VkPhysicalDeviceMultiviewFeatures : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceMultiviewFeatures`
pub type VkPhysicalDeviceMultiviewFeaturesKHR = VkPhysicalDeviceMultiviewFeatures;

/// `VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub perViewPositionAllComponents: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX);
impl_extends!(VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX : VkPhysicalDeviceProperties2);

/// `VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub multiviewPerViewRenderAreas: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM);
impl_extends!(VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub multiviewPerViewViewports: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM);
impl_extends!(VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceMultiviewProperties`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceMultiviewProperties {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    /// max number of views in a subpass
    pub maxMultiviewViewCount: uint32_t,
    /// max instance index for a draw in a multiview subpass
    pub maxMultiviewInstanceIndex: uint32_t,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceMultiviewProperties : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES);
impl_extends!(VkPhysicalDeviceMultiviewProperties : VkPhysicalDeviceProperties2);

/// `VkPhysicalDeviceMultiviewProperties`
pub type VkPhysicalDeviceMultiviewPropertiesKHR = VkPhysicalDeviceMultiviewProperties;

/// `VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub mutableDescriptorType: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT);
impl_extends!(VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT`
pub type VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE = VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT;

/// `VkPhysicalDeviceNestedCommandBufferFeaturesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceNestedCommandBufferFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub nestedCommandBuffer: VkBool32,
    pub nestedCommandBufferRendering: VkBool32,
    pub nestedCommandBufferSimultaneousUse: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceNestedCommandBufferFeaturesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT);
impl_extends!(VkPhysicalDeviceNestedCommandBufferFeaturesEXT : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceNestedCommandBufferPropertiesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceNestedCommandBufferPropertiesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub maxCommandBufferNestingLevel: uint32_t,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceNestedCommandBufferPropertiesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_PROPERTIES_EXT);
impl_extends!(VkPhysicalDeviceNestedCommandBufferPropertiesEXT : VkPhysicalDeviceProperties2);

/// `VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub nonSeamlessCubeMap: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT);
impl_extends!(VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceOpacityMicromapFeaturesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceOpacityMicromapFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub micromap: VkBool32,
    pub micromapCaptureReplay: VkBool32,
    pub micromapHostCommands: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceOpacityMicromapFeaturesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT);
impl_extends!(VkPhysicalDeviceOpacityMicromapFeaturesEXT : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceOpacityMicromapPropertiesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceOpacityMicromapPropertiesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub maxOpacity2StateSubdivisionLevel: uint32_t,
    pub maxOpacity4StateSubdivisionLevel: uint32_t,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceOpacityMicromapPropertiesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT);
impl_extends!(VkPhysicalDeviceOpacityMicromapPropertiesEXT : VkPhysicalDeviceProperties2);

/// `VkPhysicalDeviceOpticalFlowFeaturesNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceOpticalFlowFeaturesNV {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub opticalFlow: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceOpticalFlowFeaturesNV : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV);
impl_extends!(VkPhysicalDeviceOpticalFlowFeaturesNV : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceOpticalFlowPropertiesNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceOpticalFlowPropertiesNV {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub supportedOutputGridSizes: VkOpticalFlowGridSizeFlagsNV,
    pub supportedHintGridSizes: VkOpticalFlowGridSizeFlagsNV,
    pub hintSupported: VkBool32,
    pub costSupported: VkBool32,
    pub bidirectionalFlowSupported: VkBool32,
    pub globalFlowSupported: VkBool32,
    pub minWidth: uint32_t,
    pub minHeight: uint32_t,
    pub maxWidth: uint32_t,
    pub maxHeight: uint32_t,
    pub maxNumRegionsOfInterest: uint32_t,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceOpticalFlowPropertiesNV : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV);
impl_extends!(VkPhysicalDeviceOpticalFlowPropertiesNV : VkPhysicalDeviceProperties2);

/// `VkPhysicalDevicePCIBusInfoPropertiesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDevicePCIBusInfoPropertiesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub pciDomain: uint32_t,
    pub pciBus: uint32_t,
    pub pciDevice: uint32_t,
    pub pciFunction: uint32_t,
}
impl_default_zeroed_with_s_type!(VkPhysicalDevicePCIBusInfoPropertiesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT);
impl_extends!(VkPhysicalDevicePCIBusInfoPropertiesEXT : VkPhysicalDeviceProperties2);

/// `VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub pageableDeviceLocalMemory: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT);
impl_extends!(VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub partitionedAccelerationStructure: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_FEATURES_NV);
impl_extends!(VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub maxPartitionCount: uint32_t,
}
impl_default_zeroed_with_s_type!(VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_PROPERTIES_NV);
impl_extends!(VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV : VkPhysicalDeviceProperties2);

/// `VkPhysicalDevicePerStageDescriptorSetFeaturesNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDevicePerStageDescriptorSetFeaturesNV {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub perStageDescriptorSet: VkBool32,
    pub dynamicPipelineLayout: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDevicePerStageDescriptorSetFeaturesNV : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV);
impl_extends!(VkPhysicalDevicePerStageDescriptorSetFeaturesNV : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDevicePerformanceCountersByRegionFeaturesARM`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDevicePerformanceCountersByRegionFeaturesARM {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub performanceCountersByRegion: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDevicePerformanceCountersByRegionFeaturesARM : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_COUNTERS_BY_REGION_FEATURES_ARM);
impl_extends!(VkPhysicalDevicePerformanceCountersByRegionFeaturesARM : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDevicePerformanceCountersByRegionPropertiesARM`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDevicePerformanceCountersByRegionPropertiesARM {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub maxPerRegionPerformanceCounters: uint32_t,
    pub performanceCounterRegionSize: VkExtent2D,
    pub rowStrideAlignment: uint32_t,
    pub regionAlignment: uint32_t,
    pub identityTransformOrder: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDevicePerformanceCountersByRegionPropertiesARM : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_COUNTERS_BY_REGION_PROPERTIES_ARM);
impl_extends!(VkPhysicalDevicePerformanceCountersByRegionPropertiesARM : VkPhysicalDeviceProperties2);

/// `VkPhysicalDevicePerformanceQueryFeaturesKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDevicePerformanceQueryFeaturesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    /// performance counters supported in query pools
    pub performanceCounterQueryPools: VkBool32,
    /// performance counters from multiple query pools can be accessed in the same primary command buffer
    pub performanceCounterMultipleQueryPools: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDevicePerformanceQueryFeaturesKHR : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR);
impl_extends!(VkPhysicalDevicePerformanceQueryFeaturesKHR : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDevicePerformanceQueryPropertiesKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDevicePerformanceQueryPropertiesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    /// Flag to specify whether performance queries are allowed to be used in vkCmdCopyQueryPoolResults
    pub allowCommandBufferQueryCopies: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDevicePerformanceQueryPropertiesKHR : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR);
impl_extends!(VkPhysicalDevicePerformanceQueryPropertiesKHR : VkPhysicalDeviceProperties2);

/// `VkPhysicalDevicePipelineBinaryFeaturesKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDevicePipelineBinaryFeaturesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub pipelineBinaries: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDevicePipelineBinaryFeaturesKHR : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR);
impl_extends!(VkPhysicalDevicePipelineBinaryFeaturesKHR : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDevicePipelineBinaryPropertiesKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDevicePipelineBinaryPropertiesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub pipelineBinaryInternalCache: VkBool32,
    pub pipelineBinaryInternalCacheControl: VkBool32,
    pub pipelineBinaryPrefersInternalCache: VkBool32,
    pub pipelineBinaryPrecompiledInternalCache: VkBool32,
    pub pipelineBinaryCompressedData: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDevicePipelineBinaryPropertiesKHR : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_PROPERTIES_KHR);
impl_extends!(VkPhysicalDevicePipelineBinaryPropertiesKHR : VkPhysicalDeviceProperties2);

/// `VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub pipelineCacheIncrementalMode: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CACHE_INCREMENTAL_MODE_FEATURES_SEC);
impl_extends!(VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDevicePipelineCreationCacheControlFeatures`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDevicePipelineCreationCacheControlFeatures {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub pipelineCreationCacheControl: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDevicePipelineCreationCacheControlFeatures : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES);
impl_extends!(VkPhysicalDevicePipelineCreationCacheControlFeatures : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDevicePipelineCreationCacheControlFeatures`
pub type VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT = VkPhysicalDevicePipelineCreationCacheControlFeatures;

/// `VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub pipelineExecutableInfo: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR);
impl_extends!(VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub pipelineLibraryGroupHandles: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT);
impl_extends!(VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDevicePipelineOpacityMicromapFeaturesARM`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDevicePipelineOpacityMicromapFeaturesARM {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub pipelineOpacityMicromap: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDevicePipelineOpacityMicromapFeaturesARM : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_OPACITY_MICROMAP_FEATURES_ARM);
impl_extends!(VkPhysicalDevicePipelineOpacityMicromapFeaturesARM : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDevicePipelinePropertiesFeaturesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDevicePipelinePropertiesFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub pipelinePropertiesIdentifier: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDevicePipelinePropertiesFeaturesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT);
impl_extends!(VkPhysicalDevicePipelinePropertiesFeaturesEXT : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDevicePipelineProtectedAccessFeatures`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDevicePipelineProtectedAccessFeatures {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub pipelineProtectedAccess: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDevicePipelineProtectedAccessFeatures : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES);
impl_extends!(VkPhysicalDevicePipelineProtectedAccessFeatures : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDevicePipelineProtectedAccessFeatures`
pub type VkPhysicalDevicePipelineProtectedAccessFeaturesEXT = VkPhysicalDevicePipelineProtectedAccessFeatures;

/// `VkPhysicalDevicePipelineRobustnessFeatures`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDevicePipelineRobustnessFeatures {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub pipelineRobustness: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDevicePipelineRobustnessFeatures : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES);
impl_extends!(VkPhysicalDevicePipelineRobustnessFeatures : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDevicePipelineRobustnessFeatures`
pub type VkPhysicalDevicePipelineRobustnessFeaturesEXT = VkPhysicalDevicePipelineRobustnessFeatures;

/// `VkPhysicalDevicePipelineRobustnessProperties`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDevicePipelineRobustnessProperties {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub defaultRobustnessStorageBuffers: VkPipelineRobustnessBufferBehavior,
    pub defaultRobustnessUniformBuffers: VkPipelineRobustnessBufferBehavior,
    pub defaultRobustnessVertexInputs: VkPipelineRobustnessBufferBehavior,
    pub defaultRobustnessImages: VkPipelineRobustnessImageBehavior,
}
impl_default_zeroed_with_s_type!(VkPhysicalDevicePipelineRobustnessProperties : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES);
impl_extends!(VkPhysicalDevicePipelineRobustnessProperties : VkPhysicalDeviceProperties2);

/// `VkPhysicalDevicePipelineRobustnessProperties`
pub type VkPhysicalDevicePipelineRobustnessPropertiesEXT = VkPhysicalDevicePipelineRobustnessProperties;

/// `VkPhysicalDevicePointClippingProperties`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDevicePointClippingProperties {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub pointClippingBehavior: VkPointClippingBehavior,
}
impl_default_zeroed_with_s_type!(VkPhysicalDevicePointClippingProperties : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES);
impl_extends!(VkPhysicalDevicePointClippingProperties : VkPhysicalDeviceProperties2);

/// `VkPhysicalDevicePointClippingProperties`
pub type VkPhysicalDevicePointClippingPropertiesKHR = VkPhysicalDevicePointClippingProperties;

/// `VkPhysicalDevicePortabilitySubsetFeaturesKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDevicePortabilitySubsetFeaturesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub constantAlphaColorBlendFactors: VkBool32,
    pub events: VkBool32,
    pub imageViewFormatReinterpretation: VkBool32,
    pub imageViewFormatSwizzle: VkBool32,
    pub imageView2DOn3DImage: VkBool32,
    pub multisampleArrayImage: VkBool32,
    pub mutableComparisonSamplers: VkBool32,
    pub pointPolygons: VkBool32,
    pub samplerMipLodBias: VkBool32,
    pub separateStencilMaskRef: VkBool32,
    pub shaderSampleRateInterpolationFunctions: VkBool32,
    pub tessellationIsolines: VkBool32,
    pub tessellationPointMode: VkBool32,
    pub triangleFans: VkBool32,
    pub vertexAttributeAccessBeyondStride: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDevicePortabilitySubsetFeaturesKHR : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR);
impl_extends!(VkPhysicalDevicePortabilitySubsetFeaturesKHR : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDevicePortabilitySubsetPropertiesKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDevicePortabilitySubsetPropertiesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub minVertexInputBindingStrideAlignment: uint32_t,
}
impl_default_zeroed_with_s_type!(VkPhysicalDevicePortabilitySubsetPropertiesKHR : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR);
impl_extends!(VkPhysicalDevicePortabilitySubsetPropertiesKHR : VkPhysicalDeviceProperties2);

/// `VkPhysicalDevicePresentBarrierFeaturesNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDevicePresentBarrierFeaturesNV {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub presentBarrier: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDevicePresentBarrierFeaturesNV : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV);
impl_extends!(VkPhysicalDevicePresentBarrierFeaturesNV : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDevicePresentId2FeaturesKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDevicePresentId2FeaturesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    /// Present ID2 in VkPresentInfoKHR
    pub presentId2: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDevicePresentId2FeaturesKHR : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR);
impl_extends!(VkPhysicalDevicePresentId2FeaturesKHR : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDevicePresentIdFeaturesKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDevicePresentIdFeaturesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    /// Present ID in VkPresentInfoKHR
    pub presentId: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDevicePresentIdFeaturesKHR : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR);
impl_extends!(VkPhysicalDevicePresentIdFeaturesKHR : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDevicePresentMeteringFeaturesNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDevicePresentMeteringFeaturesNV {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub presentMetering: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDevicePresentMeteringFeaturesNV : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_METERING_FEATURES_NV);
impl_extends!(VkPhysicalDevicePresentMeteringFeaturesNV : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR`
pub type VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT = VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR;

/// `VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub presentModeFifoLatestReady: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR);
impl_extends!(VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDevicePresentTimingFeaturesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDevicePresentTimingFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    /// vkGetPastPresentationTimingEXT is supported
    pub presentTiming: VkBool32,
    /// Absolute time can be used to specify present time
    pub presentAtAbsoluteTime: VkBool32,
    /// Relative time can be used to specify present duration
    pub presentAtRelativeTime: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDevicePresentTimingFeaturesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_TIMING_FEATURES_EXT);
impl_extends!(VkPhysicalDevicePresentTimingFeaturesEXT : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDevicePresentWait2FeaturesKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDevicePresentWait2FeaturesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    /// vkWaitForPresent2KHR is supported
    pub presentWait2: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDevicePresentWait2FeaturesKHR : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR);
impl_extends!(VkPhysicalDevicePresentWait2FeaturesKHR : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDevicePresentWaitFeaturesKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDevicePresentWaitFeaturesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    /// vkWaitForPresentKHR is supported
    pub presentWait: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDevicePresentWaitFeaturesKHR : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR);
impl_extends!(VkPhysicalDevicePresentWaitFeaturesKHR : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDevicePresentationPropertiesANDROID`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDevicePresentationPropertiesANDROID {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub sharedImage: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDevicePresentationPropertiesANDROID : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENTATION_PROPERTIES_ANDROID);
impl_extends!(VkPhysicalDevicePresentationPropertiesANDROID : VkPhysicalDeviceProperties2);

/// `VkPhysicalDevicePresentationPropertiesOHOS`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDevicePresentationPropertiesOHOS {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub sharedImage: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDevicePresentationPropertiesOHOS : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENTATION_PROPERTIES_OHOS);
impl_extends!(VkPhysicalDevicePresentationPropertiesOHOS : VkPhysicalDeviceProperties2);

/// `VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub primitiveTopologyListRestart: VkBool32,
    pub primitiveTopologyPatchListRestart: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT);
impl_extends!(VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub primitivesGeneratedQuery: VkBool32,
    pub primitivesGeneratedQueryWithRasterizerDiscard: VkBool32,
    pub primitivesGeneratedQueryWithNonZeroStreams: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT);
impl_extends!(VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDevicePrivateDataFeatures`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDevicePrivateDataFeatures {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub privateData: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDevicePrivateDataFeatures : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES);
impl_extends!(VkPhysicalDevicePrivateDataFeatures : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDevicePrivateDataFeatures`
pub type VkPhysicalDevicePrivateDataFeaturesEXT = VkPhysicalDevicePrivateDataFeatures;

/// `VkPhysicalDeviceProperties`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceProperties {
    pub apiVersion: uint32_t,
    pub driverVersion: uint32_t,
    pub vendorID: uint32_t,
    pub deviceID: uint32_t,
    pub deviceType: VkPhysicalDeviceType,
    pub deviceName: [c_char; VK_MAX_PHYSICAL_DEVICE_NAME_SIZE as usize],
    pub pipelineCacheUUID: [uint8_t; VK_UUID_SIZE as usize],
    pub limits: VkPhysicalDeviceLimits,
    pub sparseProperties: VkPhysicalDeviceSparseProperties,
}
impl_default_zeroed!(VkPhysicalDeviceProperties);

/// `VkPhysicalDeviceProperties2`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceProperties2 {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub properties: VkPhysicalDeviceProperties,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceProperties2 : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2);

/// `VkPhysicalDeviceProperties2`
pub type VkPhysicalDeviceProperties2KHR = VkPhysicalDeviceProperties2;

/// `VkPhysicalDeviceProtectedMemoryFeatures`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceProtectedMemoryFeatures {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub protectedMemory: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceProtectedMemoryFeatures : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES);
impl_extends!(VkPhysicalDeviceProtectedMemoryFeatures : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceProtectedMemoryProperties`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceProtectedMemoryProperties {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub protectedNoFault: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceProtectedMemoryProperties : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES);
impl_extends!(VkPhysicalDeviceProtectedMemoryProperties : VkPhysicalDeviceProperties2);

/// `VkPhysicalDeviceProvokingVertexFeaturesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceProvokingVertexFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub provokingVertexLast: VkBool32,
    pub transformFeedbackPreservesProvokingVertex: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceProvokingVertexFeaturesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT);
impl_extends!(VkPhysicalDeviceProvokingVertexFeaturesEXT : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceProvokingVertexPropertiesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceProvokingVertexPropertiesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub provokingVertexModePerPipeline: VkBool32,
    pub transformFeedbackPreservesTriangleFanProvokingVertex: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceProvokingVertexPropertiesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT);
impl_extends!(VkPhysicalDeviceProvokingVertexPropertiesEXT : VkPhysicalDeviceProperties2);

/// `VkPhysicalDevicePushConstantBankFeaturesNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDevicePushConstantBankFeaturesNV {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub pushConstantBank: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDevicePushConstantBankFeaturesNV : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_CONSTANT_BANK_FEATURES_NV);
impl_extends!(VkPhysicalDevicePushConstantBankFeaturesNV : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDevicePushConstantBankPropertiesNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDevicePushConstantBankPropertiesNV {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub maxGraphicsPushConstantBanks: uint32_t,
    pub maxComputePushConstantBanks: uint32_t,
    pub maxGraphicsPushDataBanks: uint32_t,
    pub maxComputePushDataBanks: uint32_t,
}
impl_default_zeroed_with_s_type!(VkPhysicalDevicePushConstantBankPropertiesNV : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_CONSTANT_BANK_PROPERTIES_NV);
impl_extends!(VkPhysicalDevicePushConstantBankPropertiesNV : VkPhysicalDeviceProperties2);

/// `VkPhysicalDevicePushDescriptorProperties`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDevicePushDescriptorProperties {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub maxPushDescriptors: uint32_t,
}
impl_default_zeroed_with_s_type!(VkPhysicalDevicePushDescriptorProperties : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES);
impl_extends!(VkPhysicalDevicePushDescriptorProperties : VkPhysicalDeviceProperties2);

/// `VkPhysicalDevicePushDescriptorProperties`
pub type VkPhysicalDevicePushDescriptorPropertiesKHR = VkPhysicalDevicePushDescriptorProperties;

/// `VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub queueFamilyIndex: uint32_t,
    pub engineType: VkPhysicalDeviceDataGraphProcessingEngineTypeARM,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_QUEUE_FAMILY_DATA_GRAPH_PROCESSING_ENGINE_INFO_ARM);

/// `VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub formatRgba10x6WithoutYCbCrSampler: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT);
impl_extends!(VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT`
pub type VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM = VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT;

/// `VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub rasterizationOrderColorAttachmentAccess: VkBool32,
    pub rasterizationOrderDepthAttachmentAccess: VkBool32,
    pub rasterizationOrderStencilAttachmentAccess: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT);
impl_extends!(VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceRawAccessChainsFeaturesNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceRawAccessChainsFeaturesNV {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub shaderRawAccessChains: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceRawAccessChainsFeaturesNV : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV);
impl_extends!(VkPhysicalDeviceRawAccessChainsFeaturesNV : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceRayQueryFeaturesKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceRayQueryFeaturesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub rayQuery: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceRayQueryFeaturesKHR : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR);
impl_extends!(VkPhysicalDeviceRayQueryFeaturesKHR : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub rayTracingInvocationReorder: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_EXT);
impl_extends!(VkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub rayTracingInvocationReorder: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV);
impl_extends!(VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceRayTracingInvocationReorderPropertiesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceRayTracingInvocationReorderPropertiesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub rayTracingInvocationReorderReorderingHint: VkRayTracingInvocationReorderModeEXT,
    pub maxShaderBindingTableRecordIndex: uint32_t,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceRayTracingInvocationReorderPropertiesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_EXT);
impl_extends!(VkPhysicalDeviceRayTracingInvocationReorderPropertiesEXT : VkPhysicalDeviceProperties2);

/// `VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub rayTracingInvocationReorderReorderingHint: VkRayTracingInvocationReorderModeEXT,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV);
impl_extends!(VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV : VkPhysicalDeviceProperties2);

/// `VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub spheres: VkBool32,
    pub linearSweptSpheres: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_LINEAR_SWEPT_SPHERES_FEATURES_NV);
impl_extends!(VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub rayTracingMaintenance1: VkBool32,
    pub rayTracingPipelineTraceRaysIndirect2: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR);
impl_extends!(VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceRayTracingMotionBlurFeaturesNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceRayTracingMotionBlurFeaturesNV {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub rayTracingMotionBlur: VkBool32,
    pub rayTracingMotionBlurPipelineTraceRaysIndirect: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceRayTracingMotionBlurFeaturesNV : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV);
impl_extends!(VkPhysicalDeviceRayTracingMotionBlurFeaturesNV : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceRayTracingPipelineFeaturesKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceRayTracingPipelineFeaturesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub rayTracingPipeline: VkBool32,
    pub rayTracingPipelineShaderGroupHandleCaptureReplay: VkBool32,
    pub rayTracingPipelineShaderGroupHandleCaptureReplayMixed: VkBool32,
    pub rayTracingPipelineTraceRaysIndirect: VkBool32,
    pub rayTraversalPrimitiveCulling: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceRayTracingPipelineFeaturesKHR : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR);
impl_extends!(VkPhysicalDeviceRayTracingPipelineFeaturesKHR : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceRayTracingPipelinePropertiesKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceRayTracingPipelinePropertiesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub shaderGroupHandleSize: uint32_t,
    pub maxRayRecursionDepth: uint32_t,
    pub maxShaderGroupStride: uint32_t,
    pub shaderGroupBaseAlignment: uint32_t,
    pub shaderGroupHandleCaptureReplaySize: uint32_t,
    pub maxRayDispatchInvocationCount: uint32_t,
    pub shaderGroupHandleAlignment: uint32_t,
    pub maxRayHitAttributeSize: uint32_t,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceRayTracingPipelinePropertiesKHR : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR);
impl_extends!(VkPhysicalDeviceRayTracingPipelinePropertiesKHR : VkPhysicalDeviceProperties2);

/// `VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub rayTracingPositionFetch: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR);
impl_extends!(VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceRayTracingPropertiesNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceRayTracingPropertiesNV {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub shaderGroupHandleSize: uint32_t,
    pub maxRecursionDepth: uint32_t,
    pub maxShaderGroupStride: uint32_t,
    pub shaderGroupBaseAlignment: uint32_t,
    pub maxGeometryCount: uint64_t,
    pub maxInstanceCount: uint64_t,
    pub maxTriangleCount: uint64_t,
    pub maxDescriptorSetAccelerationStructures: uint32_t,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceRayTracingPropertiesNV : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV);
impl_extends!(VkPhysicalDeviceRayTracingPropertiesNV : VkPhysicalDeviceProperties2);

/// `VkPhysicalDeviceRayTracingValidationFeaturesNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceRayTracingValidationFeaturesNV {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub rayTracingValidation: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceRayTracingValidationFeaturesNV : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV);
impl_extends!(VkPhysicalDeviceRayTracingValidationFeaturesNV : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub relaxedLineRasterization: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG);
impl_extends!(VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceRenderPassStripedFeaturesARM`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceRenderPassStripedFeaturesARM {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub renderPassStriped: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceRenderPassStripedFeaturesARM : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM);
impl_extends!(VkPhysicalDeviceRenderPassStripedFeaturesARM : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceRenderPassStripedPropertiesARM`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceRenderPassStripedPropertiesARM {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub renderPassStripeGranularity: VkExtent2D,
    pub maxRenderPassStripes: uint32_t,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceRenderPassStripedPropertiesARM : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_PROPERTIES_ARM);
impl_extends!(VkPhysicalDeviceRenderPassStripedPropertiesARM : VkPhysicalDeviceProperties2);

/// `VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub representativeFragmentTest: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV);
impl_extends!(VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceRobustness2FeaturesKHR`
pub type VkPhysicalDeviceRobustness2FeaturesEXT = VkPhysicalDeviceRobustness2FeaturesKHR;

/// `VkPhysicalDeviceRobustness2FeaturesKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceRobustness2FeaturesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub robustBufferAccess2: VkBool32,
    pub robustImageAccess2: VkBool32,
    pub nullDescriptor: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceRobustness2FeaturesKHR : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR);
impl_extends!(VkPhysicalDeviceRobustness2FeaturesKHR : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceRobustness2PropertiesKHR`
pub type VkPhysicalDeviceRobustness2PropertiesEXT = VkPhysicalDeviceRobustness2PropertiesKHR;

/// `VkPhysicalDeviceRobustness2PropertiesKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceRobustness2PropertiesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub robustStorageBufferAccessSizeAlignment: VkDeviceSize,
    pub robustUniformBufferAccessSizeAlignment: VkDeviceSize,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceRobustness2PropertiesKHR : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_KHR);
impl_extends!(VkPhysicalDeviceRobustness2PropertiesKHR : VkPhysicalDeviceProperties2);

/// `VkPhysicalDeviceSampleLocationsPropertiesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceSampleLocationsPropertiesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub sampleLocationSampleCounts: VkSampleCountFlags,
    pub maxSampleLocationGridSize: VkExtent2D,
    pub sampleLocationCoordinateRange: [float; 2 as usize],
    pub sampleLocationSubPixelBits: uint32_t,
    pub variableSampleLocations: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceSampleLocationsPropertiesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT);
impl_extends!(VkPhysicalDeviceSampleLocationsPropertiesEXT : VkPhysicalDeviceProperties2);

/// `VkPhysicalDeviceSamplerFilterMinmaxProperties`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceSamplerFilterMinmaxProperties {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub filterMinmaxSingleComponentFormats: VkBool32,
    pub filterMinmaxImageComponentMapping: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceSamplerFilterMinmaxProperties : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES);
impl_extends!(VkPhysicalDeviceSamplerFilterMinmaxProperties : VkPhysicalDeviceProperties2);

/// `VkPhysicalDeviceSamplerFilterMinmaxProperties`
pub type VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT = VkPhysicalDeviceSamplerFilterMinmaxProperties;

/// `VkPhysicalDeviceSamplerYcbcrConversionFeatures`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceSamplerYcbcrConversionFeatures {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    /// Sampler color conversion supported
    pub samplerYcbcrConversion: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceSamplerYcbcrConversionFeatures : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES);
impl_extends!(VkPhysicalDeviceSamplerYcbcrConversionFeatures : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceSamplerYcbcrConversionFeatures`
pub type VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR = VkPhysicalDeviceSamplerYcbcrConversionFeatures;

/// `VkPhysicalDeviceScalarBlockLayoutFeatures`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceScalarBlockLayoutFeatures {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub scalarBlockLayout: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceScalarBlockLayoutFeatures : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES);
impl_extends!(VkPhysicalDeviceScalarBlockLayoutFeatures : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceScalarBlockLayoutFeatures`
pub type VkPhysicalDeviceScalarBlockLayoutFeaturesEXT = VkPhysicalDeviceScalarBlockLayoutFeatures;

/// `VkPhysicalDeviceSchedulingControlsFeaturesARM`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceSchedulingControlsFeaturesARM {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub schedulingControls: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceSchedulingControlsFeaturesARM : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM);
impl_extends!(VkPhysicalDeviceSchedulingControlsFeaturesARM : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

flags!(VkPhysicalDeviceSchedulingControlsFlagsARM);
from_into_transparent!(VkPhysicalDeviceSchedulingControlsFlagsARM: i64);
/// `VkPhysicalDeviceSchedulingControlsFlagsARM`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkPhysicalDeviceSchedulingControlsFlagsARM(pub i64);

/// `1 << 0`  
pub const VK_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_SHADER_CORE_COUNT_ARM: VkPhysicalDeviceSchedulingControlsFlagsARM = VkPhysicalDeviceSchedulingControlsFlagsARM(1 << 0);

impl_flags_display!(VkPhysicalDeviceSchedulingControlsFlagsARM { VK_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_SHADER_CORE_COUNT_ARM });

/// `VkPhysicalDeviceSchedulingControlsPropertiesARM`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceSchedulingControlsPropertiesARM {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub schedulingControlsFlags: VkPhysicalDeviceSchedulingControlsFlagsARM,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceSchedulingControlsPropertiesARM : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_PROPERTIES_ARM);
impl_extends!(VkPhysicalDeviceSchedulingControlsPropertiesARM : VkPhysicalDeviceProperties2);

/// `VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub separateDepthStencilLayouts: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES);
impl_extends!(VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures`
pub type VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR = VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures;

/// `VkPhysicalDeviceShader64BitIndexingFeaturesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceShader64BitIndexingFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub shader64BitIndexing: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceShader64BitIndexingFeaturesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_64_BIT_INDEXING_FEATURES_EXT);
impl_extends!(VkPhysicalDeviceShader64BitIndexingFeaturesEXT : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub shaderFloat16VectorAtomics: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV);
impl_extends!(VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub shaderBufferFloat16Atomics: VkBool32,
    pub shaderBufferFloat16AtomicAdd: VkBool32,
    pub shaderBufferFloat16AtomicMinMax: VkBool32,
    pub shaderBufferFloat32AtomicMinMax: VkBool32,
    pub shaderBufferFloat64AtomicMinMax: VkBool32,
    pub shaderSharedFloat16Atomics: VkBool32,
    pub shaderSharedFloat16AtomicAdd: VkBool32,
    pub shaderSharedFloat16AtomicMinMax: VkBool32,
    pub shaderSharedFloat32AtomicMinMax: VkBool32,
    pub shaderSharedFloat64AtomicMinMax: VkBool32,
    pub shaderImageFloat32AtomicMinMax: VkBool32,
    pub sparseImageFloat32AtomicMinMax: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT);
impl_extends!(VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceShaderAtomicFloatFeaturesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceShaderAtomicFloatFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub shaderBufferFloat32Atomics: VkBool32,
    pub shaderBufferFloat32AtomicAdd: VkBool32,
    pub shaderBufferFloat64Atomics: VkBool32,
    pub shaderBufferFloat64AtomicAdd: VkBool32,
    pub shaderSharedFloat32Atomics: VkBool32,
    pub shaderSharedFloat32AtomicAdd: VkBool32,
    pub shaderSharedFloat64Atomics: VkBool32,
    pub shaderSharedFloat64AtomicAdd: VkBool32,
    pub shaderImageFloat32Atomics: VkBool32,
    pub shaderImageFloat32AtomicAdd: VkBool32,
    pub sparseImageFloat32Atomics: VkBool32,
    pub sparseImageFloat32AtomicAdd: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceShaderAtomicFloatFeaturesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT);
impl_extends!(VkPhysicalDeviceShaderAtomicFloatFeaturesEXT : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceShaderAtomicInt64Features`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceShaderAtomicInt64Features {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub shaderBufferInt64Atomics: VkBool32,
    pub shaderSharedInt64Atomics: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceShaderAtomicInt64Features : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES);
impl_extends!(VkPhysicalDeviceShaderAtomicInt64Features : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceShaderAtomicInt64Features`
pub type VkPhysicalDeviceShaderAtomicInt64FeaturesKHR = VkPhysicalDeviceShaderAtomicInt64Features;

/// `VkPhysicalDeviceShaderBfloat16FeaturesKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceShaderBfloat16FeaturesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub shaderBFloat16Type: VkBool32,
    pub shaderBFloat16DotProduct: VkBool32,
    pub shaderBFloat16CooperativeMatrix: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceShaderBfloat16FeaturesKHR : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_BFLOAT16_FEATURES_KHR);
impl_extends!(VkPhysicalDeviceShaderBfloat16FeaturesKHR : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceShaderClockFeaturesKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceShaderClockFeaturesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub shaderSubgroupClock: VkBool32,
    pub shaderDeviceClock: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceShaderClockFeaturesKHR : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR);
impl_extends!(VkPhysicalDeviceShaderClockFeaturesKHR : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub shaderCoreBuiltins: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM);
impl_extends!(VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub shaderCoreMask: uint64_t,
    pub shaderCoreCount: uint32_t,
    pub shaderWarpsPerCore: uint32_t,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM);
impl_extends!(VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM : VkPhysicalDeviceProperties2);

/// `VkPhysicalDeviceShaderCoreProperties2AMD`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceShaderCoreProperties2AMD {
    pub sType: VkStructureType,
    /// Pointer to next structure
    pub pNext: *mut void,
    /// features supported by the shader core
    pub shaderCoreFeatures: VkShaderCorePropertiesFlagsAMD,
    /// number of active compute units across all shader engines/arrays
    pub activeComputeUnitCount: uint32_t,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceShaderCoreProperties2AMD : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD);
impl_extends!(VkPhysicalDeviceShaderCoreProperties2AMD : VkPhysicalDeviceProperties2);

/// `VkPhysicalDeviceShaderCorePropertiesAMD`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceShaderCorePropertiesAMD {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    /// number of shader engines
    pub shaderEngineCount: uint32_t,
    /// number of shader arrays
    pub shaderArraysPerEngineCount: uint32_t,
    /// number of physical CUs per shader array
    pub computeUnitsPerShaderArray: uint32_t,
    /// number of SIMDs per compute unit
    pub simdPerComputeUnit: uint32_t,
    /// number of wavefront slots in each SIMD
    pub wavefrontsPerSimd: uint32_t,
    /// maximum number of threads per wavefront
    pub wavefrontSize: uint32_t,
    /// number of physical SGPRs per SIMD
    pub sgprsPerSimd: uint32_t,
    /// minimum number of SGPRs that can be allocated by a wave
    pub minSgprAllocation: uint32_t,
    /// number of available SGPRs
    pub maxSgprAllocation: uint32_t,
    /// SGPRs are allocated in groups of this size
    pub sgprAllocationGranularity: uint32_t,
    /// number of physical VGPRs per SIMD
    pub vgprsPerSimd: uint32_t,
    /// minimum number of VGPRs that can be allocated by a wave
    pub minVgprAllocation: uint32_t,
    /// number of available VGPRs
    pub maxVgprAllocation: uint32_t,
    /// VGPRs are allocated in groups of this size
    pub vgprAllocationGranularity: uint32_t,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceShaderCorePropertiesAMD : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD);
impl_extends!(VkPhysicalDeviceShaderCorePropertiesAMD : VkPhysicalDeviceProperties2);

/// `VkPhysicalDeviceShaderCorePropertiesARM`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceShaderCorePropertiesARM {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub pixelRate: uint32_t,
    pub texelRate: uint32_t,
    pub fmaRate: uint32_t,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceShaderCorePropertiesARM : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM);
impl_extends!(VkPhysicalDeviceShaderCorePropertiesARM : VkPhysicalDeviceProperties2);

/// `VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub shaderDemoteToHelperInvocation: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES);
impl_extends!(VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures`
pub type VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT = VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures;

/// `VkPhysicalDeviceShaderDrawParametersFeatures`
pub type VkPhysicalDeviceShaderDrawParameterFeatures = VkPhysicalDeviceShaderDrawParametersFeatures;

/// `VkPhysicalDeviceShaderDrawParametersFeatures`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceShaderDrawParametersFeatures {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub shaderDrawParameters: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceShaderDrawParametersFeatures : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES);
impl_extends!(VkPhysicalDeviceShaderDrawParametersFeatures : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub shaderEarlyAndLateFragmentTests: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD);
impl_extends!(VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceShaderEnqueueFeaturesAMDX`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceShaderEnqueueFeaturesAMDX {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub shaderEnqueue: VkBool32,
    pub shaderMeshEnqueue: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceShaderEnqueueFeaturesAMDX : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_FEATURES_AMDX);
impl_extends!(VkPhysicalDeviceShaderEnqueueFeaturesAMDX : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceShaderEnqueuePropertiesAMDX`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceShaderEnqueuePropertiesAMDX {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub maxExecutionGraphDepth: uint32_t,
    pub maxExecutionGraphShaderOutputNodes: uint32_t,
    pub maxExecutionGraphShaderPayloadSize: uint32_t,
    pub maxExecutionGraphShaderPayloadCount: uint32_t,
    pub executionGraphDispatchAddressAlignment: uint32_t,
    pub maxExecutionGraphWorkgroupCount: [uint32_t; 3 as usize],
    pub maxExecutionGraphWorkgroups: uint32_t,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceShaderEnqueuePropertiesAMDX : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_PROPERTIES_AMDX);
impl_extends!(VkPhysicalDeviceShaderEnqueuePropertiesAMDX : VkPhysicalDeviceProperties2);

/// `VkPhysicalDeviceShaderExpectAssumeFeatures`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceShaderExpectAssumeFeatures {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub shaderExpectAssume: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceShaderExpectAssumeFeatures : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES);
impl_extends!(VkPhysicalDeviceShaderExpectAssumeFeatures : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceShaderExpectAssumeFeatures`
pub type VkPhysicalDeviceShaderExpectAssumeFeaturesKHR = VkPhysicalDeviceShaderExpectAssumeFeatures;

/// `VkPhysicalDeviceShaderFloat16Int8Features`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceShaderFloat16Int8Features {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    /// 16-bit floats (halfs) in shaders
    pub shaderFloat16: VkBool32,
    /// 8-bit integers in shaders
    pub shaderInt8: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceShaderFloat16Int8Features : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES);
impl_extends!(VkPhysicalDeviceShaderFloat16Int8Features : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceShaderFloat16Int8Features`
pub type VkPhysicalDeviceShaderFloat16Int8FeaturesKHR = VkPhysicalDeviceShaderFloat16Int8Features;

/// `VkPhysicalDeviceShaderFloat8FeaturesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceShaderFloat8FeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub shaderFloat8: VkBool32,
    pub shaderFloat8CooperativeMatrix: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceShaderFloat8FeaturesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT);
impl_extends!(VkPhysicalDeviceShaderFloat8FeaturesEXT : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceShaderFloatControls2Features`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceShaderFloatControls2Features {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub shaderFloatControls2: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceShaderFloatControls2Features : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES);
impl_extends!(VkPhysicalDeviceShaderFloatControls2Features : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceShaderFloatControls2Features`
pub type VkPhysicalDeviceShaderFloatControls2FeaturesKHR = VkPhysicalDeviceShaderFloatControls2Features;

/// `VkPhysicalDeviceShaderFmaFeaturesKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceShaderFmaFeaturesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub shaderFmaFloat16: VkBool32,
    pub shaderFmaFloat32: VkBool32,
    pub shaderFmaFloat64: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceShaderFmaFeaturesKHR : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FMA_FEATURES_KHR);
impl_extends!(VkPhysicalDeviceShaderFmaFeaturesKHR : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub shaderImageInt64Atomics: VkBool32,
    pub sparseImageInt64Atomics: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT);
impl_extends!(VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceShaderImageFootprintFeaturesNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceShaderImageFootprintFeaturesNV {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub imageFootprint: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceShaderImageFootprintFeaturesNV : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV);
impl_extends!(VkPhysicalDeviceShaderImageFootprintFeaturesNV : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceShaderInstrumentationFeaturesARM`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceShaderInstrumentationFeaturesARM {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub shaderInstrumentation: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceShaderInstrumentationFeaturesARM : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INSTRUMENTATION_FEATURES_ARM);
impl_extends!(VkPhysicalDeviceShaderInstrumentationFeaturesARM : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceShaderInstrumentationPropertiesARM`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceShaderInstrumentationPropertiesARM {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub numMetrics: uint32_t,
    pub perBasicBlockGranularity: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceShaderInstrumentationPropertiesARM : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INSTRUMENTATION_PROPERTIES_ARM);
impl_extends!(VkPhysicalDeviceShaderInstrumentationPropertiesARM : VkPhysicalDeviceProperties2);

/// `VkPhysicalDeviceShaderIntegerDotProductFeatures`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceShaderIntegerDotProductFeatures {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub shaderIntegerDotProduct: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceShaderIntegerDotProductFeatures : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES);
impl_extends!(VkPhysicalDeviceShaderIntegerDotProductFeatures : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceShaderIntegerDotProductFeatures`
pub type VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR = VkPhysicalDeviceShaderIntegerDotProductFeatures;

/// `VkPhysicalDeviceShaderIntegerDotProductProperties`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceShaderIntegerDotProductProperties {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub integerDotProduct8BitUnsignedAccelerated: VkBool32,
    pub integerDotProduct8BitSignedAccelerated: VkBool32,
    pub integerDotProduct8BitMixedSignednessAccelerated: VkBool32,
    pub integerDotProduct4x8BitPackedUnsignedAccelerated: VkBool32,
    pub integerDotProduct4x8BitPackedSignedAccelerated: VkBool32,
    pub integerDotProduct4x8BitPackedMixedSignednessAccelerated: VkBool32,
    pub integerDotProduct16BitUnsignedAccelerated: VkBool32,
    pub integerDotProduct16BitSignedAccelerated: VkBool32,
    pub integerDotProduct16BitMixedSignednessAccelerated: VkBool32,
    pub integerDotProduct32BitUnsignedAccelerated: VkBool32,
    pub integerDotProduct32BitSignedAccelerated: VkBool32,
    pub integerDotProduct32BitMixedSignednessAccelerated: VkBool32,
    pub integerDotProduct64BitUnsignedAccelerated: VkBool32,
    pub integerDotProduct64BitSignedAccelerated: VkBool32,
    pub integerDotProduct64BitMixedSignednessAccelerated: VkBool32,
    pub integerDotProductAccumulatingSaturating8BitUnsignedAccelerated: VkBool32,
    pub integerDotProductAccumulatingSaturating8BitSignedAccelerated: VkBool32,
    pub integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated: VkBool32,
    pub integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated: VkBool32,
    pub integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated: VkBool32,
    pub integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated: VkBool32,
    pub integerDotProductAccumulatingSaturating16BitUnsignedAccelerated: VkBool32,
    pub integerDotProductAccumulatingSaturating16BitSignedAccelerated: VkBool32,
    pub integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated: VkBool32,
    pub integerDotProductAccumulatingSaturating32BitUnsignedAccelerated: VkBool32,
    pub integerDotProductAccumulatingSaturating32BitSignedAccelerated: VkBool32,
    pub integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated: VkBool32,
    pub integerDotProductAccumulatingSaturating64BitUnsignedAccelerated: VkBool32,
    pub integerDotProductAccumulatingSaturating64BitSignedAccelerated: VkBool32,
    pub integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceShaderIntegerDotProductProperties : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES);
impl_extends!(VkPhysicalDeviceShaderIntegerDotProductProperties : VkPhysicalDeviceProperties2);

/// `VkPhysicalDeviceShaderIntegerDotProductProperties`
pub type VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR = VkPhysicalDeviceShaderIntegerDotProductProperties;

/// `VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub shaderIntegerFunctions2: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL);
impl_extends!(VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceShaderLongVectorFeaturesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceShaderLongVectorFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub longVector: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceShaderLongVectorFeaturesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_LONG_VECTOR_FEATURES_EXT);
impl_extends!(VkPhysicalDeviceShaderLongVectorFeaturesEXT : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceShaderLongVectorPropertiesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceShaderLongVectorPropertiesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub maxVectorComponents: uint32_t,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceShaderLongVectorPropertiesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_LONG_VECTOR_PROPERTIES_EXT);
impl_extends!(VkPhysicalDeviceShaderLongVectorPropertiesEXT : VkPhysicalDeviceProperties2);

/// `VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub shaderMaximalReconvergence: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR);
impl_extends!(VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub shaderMixedFloatDotProductFloat16AccFloat32: VkBool32,
    pub shaderMixedFloatDotProductFloat16AccFloat16: VkBool32,
    pub shaderMixedFloatDotProductBFloat16Acc: VkBool32,
    pub shaderMixedFloatDotProductFloat8AccFloat32: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MIXED_FLOAT_DOT_PRODUCT_FEATURES_VALVE);
impl_extends!(VkPhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub shaderModuleIdentifier: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT);
impl_extends!(VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub shaderModuleIdentifierAlgorithmUUID: [uint8_t; VK_UUID_SIZE as usize],
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT);
impl_extends!(VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT : VkPhysicalDeviceProperties2);

/// `VkPhysicalDeviceShaderObjectFeaturesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceShaderObjectFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub shaderObject: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceShaderObjectFeaturesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT);
impl_extends!(VkPhysicalDeviceShaderObjectFeaturesEXT : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceShaderObjectPropertiesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceShaderObjectPropertiesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub shaderBinaryUUID: [uint8_t; VK_UUID_SIZE as usize],
    pub shaderBinaryVersion: uint32_t,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceShaderObjectPropertiesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT);
impl_extends!(VkPhysicalDeviceShaderObjectPropertiesEXT : VkPhysicalDeviceProperties2);

/// `VkPhysicalDeviceShaderQuadControlFeaturesKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceShaderQuadControlFeaturesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub shaderQuadControl: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceShaderQuadControlFeaturesKHR : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR);
impl_extends!(VkPhysicalDeviceShaderQuadControlFeaturesKHR : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub shaderRelaxedExtendedInstruction: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR);
impl_extends!(VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub shaderReplicatedComposites: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT);
impl_extends!(VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceShaderSMBuiltinsFeaturesNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceShaderSMBuiltinsFeaturesNV {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub shaderSMBuiltins: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceShaderSMBuiltinsFeaturesNV : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV);
impl_extends!(VkPhysicalDeviceShaderSMBuiltinsFeaturesNV : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceShaderSMBuiltinsPropertiesNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceShaderSMBuiltinsPropertiesNV {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub shaderSMCount: uint32_t,
    pub shaderWarpsPerSM: uint32_t,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceShaderSMBuiltinsPropertiesNV : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV);
impl_extends!(VkPhysicalDeviceShaderSMBuiltinsPropertiesNV : VkPhysicalDeviceProperties2);

/// `VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    /// Flag to specify whether subgroup operations with extended types are supported
    pub shaderSubgroupExtendedTypes: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES);
impl_extends!(VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures`
pub type VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR = VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures;

/// `VkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub shaderSubgroupPartitioned: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_PARTITIONED_FEATURES_EXT);
impl_extends!(VkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceShaderSubgroupRotateFeatures`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceShaderSubgroupRotateFeatures {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub shaderSubgroupRotate: VkBool32,
    pub shaderSubgroupRotateClustered: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceShaderSubgroupRotateFeatures : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES);
impl_extends!(VkPhysicalDeviceShaderSubgroupRotateFeatures : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceShaderSubgroupRotateFeatures`
pub type VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR = VkPhysicalDeviceShaderSubgroupRotateFeatures;

/// `VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub shaderSubgroupUniformControlFlow: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR);
impl_extends!(VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceShaderTerminateInvocationFeatures`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceShaderTerminateInvocationFeatures {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub shaderTerminateInvocation: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceShaderTerminateInvocationFeatures : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES);
impl_extends!(VkPhysicalDeviceShaderTerminateInvocationFeatures : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceShaderTerminateInvocationFeatures`
pub type VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR = VkPhysicalDeviceShaderTerminateInvocationFeatures;

/// `VkPhysicalDeviceShaderTileImageFeaturesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceShaderTileImageFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub shaderTileImageColorReadAccess: VkBool32,
    pub shaderTileImageDepthReadAccess: VkBool32,
    pub shaderTileImageStencilReadAccess: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceShaderTileImageFeaturesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT);
impl_extends!(VkPhysicalDeviceShaderTileImageFeaturesEXT : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceShaderTileImagePropertiesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceShaderTileImagePropertiesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub shaderTileImageCoherentReadAccelerated: VkBool32,
    pub shaderTileImageReadSampleFromPixelRateInvocation: VkBool32,
    pub shaderTileImageReadFromHelperInvocation: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceShaderTileImagePropertiesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT);
impl_extends!(VkPhysicalDeviceShaderTileImagePropertiesEXT : VkPhysicalDeviceProperties2);

/// `VkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub shaderUniformBufferUnsizedArray: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNIFORM_BUFFER_UNSIZED_ARRAY_FEATURES_EXT);
impl_extends!(VkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceShaderUntypedPointersFeaturesKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceShaderUntypedPointersFeaturesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub shaderUntypedPointers: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceShaderUntypedPointersFeaturesKHR : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES_KHR);
impl_extends!(VkPhysicalDeviceShaderUntypedPointersFeaturesKHR : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceShadingRateImageFeaturesNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceShadingRateImageFeaturesNV {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub shadingRateImage: VkBool32,
    pub shadingRateCoarseSampleOrder: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceShadingRateImageFeaturesNV : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV);
impl_extends!(VkPhysicalDeviceShadingRateImageFeaturesNV : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceShadingRateImagePropertiesNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceShadingRateImagePropertiesNV {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub shadingRateTexelSize: VkExtent2D,
    pub shadingRatePaletteSize: uint32_t,
    pub shadingRateMaxCoarseSamples: uint32_t,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceShadingRateImagePropertiesNV : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV);
impl_extends!(VkPhysicalDeviceShadingRateImagePropertiesNV : VkPhysicalDeviceProperties2);

/// `VkPhysicalDeviceSparseImageFormatInfo2`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceSparseImageFormatInfo2 {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub format: VkFormat,
    pub r#type: VkImageType,
    pub samples: VkSampleCountFlags,
    pub usage: VkImageUsageFlags,
    pub tiling: VkImageTiling,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceSparseImageFormatInfo2 : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2);

/// `VkPhysicalDeviceSparseImageFormatInfo2`
pub type VkPhysicalDeviceSparseImageFormatInfo2KHR = VkPhysicalDeviceSparseImageFormatInfo2;

/// `VkPhysicalDeviceSparseProperties`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceSparseProperties {
    /// Sparse resources support: GPU will access all 2D (single sample) sparse resources using the standard sparse image block shapes (based on pixel format)
    pub residencyStandard2DBlockShape: VkBool32,
    /// Sparse resources support: GPU will access all 2D (multisample) sparse resources using the standard sparse image block shapes (based on pixel format)
    pub residencyStandard2DMultisampleBlockShape: VkBool32,
    /// Sparse resources support: GPU will access all 3D sparse resources using the standard sparse image block shapes (based on pixel format)
    pub residencyStandard3DBlockShape: VkBool32,
    /// 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 residencyAlignedMipSize: VkBool32,
    /// 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 residencyNonResidentStrict: VkBool32,
}
impl_default_zeroed!(VkPhysicalDeviceSparseProperties);

/// `VkPhysicalDeviceSubgroupProperties`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceSubgroupProperties {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    /// The size of a subgroup for this queue.
    pub subgroupSize: uint32_t,
    /// Bitfield of what shader stages support subgroup operations
    pub supportedStages: VkShaderStageFlags,
    /// Bitfield of what subgroup operations are supported.
    pub supportedOperations: VkSubgroupFeatureFlags,
    /// Flag to specify whether quad operations are available in all stages.
    pub quadOperationsInAllStages: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceSubgroupProperties : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES);
impl_extends!(VkPhysicalDeviceSubgroupProperties : VkPhysicalDeviceProperties2);

/// `VkPhysicalDeviceSubgroupSizeControlFeatures`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceSubgroupSizeControlFeatures {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub subgroupSizeControl: VkBool32,
    pub computeFullSubgroups: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceSubgroupSizeControlFeatures : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES);
impl_extends!(VkPhysicalDeviceSubgroupSizeControlFeatures : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceSubgroupSizeControlFeatures`
pub type VkPhysicalDeviceSubgroupSizeControlFeaturesEXT = VkPhysicalDeviceSubgroupSizeControlFeatures;

/// `VkPhysicalDeviceSubgroupSizeControlProperties`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceSubgroupSizeControlProperties {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    /// The minimum subgroup size supported by this device
    pub minSubgroupSize: uint32_t,
    /// The maximum subgroup size supported by this device
    pub maxSubgroupSize: uint32_t,
    /// The maximum number of subgroups supported in a workgroup
    pub maxComputeWorkgroupSubgroups: uint32_t,
    /// The shader stages that support specifying a subgroup size
    pub requiredSubgroupSizeStages: VkShaderStageFlags,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceSubgroupSizeControlProperties : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES);
impl_extends!(VkPhysicalDeviceSubgroupSizeControlProperties : VkPhysicalDeviceProperties2);

/// `VkPhysicalDeviceSubgroupSizeControlProperties`
pub type VkPhysicalDeviceSubgroupSizeControlPropertiesEXT = VkPhysicalDeviceSubgroupSizeControlProperties;

/// `VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub subpassMergeFeedback: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT);
impl_extends!(VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceSubpassShadingFeaturesHUAWEI`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceSubpassShadingFeaturesHUAWEI {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub subpassShading: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceSubpassShadingFeaturesHUAWEI : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI);
impl_extends!(VkPhysicalDeviceSubpassShadingFeaturesHUAWEI : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceSubpassShadingPropertiesHUAWEI`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceSubpassShadingPropertiesHUAWEI {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub maxSubpassShadingWorkgroupSizeAspectRatio: uint32_t,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceSubpassShadingPropertiesHUAWEI : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI);
impl_extends!(VkPhysicalDeviceSubpassShadingPropertiesHUAWEI : VkPhysicalDeviceProperties2);

/// `VkPhysicalDeviceSurfaceInfo2KHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceSurfaceInfo2KHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub surface: VkSurfaceKHR,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceSurfaceInfo2KHR : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR);

/// `VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR`
pub type VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT = VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR;

/// `VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub swapchainMaintenance1: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR);
impl_extends!(VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceSynchronization2Features`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceSynchronization2Features {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub synchronization2: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceSynchronization2Features : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES);
impl_extends!(VkPhysicalDeviceSynchronization2Features : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceSynchronization2Features`
pub type VkPhysicalDeviceSynchronization2FeaturesKHR = VkPhysicalDeviceSynchronization2Features;

/// `VkPhysicalDeviceTensorFeaturesARM`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceTensorFeaturesARM {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub tensorNonPacked: VkBool32,
    pub shaderTensorAccess: VkBool32,
    pub shaderStorageTensorArrayDynamicIndexing: VkBool32,
    pub shaderStorageTensorArrayNonUniformIndexing: VkBool32,
    pub descriptorBindingStorageTensorUpdateAfterBind: VkBool32,
    pub tensors: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceTensorFeaturesARM : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_FEATURES_ARM);
impl_extends!(VkPhysicalDeviceTensorFeaturesARM : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceTensorPropertiesARM`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceTensorPropertiesARM {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub maxTensorDimensionCount: uint32_t,
    pub maxTensorElements: uint64_t,
    pub maxPerDimensionTensorElements: uint64_t,
    pub maxTensorStride: int64_t,
    pub maxTensorSize: uint64_t,
    pub maxTensorShaderAccessArrayLength: uint32_t,
    pub maxTensorShaderAccessSize: uint32_t,
    pub maxDescriptorSetStorageTensors: uint32_t,
    pub maxPerStageDescriptorSetStorageTensors: uint32_t,
    pub maxDescriptorSetUpdateAfterBindStorageTensors: uint32_t,
    pub maxPerStageDescriptorUpdateAfterBindStorageTensors: uint32_t,
    pub shaderStorageTensorArrayNonUniformIndexingNative: VkBool32,
    pub shaderTensorSupportedStages: VkShaderStageFlags,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceTensorPropertiesARM : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_PROPERTIES_ARM);
impl_extends!(VkPhysicalDeviceTensorPropertiesARM : VkPhysicalDeviceProperties2);

/// `VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub texelBufferAlignment: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT);
impl_extends!(VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceTexelBufferAlignmentProperties`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceTexelBufferAlignmentProperties {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub storageTexelBufferOffsetAlignmentBytes: VkDeviceSize,
    pub storageTexelBufferOffsetSingleTexelAlignment: VkBool32,
    pub uniformTexelBufferOffsetAlignmentBytes: VkDeviceSize,
    pub uniformTexelBufferOffsetSingleTexelAlignment: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceTexelBufferAlignmentProperties : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES);
impl_extends!(VkPhysicalDeviceTexelBufferAlignmentProperties : VkPhysicalDeviceProperties2);

/// `VkPhysicalDeviceTexelBufferAlignmentProperties`
pub type VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT = VkPhysicalDeviceTexelBufferAlignmentProperties;

/// `VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub textureCompressionASTC_3D: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_3D_FEATURES_EXT);
impl_extends!(VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceTextureCompressionASTCHDRFeatures`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceTextureCompressionASTCHDRFeatures {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub textureCompressionASTC_HDR: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceTextureCompressionASTCHDRFeatures : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES);
impl_extends!(VkPhysicalDeviceTextureCompressionASTCHDRFeatures : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceTextureCompressionASTCHDRFeatures`
pub type VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT = VkPhysicalDeviceTextureCompressionASTCHDRFeatures;

/// `VkPhysicalDeviceTileMemoryHeapFeaturesQCOM`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceTileMemoryHeapFeaturesQCOM {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub tileMemoryHeap: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceTileMemoryHeapFeaturesQCOM : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_FEATURES_QCOM);
impl_extends!(VkPhysicalDeviceTileMemoryHeapFeaturesQCOM : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceTileMemoryHeapPropertiesQCOM`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceTileMemoryHeapPropertiesQCOM {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub queueSubmitBoundary: VkBool32,
    pub tileBufferTransfers: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceTileMemoryHeapPropertiesQCOM : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_PROPERTIES_QCOM);
impl_extends!(VkPhysicalDeviceTileMemoryHeapPropertiesQCOM : VkPhysicalDeviceProperties2);

/// `VkPhysicalDeviceTilePropertiesFeaturesQCOM`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceTilePropertiesFeaturesQCOM {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub tileProperties: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceTilePropertiesFeaturesQCOM : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM);
impl_extends!(VkPhysicalDeviceTilePropertiesFeaturesQCOM : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceTileShadingFeaturesQCOM`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceTileShadingFeaturesQCOM {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub tileShading: VkBool32,
    pub tileShadingFragmentStage: VkBool32,
    pub tileShadingColorAttachments: VkBool32,
    pub tileShadingDepthAttachments: VkBool32,
    pub tileShadingStencilAttachments: VkBool32,
    pub tileShadingInputAttachments: VkBool32,
    pub tileShadingSampledAttachments: VkBool32,
    pub tileShadingPerTileDraw: VkBool32,
    pub tileShadingPerTileDispatch: VkBool32,
    pub tileShadingDispatchTile: VkBool32,
    pub tileShadingApron: VkBool32,
    pub tileShadingAnisotropicApron: VkBool32,
    pub tileShadingAtomicOps: VkBool32,
    pub tileShadingImageProcessing: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceTileShadingFeaturesQCOM : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_FEATURES_QCOM);
impl_extends!(VkPhysicalDeviceTileShadingFeaturesQCOM : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceTileShadingPropertiesQCOM`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceTileShadingPropertiesQCOM {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub maxApronSize: uint32_t,
    pub preferNonCoherent: VkBool32,
    pub tileGranularity: VkExtent2D,
    pub maxTileShadingRate: VkExtent2D,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceTileShadingPropertiesQCOM : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_PROPERTIES_QCOM);
impl_extends!(VkPhysicalDeviceTileShadingPropertiesQCOM : VkPhysicalDeviceProperties2);

/// `VkPhysicalDeviceTimelineSemaphoreFeatures`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceTimelineSemaphoreFeatures {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub timelineSemaphore: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceTimelineSemaphoreFeatures : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES);
impl_extends!(VkPhysicalDeviceTimelineSemaphoreFeatures : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceTimelineSemaphoreFeatures`
pub type VkPhysicalDeviceTimelineSemaphoreFeaturesKHR = VkPhysicalDeviceTimelineSemaphoreFeatures;

/// `VkPhysicalDeviceTimelineSemaphoreProperties`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceTimelineSemaphoreProperties {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub maxTimelineSemaphoreValueDifference: uint64_t,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceTimelineSemaphoreProperties : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES);
impl_extends!(VkPhysicalDeviceTimelineSemaphoreProperties : VkPhysicalDeviceProperties2);

/// `VkPhysicalDeviceTimelineSemaphoreProperties`
pub type VkPhysicalDeviceTimelineSemaphorePropertiesKHR = VkPhysicalDeviceTimelineSemaphoreProperties;

/// `VkPhysicalDeviceToolProperties`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceToolProperties {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub name: [c_char; VK_MAX_EXTENSION_NAME_SIZE as usize],
    pub version: [c_char; VK_MAX_EXTENSION_NAME_SIZE as usize],
    pub purposes: VkToolPurposeFlags,
    pub description: [c_char; VK_MAX_DESCRIPTION_SIZE as usize],
    pub layer: [c_char; VK_MAX_EXTENSION_NAME_SIZE as usize],
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceToolProperties : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES);

/// `VkPhysicalDeviceToolProperties`
pub type VkPhysicalDeviceToolPropertiesEXT = VkPhysicalDeviceToolProperties;

/// `VkPhysicalDeviceTransformFeedbackFeaturesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceTransformFeedbackFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub transformFeedback: VkBool32,
    pub geometryStreams: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceTransformFeedbackFeaturesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT);
impl_extends!(VkPhysicalDeviceTransformFeedbackFeaturesEXT : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceTransformFeedbackPropertiesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceTransformFeedbackPropertiesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub maxTransformFeedbackStreams: uint32_t,
    pub maxTransformFeedbackBuffers: uint32_t,
    pub maxTransformFeedbackBufferSize: VkDeviceSize,
    pub maxTransformFeedbackStreamDataSize: uint32_t,
    pub maxTransformFeedbackBufferDataSize: uint32_t,
    pub maxTransformFeedbackBufferDataStride: uint32_t,
    pub transformFeedbackQueries: VkBool32,
    pub transformFeedbackStreamsLinesTriangles: VkBool32,
    pub transformFeedbackRasterizationStreamSelect: VkBool32,
    pub transformFeedbackDraw: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceTransformFeedbackPropertiesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT);
impl_extends!(VkPhysicalDeviceTransformFeedbackPropertiesEXT : VkPhysicalDeviceProperties2);

from_into_transparent!(VkPhysicalDeviceType: i32);
/// `VkPhysicalDeviceType`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkPhysicalDeviceType(pub i32);

/// `0`  
pub const VK_PHYSICAL_DEVICE_TYPE_OTHER: VkPhysicalDeviceType = VkPhysicalDeviceType(0);
/// `1`  
pub const VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU: VkPhysicalDeviceType = VkPhysicalDeviceType(1);
/// `2`  
pub const VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU: VkPhysicalDeviceType = VkPhysicalDeviceType(2);
/// `3`  
pub const VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU: VkPhysicalDeviceType = VkPhysicalDeviceType(3);
/// `4`  
pub const VK_PHYSICAL_DEVICE_TYPE_CPU: VkPhysicalDeviceType = VkPhysicalDeviceType(4);

impl_enum_display!(VkPhysicalDeviceType { VK_PHYSICAL_DEVICE_TYPE_OTHER, VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU, VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU, VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU, VK_PHYSICAL_DEVICE_TYPE_CPU });

/// `VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub unifiedImageLayouts: VkBool32,
    pub unifiedImageLayoutsVideo: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR);
impl_extends!(VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceUniformBufferStandardLayoutFeatures`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceUniformBufferStandardLayoutFeatures {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub uniformBufferStandardLayout: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceUniformBufferStandardLayoutFeatures : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES);
impl_extends!(VkPhysicalDeviceUniformBufferStandardLayoutFeatures : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceUniformBufferStandardLayoutFeatures`
pub type VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR = VkPhysicalDeviceUniformBufferStandardLayoutFeatures;

/// `VkPhysicalDeviceVariablePointersFeatures`
pub type VkPhysicalDeviceVariablePointerFeatures = VkPhysicalDeviceVariablePointersFeatures;

/// `VkPhysicalDeviceVariablePointersFeatures`
pub type VkPhysicalDeviceVariablePointerFeaturesKHR = VkPhysicalDeviceVariablePointersFeatures;

/// `VkPhysicalDeviceVariablePointersFeatures`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceVariablePointersFeatures {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub variablePointersStorageBuffer: VkBool32,
    pub variablePointers: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceVariablePointersFeatures : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES);
impl_extends!(VkPhysicalDeviceVariablePointersFeatures : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceVariablePointersFeatures`
pub type VkPhysicalDeviceVariablePointersFeaturesKHR = VkPhysicalDeviceVariablePointersFeatures;

/// `VkPhysicalDeviceVertexAttributeDivisorFeatures`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceVertexAttributeDivisorFeatures {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub vertexAttributeInstanceRateDivisor: VkBool32,
    pub vertexAttributeInstanceRateZeroDivisor: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceVertexAttributeDivisorFeatures : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES);
impl_extends!(VkPhysicalDeviceVertexAttributeDivisorFeatures : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceVertexAttributeDivisorFeatures`
pub type VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT = VkPhysicalDeviceVertexAttributeDivisorFeatures;

/// `VkPhysicalDeviceVertexAttributeDivisorFeatures`
pub type VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR = VkPhysicalDeviceVertexAttributeDivisorFeatures;

/// `VkPhysicalDeviceVertexAttributeDivisorProperties`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceVertexAttributeDivisorProperties {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    /// max value of vertex attribute divisor
    pub maxVertexAttribDivisor: uint32_t,
    pub supportsNonZeroFirstInstance: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceVertexAttributeDivisorProperties : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES);
impl_extends!(VkPhysicalDeviceVertexAttributeDivisorProperties : VkPhysicalDeviceProperties2);

/// `VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    /// max value of vertex attribute divisor
    pub maxVertexAttribDivisor: uint32_t,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT);
impl_extends!(VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT : VkPhysicalDeviceProperties2);

/// `VkPhysicalDeviceVertexAttributeDivisorProperties`
pub type VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR = VkPhysicalDeviceVertexAttributeDivisorProperties;

/// `VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub vertexAttributeRobustness: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT);
impl_extends!(VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub vertexInputDynamicState: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT);
impl_extends!(VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceVideoDecodeVP9FeaturesKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceVideoDecodeVP9FeaturesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub videoDecodeVP9: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceVideoDecodeVP9FeaturesKHR : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR);
impl_extends!(VkPhysicalDeviceVideoDecodeVP9FeaturesKHR : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceVideoEncodeAV1FeaturesKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceVideoEncodeAV1FeaturesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub videoEncodeAV1: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceVideoEncodeAV1FeaturesKHR : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR);
impl_extends!(VkPhysicalDeviceVideoEncodeAV1FeaturesKHR : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub videoEncodeIntraRefresh: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_INTRA_REFRESH_FEATURES_KHR);
impl_extends!(VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub pVideoProfile: *const VkVideoProfileInfoKHR,
    pub qualityLevel: uint32_t,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR);

/// `VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub videoEncodeQuantizationMap: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR);
impl_extends!(VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub videoEncodeRgbConversion: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_RGB_CONVERSION_FEATURES_VALVE);
impl_extends!(VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceVideoFormatInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceVideoFormatInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub imageUsage: VkImageUsageFlags,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceVideoFormatInfoKHR : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR);

/// `VkPhysicalDeviceVideoMaintenance1FeaturesKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceVideoMaintenance1FeaturesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub videoMaintenance1: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceVideoMaintenance1FeaturesKHR : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR);
impl_extends!(VkPhysicalDeviceVideoMaintenance1FeaturesKHR : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceVideoMaintenance2FeaturesKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceVideoMaintenance2FeaturesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub videoMaintenance2: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceVideoMaintenance2FeaturesKHR : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_2_FEATURES_KHR);
impl_extends!(VkPhysicalDeviceVideoMaintenance2FeaturesKHR : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceVulkan11Features`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceVulkan11Features {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    /// 16-bit integer/floating-point variables supported in BufferBlock
    pub storageBuffer16BitAccess: VkBool32,
    /// 16-bit integer/floating-point variables supported in BufferBlock and Block
    pub uniformAndStorageBuffer16BitAccess: VkBool32,
    /// 16-bit integer/floating-point variables supported in PushConstant
    pub storagePushConstant16: VkBool32,
    /// 16-bit integer/floating-point variables supported in shader inputs and outputs
    pub storageInputOutput16: VkBool32,
    /// Multiple views in a render pass
    pub multiview: VkBool32,
    /// Multiple views in a render pass w/ geometry shader
    pub multiviewGeometryShader: VkBool32,
    /// Multiple views in a render pass w/ tessellation shader
    pub multiviewTessellationShader: VkBool32,
    pub variablePointersStorageBuffer: VkBool32,
    pub variablePointers: VkBool32,
    pub protectedMemory: VkBool32,
    /// Sampler color conversion supported
    pub samplerYcbcrConversion: VkBool32,
    pub shaderDrawParameters: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceVulkan11Features : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES);
impl_extends!(VkPhysicalDeviceVulkan11Features : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceVulkan11Properties`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceVulkan11Properties {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub deviceUUID: [uint8_t; VK_UUID_SIZE as usize],
    pub driverUUID: [uint8_t; VK_UUID_SIZE as usize],
    pub deviceLUID: [uint8_t; VK_LUID_SIZE as usize],
    pub deviceNodeMask: uint32_t,
    pub deviceLUIDValid: VkBool32,
    /// The size of a subgroup for this queue.
    pub subgroupSize: uint32_t,
    /// Bitfield of what shader stages support subgroup operations
    pub subgroupSupportedStages: VkShaderStageFlags,
    /// Bitfield of what subgroup operations are supported.
    pub subgroupSupportedOperations: VkSubgroupFeatureFlags,
    /// Flag to specify whether quad operations are available in all stages.
    pub subgroupQuadOperationsInAllStages: VkBool32,
    pub pointClippingBehavior: VkPointClippingBehavior,
    /// max number of views in a subpass
    pub maxMultiviewViewCount: uint32_t,
    /// max instance index for a draw in a multiview subpass
    pub maxMultiviewInstanceIndex: uint32_t,
    pub protectedNoFault: VkBool32,
    pub maxPerSetDescriptors: uint32_t,
    pub maxMemoryAllocationSize: VkDeviceSize,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceVulkan11Properties : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES);
impl_extends!(VkPhysicalDeviceVulkan11Properties : VkPhysicalDeviceProperties2);

/// `VkPhysicalDeviceVulkan12Features`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceVulkan12Features {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub samplerMirrorClampToEdge: VkBool32,
    pub drawIndirectCount: VkBool32,
    /// 8-bit integer variables supported in StorageBuffer
    pub storageBuffer8BitAccess: VkBool32,
    /// 8-bit integer variables supported in StorageBuffer and Uniform
    pub uniformAndStorageBuffer8BitAccess: VkBool32,
    /// 8-bit integer variables supported in PushConstant
    pub storagePushConstant8: VkBool32,
    pub shaderBufferInt64Atomics: VkBool32,
    pub shaderSharedInt64Atomics: VkBool32,
    /// 16-bit floats (halfs) in shaders
    pub shaderFloat16: VkBool32,
    /// 8-bit integers in shaders
    pub shaderInt8: VkBool32,
    pub descriptorIndexing: VkBool32,
    pub shaderInputAttachmentArrayDynamicIndexing: VkBool32,
    pub shaderUniformTexelBufferArrayDynamicIndexing: VkBool32,
    pub shaderStorageTexelBufferArrayDynamicIndexing: VkBool32,
    pub shaderUniformBufferArrayNonUniformIndexing: VkBool32,
    pub shaderSampledImageArrayNonUniformIndexing: VkBool32,
    pub shaderStorageBufferArrayNonUniformIndexing: VkBool32,
    pub shaderStorageImageArrayNonUniformIndexing: VkBool32,
    pub shaderInputAttachmentArrayNonUniformIndexing: VkBool32,
    pub shaderUniformTexelBufferArrayNonUniformIndexing: VkBool32,
    pub shaderStorageTexelBufferArrayNonUniformIndexing: VkBool32,
    pub descriptorBindingUniformBufferUpdateAfterBind: VkBool32,
    pub descriptorBindingSampledImageUpdateAfterBind: VkBool32,
    pub descriptorBindingStorageImageUpdateAfterBind: VkBool32,
    pub descriptorBindingStorageBufferUpdateAfterBind: VkBool32,
    pub descriptorBindingUniformTexelBufferUpdateAfterBind: VkBool32,
    pub descriptorBindingStorageTexelBufferUpdateAfterBind: VkBool32,
    pub descriptorBindingUpdateUnusedWhilePending: VkBool32,
    pub descriptorBindingPartiallyBound: VkBool32,
    pub descriptorBindingVariableDescriptorCount: VkBool32,
    pub runtimeDescriptorArray: VkBool32,
    pub samplerFilterMinmax: VkBool32,
    pub scalarBlockLayout: VkBool32,
    pub imagelessFramebuffer: VkBool32,
    pub uniformBufferStandardLayout: VkBool32,
    pub shaderSubgroupExtendedTypes: VkBool32,
    pub separateDepthStencilLayouts: VkBool32,
    pub hostQueryReset: VkBool32,
    pub timelineSemaphore: VkBool32,
    pub bufferDeviceAddress: VkBool32,
    pub bufferDeviceAddressCaptureReplay: VkBool32,
    pub bufferDeviceAddressMultiDevice: VkBool32,
    pub vulkanMemoryModel: VkBool32,
    pub vulkanMemoryModelDeviceScope: VkBool32,
    pub vulkanMemoryModelAvailabilityVisibilityChains: VkBool32,
    pub shaderOutputViewportIndex: VkBool32,
    pub shaderOutputLayer: VkBool32,
    pub subgroupBroadcastDynamicId: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceVulkan12Features : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES);
impl_extends!(VkPhysicalDeviceVulkan12Features : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceVulkan12Properties`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceVulkan12Properties {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub driverID: VkDriverId,
    pub driverName: [c_char; VK_MAX_DRIVER_NAME_SIZE as usize],
    pub driverInfo: [c_char; VK_MAX_DRIVER_INFO_SIZE as usize],
    pub conformanceVersion: VkConformanceVersion,
    pub denormBehaviorIndependence: VkShaderFloatControlsIndependence,
    pub roundingModeIndependence: VkShaderFloatControlsIndependence,
    /// An implementation can preserve signed zero, nan, inf
    pub shaderSignedZeroInfNanPreserveFloat16: VkBool32,
    /// An implementation can preserve signed zero, nan, inf
    pub shaderSignedZeroInfNanPreserveFloat32: VkBool32,
    /// An implementation can preserve signed zero, nan, inf
    pub shaderSignedZeroInfNanPreserveFloat64: VkBool32,
    /// An implementation can preserve  denormals
    pub shaderDenormPreserveFloat16: VkBool32,
    /// An implementation can preserve  denormals
    pub shaderDenormPreserveFloat32: VkBool32,
    /// An implementation can preserve  denormals
    pub shaderDenormPreserveFloat64: VkBool32,
    /// An implementation can flush to zero  denormals
    pub shaderDenormFlushToZeroFloat16: VkBool32,
    /// An implementation can flush to zero  denormals
    pub shaderDenormFlushToZeroFloat32: VkBool32,
    /// An implementation can flush to zero  denormals
    pub shaderDenormFlushToZeroFloat64: VkBool32,
    /// An implementation can support RTE
    pub shaderRoundingModeRTEFloat16: VkBool32,
    /// An implementation can support RTE
    pub shaderRoundingModeRTEFloat32: VkBool32,
    /// An implementation can support RTE
    pub shaderRoundingModeRTEFloat64: VkBool32,
    /// An implementation can support RTZ
    pub shaderRoundingModeRTZFloat16: VkBool32,
    /// An implementation can support RTZ
    pub shaderRoundingModeRTZFloat32: VkBool32,
    /// An implementation can support RTZ
    pub shaderRoundingModeRTZFloat64: VkBool32,
    pub maxUpdateAfterBindDescriptorsInAllPools: uint32_t,
    pub shaderUniformBufferArrayNonUniformIndexingNative: VkBool32,
    pub shaderSampledImageArrayNonUniformIndexingNative: VkBool32,
    pub shaderStorageBufferArrayNonUniformIndexingNative: VkBool32,
    pub shaderStorageImageArrayNonUniformIndexingNative: VkBool32,
    pub shaderInputAttachmentArrayNonUniformIndexingNative: VkBool32,
    pub robustBufferAccessUpdateAfterBind: VkBool32,
    pub quadDivergentImplicitLod: VkBool32,
    pub maxPerStageDescriptorUpdateAfterBindSamplers: uint32_t,
    pub maxPerStageDescriptorUpdateAfterBindUniformBuffers: uint32_t,
    pub maxPerStageDescriptorUpdateAfterBindStorageBuffers: uint32_t,
    pub maxPerStageDescriptorUpdateAfterBindSampledImages: uint32_t,
    pub maxPerStageDescriptorUpdateAfterBindStorageImages: uint32_t,
    pub maxPerStageDescriptorUpdateAfterBindInputAttachments: uint32_t,
    pub maxPerStageUpdateAfterBindResources: uint32_t,
    pub maxDescriptorSetUpdateAfterBindSamplers: uint32_t,
    pub maxDescriptorSetUpdateAfterBindUniformBuffers: uint32_t,
    pub maxDescriptorSetUpdateAfterBindUniformBuffersDynamic: uint32_t,
    pub maxDescriptorSetUpdateAfterBindStorageBuffers: uint32_t,
    pub maxDescriptorSetUpdateAfterBindStorageBuffersDynamic: uint32_t,
    pub maxDescriptorSetUpdateAfterBindSampledImages: uint32_t,
    pub maxDescriptorSetUpdateAfterBindStorageImages: uint32_t,
    pub maxDescriptorSetUpdateAfterBindInputAttachments: uint32_t,
    /// supported depth resolve modes
    pub supportedDepthResolveModes: VkResolveModeFlags,
    /// supported stencil resolve modes
    pub supportedStencilResolveModes: VkResolveModeFlags,
    /// depth and stencil resolve modes can be set independently if one of them is none
    pub independentResolveNone: VkBool32,
    /// depth and stencil resolve modes can be set independently
    pub independentResolve: VkBool32,
    pub filterMinmaxSingleComponentFormats: VkBool32,
    pub filterMinmaxImageComponentMapping: VkBool32,
    pub maxTimelineSemaphoreValueDifference: uint64_t,
    pub framebufferIntegerColorSampleCounts: VkSampleCountFlags,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceVulkan12Properties : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES);
impl_extends!(VkPhysicalDeviceVulkan12Properties : VkPhysicalDeviceProperties2);

/// `VkPhysicalDeviceVulkan13Features`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceVulkan13Features {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub robustImageAccess: VkBool32,
    pub inlineUniformBlock: VkBool32,
    pub descriptorBindingInlineUniformBlockUpdateAfterBind: VkBool32,
    pub pipelineCreationCacheControl: VkBool32,
    pub privateData: VkBool32,
    pub shaderDemoteToHelperInvocation: VkBool32,
    pub shaderTerminateInvocation: VkBool32,
    pub subgroupSizeControl: VkBool32,
    pub computeFullSubgroups: VkBool32,
    pub synchronization2: VkBool32,
    pub textureCompressionASTC_HDR: VkBool32,
    pub shaderZeroInitializeWorkgroupMemory: VkBool32,
    pub dynamicRendering: VkBool32,
    pub shaderIntegerDotProduct: VkBool32,
    pub maintenance4: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceVulkan13Features : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES);
impl_extends!(VkPhysicalDeviceVulkan13Features : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceVulkan13Properties`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceVulkan13Properties {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    /// The minimum subgroup size supported by this device
    pub minSubgroupSize: uint32_t,
    /// The maximum subgroup size supported by this device
    pub maxSubgroupSize: uint32_t,
    /// The maximum number of subgroups supported in a workgroup
    pub maxComputeWorkgroupSubgroups: uint32_t,
    /// The shader stages that support specifying a subgroup size
    pub requiredSubgroupSizeStages: VkShaderStageFlags,
    pub maxInlineUniformBlockSize: uint32_t,
    pub maxPerStageDescriptorInlineUniformBlocks: uint32_t,
    pub maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks: uint32_t,
    pub maxDescriptorSetInlineUniformBlocks: uint32_t,
    pub maxDescriptorSetUpdateAfterBindInlineUniformBlocks: uint32_t,
    pub maxInlineUniformTotalSize: uint32_t,
    pub integerDotProduct8BitUnsignedAccelerated: VkBool32,
    pub integerDotProduct8BitSignedAccelerated: VkBool32,
    pub integerDotProduct8BitMixedSignednessAccelerated: VkBool32,
    pub integerDotProduct4x8BitPackedUnsignedAccelerated: VkBool32,
    pub integerDotProduct4x8BitPackedSignedAccelerated: VkBool32,
    pub integerDotProduct4x8BitPackedMixedSignednessAccelerated: VkBool32,
    pub integerDotProduct16BitUnsignedAccelerated: VkBool32,
    pub integerDotProduct16BitSignedAccelerated: VkBool32,
    pub integerDotProduct16BitMixedSignednessAccelerated: VkBool32,
    pub integerDotProduct32BitUnsignedAccelerated: VkBool32,
    pub integerDotProduct32BitSignedAccelerated: VkBool32,
    pub integerDotProduct32BitMixedSignednessAccelerated: VkBool32,
    pub integerDotProduct64BitUnsignedAccelerated: VkBool32,
    pub integerDotProduct64BitSignedAccelerated: VkBool32,
    pub integerDotProduct64BitMixedSignednessAccelerated: VkBool32,
    pub integerDotProductAccumulatingSaturating8BitUnsignedAccelerated: VkBool32,
    pub integerDotProductAccumulatingSaturating8BitSignedAccelerated: VkBool32,
    pub integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated: VkBool32,
    pub integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated: VkBool32,
    pub integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated: VkBool32,
    pub integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated: VkBool32,
    pub integerDotProductAccumulatingSaturating16BitUnsignedAccelerated: VkBool32,
    pub integerDotProductAccumulatingSaturating16BitSignedAccelerated: VkBool32,
    pub integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated: VkBool32,
    pub integerDotProductAccumulatingSaturating32BitUnsignedAccelerated: VkBool32,
    pub integerDotProductAccumulatingSaturating32BitSignedAccelerated: VkBool32,
    pub integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated: VkBool32,
    pub integerDotProductAccumulatingSaturating64BitUnsignedAccelerated: VkBool32,
    pub integerDotProductAccumulatingSaturating64BitSignedAccelerated: VkBool32,
    pub integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated: VkBool32,
    pub storageTexelBufferOffsetAlignmentBytes: VkDeviceSize,
    pub storageTexelBufferOffsetSingleTexelAlignment: VkBool32,
    pub uniformTexelBufferOffsetAlignmentBytes: VkDeviceSize,
    pub uniformTexelBufferOffsetSingleTexelAlignment: VkBool32,
    pub maxBufferSize: VkDeviceSize,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceVulkan13Properties : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES);
impl_extends!(VkPhysicalDeviceVulkan13Properties : VkPhysicalDeviceProperties2);

/// `VkPhysicalDeviceVulkan14Features`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceVulkan14Features {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub globalPriorityQuery: VkBool32,
    pub shaderSubgroupRotate: VkBool32,
    pub shaderSubgroupRotateClustered: VkBool32,
    pub shaderFloatControls2: VkBool32,
    pub shaderExpectAssume: VkBool32,
    pub rectangularLines: VkBool32,
    pub bresenhamLines: VkBool32,
    pub smoothLines: VkBool32,
    pub stippledRectangularLines: VkBool32,
    pub stippledBresenhamLines: VkBool32,
    pub stippledSmoothLines: VkBool32,
    pub vertexAttributeInstanceRateDivisor: VkBool32,
    pub vertexAttributeInstanceRateZeroDivisor: VkBool32,
    pub indexTypeUint8: VkBool32,
    pub dynamicRenderingLocalRead: VkBool32,
    pub maintenance5: VkBool32,
    pub maintenance6: VkBool32,
    pub pipelineProtectedAccess: VkBool32,
    pub pipelineRobustness: VkBool32,
    pub hostImageCopy: VkBool32,
    pub pushDescriptor: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceVulkan14Features : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES);
impl_extends!(VkPhysicalDeviceVulkan14Features : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceVulkan14Properties`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceVulkan14Properties {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub lineSubPixelPrecisionBits: uint32_t,
    /// max value of vertex attribute divisor
    pub maxVertexAttribDivisor: uint32_t,
    pub supportsNonZeroFirstInstance: VkBool32,
    pub maxPushDescriptors: uint32_t,
    pub dynamicRenderingLocalReadDepthStencilAttachments: VkBool32,
    pub dynamicRenderingLocalReadMultisampledAttachments: VkBool32,
    pub earlyFragmentMultisampleCoverageAfterSampleCounting: VkBool32,
    pub earlyFragmentSampleMaskTestBeforeSampleCounting: VkBool32,
    pub depthStencilSwizzleOneSupport: VkBool32,
    pub polygonModePointSize: VkBool32,
    pub nonStrictSinglePixelWideLinesUseParallelogram: VkBool32,
    pub nonStrictWideLinesUseParallelogram: VkBool32,
    pub blockTexelViewCompatibleMultipleLayers: VkBool32,
    pub maxCombinedImageSamplerDescriptorCount: uint32_t,
    pub fragmentShadingRateClampCombinerInputs: VkBool32,
    pub defaultRobustnessStorageBuffers: VkPipelineRobustnessBufferBehavior,
    pub defaultRobustnessUniformBuffers: VkPipelineRobustnessBufferBehavior,
    pub defaultRobustnessVertexInputs: VkPipelineRobustnessBufferBehavior,
    pub defaultRobustnessImages: VkPipelineRobustnessImageBehavior,
    pub copySrcLayoutCount: uint32_t,
    pub pCopySrcLayouts: *mut VkImageLayout,
    pub copyDstLayoutCount: uint32_t,
    pub pCopyDstLayouts: *mut VkImageLayout,
    pub optimalTilingLayoutUUID: [uint8_t; VK_UUID_SIZE as usize],
    pub identicalMemoryTypeRequirements: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceVulkan14Properties : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_PROPERTIES);
impl_extends!(VkPhysicalDeviceVulkan14Properties : VkPhysicalDeviceProperties2);

/// `VkPhysicalDeviceVulkanMemoryModelFeatures`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceVulkanMemoryModelFeatures {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub vulkanMemoryModel: VkBool32,
    pub vulkanMemoryModelDeviceScope: VkBool32,
    pub vulkanMemoryModelAvailabilityVisibilityChains: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceVulkanMemoryModelFeatures : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES);
impl_extends!(VkPhysicalDeviceVulkanMemoryModelFeatures : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceVulkanMemoryModelFeatures`
pub type VkPhysicalDeviceVulkanMemoryModelFeaturesKHR = VkPhysicalDeviceVulkanMemoryModelFeatures;

/// `VkPhysicalDeviceVulkanSC10Features`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceVulkanSC10Features {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub shaderAtomicInstructions: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceVulkanSC10Features : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_SC_1_0_FEATURES);
impl_extends!(VkPhysicalDeviceVulkanSC10Features : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceVulkanSC10Properties`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceVulkanSC10Properties {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub deviceNoDynamicHostAllocations: VkBool32,
    pub deviceDestroyFreesMemory: VkBool32,
    pub commandPoolMultipleCommandBuffersRecording: VkBool32,
    pub commandPoolResetCommandBuffer: VkBool32,
    pub commandBufferSimultaneousUse: VkBool32,
    pub secondaryCommandBufferNullOrImagelessFramebuffer: VkBool32,
    pub recycleDescriptorSetMemory: VkBool32,
    pub recyclePipelineMemory: VkBool32,
    pub maxRenderPassSubpasses: uint32_t,
    pub maxRenderPassDependencies: uint32_t,
    pub maxSubpassInputAttachments: uint32_t,
    pub maxSubpassPreserveAttachments: uint32_t,
    pub maxFramebufferAttachments: uint32_t,
    pub maxDescriptorSetLayoutBindings: uint32_t,
    pub maxQueryFaultCount: uint32_t,
    pub maxCallbackFaultCount: uint32_t,
    pub maxCommandPoolCommandBuffers: uint32_t,
    pub maxCommandBufferSize: VkDeviceSize,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceVulkanSC10Properties : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_SC_1_0_PROPERTIES);
impl_extends!(VkPhysicalDeviceVulkanSC10Properties : VkPhysicalDeviceProperties2);

/// `VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub workgroupMemoryExplicitLayout: VkBool32,
    pub workgroupMemoryExplicitLayoutScalarBlockLayout: VkBool32,
    pub workgroupMemoryExplicitLayout8BitAccess: VkBool32,
    pub workgroupMemoryExplicitLayout16BitAccess: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR);
impl_extends!(VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub ycbcr2plane444Formats: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT);
impl_extends!(VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceYcbcrDegammaFeaturesQCOM`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceYcbcrDegammaFeaturesQCOM {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub ycbcrDegamma: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceYcbcrDegammaFeaturesQCOM : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM);
impl_extends!(VkPhysicalDeviceYcbcrDegammaFeaturesQCOM : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceYcbcrImageArraysFeaturesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceYcbcrImageArraysFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub ycbcrImageArrays: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceYcbcrImageArraysFeaturesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT);
impl_extends!(VkPhysicalDeviceYcbcrImageArraysFeaturesEXT : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub zeroInitializeDeviceMemory: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES_EXT);
impl_extends!(VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub shaderZeroInitializeWorkgroupMemory: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures : VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES);
impl_extends!(VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures : VkPhysicalDeviceFeatures2, VkDeviceCreateInfo);

/// `VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures`
pub type VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR = VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures;

/// `VkPipeline` : `VkDevice`
#[repr(transparent)]
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkPipeline(pub u64);
from_into_transparent!(VkPipeline: u64);
impl_handle!(VkPipeline: VK_OBJECT_TYPE_PIPELINE; SubHandle = VkDevice);

/// `VkPipelineBinaryCreateInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPipelineBinaryCreateInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub pKeysAndDataInfo: *const VkPipelineBinaryKeysAndDataKHR,
    pub pipeline: VkPipeline,
    pub pPipelineCreateInfo: *const VkPipelineCreateInfoKHR,
}
impl_default_zeroed_with_s_type!(VkPipelineBinaryCreateInfoKHR : VK_STRUCTURE_TYPE_PIPELINE_BINARY_CREATE_INFO_KHR);

/// `VkPipelineBinaryDataInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPipelineBinaryDataInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub pipelineBinary: VkPipelineBinaryKHR,
}
impl_default_zeroed_with_s_type!(VkPipelineBinaryDataInfoKHR : VK_STRUCTURE_TYPE_PIPELINE_BINARY_DATA_INFO_KHR);

/// `VkPipelineBinaryDataKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPipelineBinaryDataKHR {
    pub dataSize: size_t,
    pub pData: *mut void,
}
impl_default_zeroed!(VkPipelineBinaryDataKHR);

/// `VkPipelineBinaryHandlesInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPipelineBinaryHandlesInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub pipelineBinaryCount: uint32_t,
    pub pPipelineBinaries: *mut VkPipelineBinaryKHR,
}
impl_default_zeroed_with_s_type!(VkPipelineBinaryHandlesInfoKHR : VK_STRUCTURE_TYPE_PIPELINE_BINARY_HANDLES_INFO_KHR);

/// `VkPipelineBinaryInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPipelineBinaryInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub binaryCount: uint32_t,
    pub pPipelineBinaries: *const VkPipelineBinaryKHR,
}
impl_default_zeroed_with_s_type!(VkPipelineBinaryInfoKHR : VK_STRUCTURE_TYPE_PIPELINE_BINARY_INFO_KHR);
impl_extends!(VkPipelineBinaryInfoKHR : VkGraphicsPipelineCreateInfo, VkComputePipelineCreateInfo, VkRayTracingPipelineCreateInfoKHR);

/// `VkPipelineBinaryKHR` : `VkDevice`
#[repr(transparent)]
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkPipelineBinaryKHR(pub u64);
from_into_transparent!(VkPipelineBinaryKHR: u64);
impl_handle!(VkPipelineBinaryKHR: VK_OBJECT_TYPE_PIPELINE_BINARY_KHR; SubHandle = VkDevice);

/// `VkPipelineBinaryKeyKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPipelineBinaryKeyKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub keySize: uint32_t,
    pub key: [uint8_t; VK_MAX_PIPELINE_BINARY_KEY_SIZE_KHR as usize],
}
impl_default_zeroed_with_s_type!(VkPipelineBinaryKeyKHR : VK_STRUCTURE_TYPE_PIPELINE_BINARY_KEY_KHR);

/// `VkPipelineBinaryKeysAndDataKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPipelineBinaryKeysAndDataKHR {
    pub binaryCount: uint32_t,
    pub pPipelineBinaryKeys: *const VkPipelineBinaryKeyKHR,
    pub pPipelineBinaryData: *const VkPipelineBinaryDataKHR,
}
impl_default_zeroed!(VkPipelineBinaryKeysAndDataKHR);

from_into_transparent!(VkPipelineBindPoint: i32);
/// `VkPipelineBindPoint`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkPipelineBindPoint(pub i32);

/// `0`  
pub const VK_PIPELINE_BIND_POINT_GRAPHICS: VkPipelineBindPoint = VkPipelineBindPoint(0);
/// `1`  
pub const VK_PIPELINE_BIND_POINT_COMPUTE: VkPipelineBindPoint = VkPipelineBindPoint(1);
/// `1000134000`  
pub const VK_PIPELINE_BIND_POINT_EXECUTION_GRAPH_AMDX: VkPipelineBindPoint = VkPipelineBindPoint(1000134000);
/// `1000165000`  
pub const VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR: VkPipelineBindPoint = VkPipelineBindPoint(1000165000);
/// `VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR`  
pub const VK_PIPELINE_BIND_POINT_RAY_TRACING_NV: VkPipelineBindPoint = VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR;
/// `1000369003`  
pub const VK_PIPELINE_BIND_POINT_SUBPASS_SHADING_HUAWEI: VkPipelineBindPoint = VkPipelineBindPoint(1000369003);
/// `1000507000`  
pub const VK_PIPELINE_BIND_POINT_DATA_GRAPH_ARM: VkPipelineBindPoint = VkPipelineBindPoint(1000507000);

impl_enum_display!(VkPipelineBindPoint { VK_PIPELINE_BIND_POINT_GRAPHICS, VK_PIPELINE_BIND_POINT_COMPUTE, VK_PIPELINE_BIND_POINT_EXECUTION_GRAPH_AMDX, VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR, VK_PIPELINE_BIND_POINT_RAY_TRACING_NV, VK_PIPELINE_BIND_POINT_SUBPASS_SHADING_HUAWEI, VK_PIPELINE_BIND_POINT_DATA_GRAPH_ARM });

/// `VkPipelineCache` : `VkDevice`
#[repr(transparent)]
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkPipelineCache(pub u64);
from_into_transparent!(VkPipelineCache: u64);
impl_handle!(VkPipelineCache: VK_OBJECT_TYPE_PIPELINE_CACHE; SubHandle = VkDevice);

flags!(VkPipelineCacheCreateFlags);
from_into_transparent!(VkPipelineCacheCreateFlags: i32);
/// `VkPipelineCacheCreateFlags`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkPipelineCacheCreateFlags(pub i32);

/// `1 << 0`  
pub const VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT: VkPipelineCacheCreateFlags = VkPipelineCacheCreateFlags(1 << 0);
/// `1 << 1`  
pub const VK_PIPELINE_CACHE_CREATE_READ_ONLY_BIT: VkPipelineCacheCreateFlags = VkPipelineCacheCreateFlags(1 << 1);
/// `1 << 2`  
pub const VK_PIPELINE_CACHE_CREATE_USE_APPLICATION_STORAGE_BIT: VkPipelineCacheCreateFlags = VkPipelineCacheCreateFlags(1 << 2);
/// `VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT`  
pub const VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT_EXT: VkPipelineCacheCreateFlags = VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT;
/// `1 << 3`  
pub const VK_PIPELINE_CACHE_CREATE_INTERNALLY_SYNCHRONIZED_MERGE_BIT_KHR: VkPipelineCacheCreateFlags = VkPipelineCacheCreateFlags(1 << 3);

impl_flags_display!(VkPipelineCacheCreateFlags { VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT, VK_PIPELINE_CACHE_CREATE_READ_ONLY_BIT, VK_PIPELINE_CACHE_CREATE_USE_APPLICATION_STORAGE_BIT, VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT_EXT, VK_PIPELINE_CACHE_CREATE_INTERNALLY_SYNCHRONIZED_MERGE_BIT_KHR });

/// `VkPipelineCacheCreateInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPipelineCacheCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub flags: VkPipelineCacheCreateFlags,
    /// Size of initial data to populate cache, in bytes
    pub initialDataSize: size_t,
    /// Initial data to populate cache
    pub pInitialData: *const void,
}
impl_default_zeroed_with_s_type!(VkPipelineCacheCreateInfo : VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO);

from_into_transparent!(VkPipelineCacheHeaderVersion: i32);
/// `VkPipelineCacheHeaderVersion`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkPipelineCacheHeaderVersion(pub i32);

/// `1`  
pub const VK_PIPELINE_CACHE_HEADER_VERSION_ONE: VkPipelineCacheHeaderVersion = VkPipelineCacheHeaderVersion(1);
/// `1000298001`  
pub const VK_PIPELINE_CACHE_HEADER_VERSION_SAFETY_CRITICAL_ONE: VkPipelineCacheHeaderVersion = VkPipelineCacheHeaderVersion(1000298001);
/// `1000629000`  
pub const VK_PIPELINE_CACHE_HEADER_VERSION_DATA_GRAPH_QCOM: VkPipelineCacheHeaderVersion = VkPipelineCacheHeaderVersion(1000629000);

impl_enum_display!(VkPipelineCacheHeaderVersion { VK_PIPELINE_CACHE_HEADER_VERSION_ONE, VK_PIPELINE_CACHE_HEADER_VERSION_SAFETY_CRITICAL_ONE, VK_PIPELINE_CACHE_HEADER_VERSION_DATA_GRAPH_QCOM });

/// `VkPipelineCacheHeaderVersionDataGraphQCOM`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPipelineCacheHeaderVersionDataGraphQCOM {
    pub headerSize: uint32_t,
    pub headerVersion: VkPipelineCacheHeaderVersion,
    pub cacheType: VkDataGraphModelCacheTypeQCOM,
    pub cacheVersion: uint32_t,
    pub toolchainVersion: [uint32_t; VK_DATA_GRAPH_MODEL_TOOLCHAIN_VERSION_LENGTH_QCOM as usize],
}
impl_default_zeroed!(VkPipelineCacheHeaderVersionDataGraphQCOM);

/// `VkPipelineCacheHeaderVersionOne`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPipelineCacheHeaderVersionOne {
    pub headerSize: uint32_t,
    pub headerVersion: VkPipelineCacheHeaderVersion,
    pub vendorID: uint32_t,
    pub deviceID: uint32_t,
    pub pipelineCacheUUID: [uint8_t; VK_UUID_SIZE as usize],
}
impl_default_zeroed!(VkPipelineCacheHeaderVersionOne);

/// `VkPipelineCacheHeaderVersionSafetyCriticalOne`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPipelineCacheHeaderVersionSafetyCriticalOne {
    pub headerVersionOne: VkPipelineCacheHeaderVersionOne,
    pub validationVersion: VkPipelineCacheValidationVersion,
    pub implementationData: uint32_t,
    pub pipelineIndexCount: uint32_t,
    pub pipelineIndexStride: uint32_t,
    pub pipelineIndexOffset: uint64_t,
}
impl_default_zeroed!(VkPipelineCacheHeaderVersionSafetyCriticalOne);

/// `VkPipelineCacheSafetyCriticalIndexEntry`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPipelineCacheSafetyCriticalIndexEntry {
    pub pipelineIdentifier: [uint8_t; VK_UUID_SIZE as usize],
    pub pipelineMemorySize: uint64_t,
    pub jsonSize: uint64_t,
    pub jsonOffset: uint64_t,
    pub stageIndexCount: uint32_t,
    pub stageIndexStride: uint32_t,
    pub stageIndexOffset: uint64_t,
}
impl_default_zeroed!(VkPipelineCacheSafetyCriticalIndexEntry);

/// `VkPipelineCacheStageValidationIndexEntry`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPipelineCacheStageValidationIndexEntry {
    pub codeSize: uint64_t,
    pub codeOffset: uint64_t,
}
impl_default_zeroed!(VkPipelineCacheStageValidationIndexEntry);

from_into_transparent!(VkPipelineCacheValidationVersion: i32);
/// `VkPipelineCacheValidationVersion`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkPipelineCacheValidationVersion(pub i32);

/// `1`  
pub const VK_PIPELINE_CACHE_VALIDATION_VERSION_SAFETY_CRITICAL_ONE: VkPipelineCacheValidationVersion = VkPipelineCacheValidationVersion(1);

impl_enum_display!(VkPipelineCacheValidationVersion { VK_PIPELINE_CACHE_VALIDATION_VERSION_SAFETY_CRITICAL_ONE });

/// `VkPipelineColorBlendAdvancedStateCreateInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPipelineColorBlendAdvancedStateCreateInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub srcPremultiplied: VkBool32,
    pub dstPremultiplied: VkBool32,
    pub blendOverlap: VkBlendOverlapEXT,
}
impl_default_zeroed_with_s_type!(VkPipelineColorBlendAdvancedStateCreateInfoEXT : VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT);
impl_extends!(VkPipelineColorBlendAdvancedStateCreateInfoEXT : VkPipelineColorBlendStateCreateInfo);

/// `VkPipelineColorBlendAttachmentState`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPipelineColorBlendAttachmentState {
    pub blendEnable: VkBool32,
    pub srcColorBlendFactor: VkBlendFactor,
    pub dstColorBlendFactor: VkBlendFactor,
    pub colorBlendOp: VkBlendOp,
    pub srcAlphaBlendFactor: VkBlendFactor,
    pub dstAlphaBlendFactor: VkBlendFactor,
    pub alphaBlendOp: VkBlendOp,
    pub colorWriteMask: VkColorComponentFlags,
}
impl_default_zeroed!(VkPipelineColorBlendAttachmentState);

flags!(VkPipelineColorBlendStateCreateFlags);
from_into_transparent!(VkPipelineColorBlendStateCreateFlags: i32);
/// `VkPipelineColorBlendStateCreateFlags`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkPipelineColorBlendStateCreateFlags(pub i32);

/// `VK_PIPELINE_COLOR_BLEND_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_BIT_EXT`  
pub const VK_PIPELINE_COLOR_BLEND_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_BIT_ARM: VkPipelineColorBlendStateCreateFlags = VK_PIPELINE_COLOR_BLEND_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_BIT_EXT;
/// `1 << 0`  
pub const VK_PIPELINE_COLOR_BLEND_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_BIT_EXT: VkPipelineColorBlendStateCreateFlags = VkPipelineColorBlendStateCreateFlags(1 << 0);

impl_flags_display!(VkPipelineColorBlendStateCreateFlags { VK_PIPELINE_COLOR_BLEND_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_BIT_ARM, VK_PIPELINE_COLOR_BLEND_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_BIT_EXT });

/// `VkPipelineColorBlendStateCreateInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPipelineColorBlendStateCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub flags: VkPipelineColorBlendStateCreateFlags,
    pub logicOpEnable: VkBool32,
    pub logicOp: VkLogicOp,
    /// # of pAttachments
    pub attachmentCount: uint32_t,
    pub pAttachments: *const VkPipelineColorBlendAttachmentState,
    pub blendConstants: [float; 4 as usize],
}
impl_default_zeroed_with_s_type!(VkPipelineColorBlendStateCreateInfo : VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO);

/// `VkPipelineColorWriteCreateInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPipelineColorWriteCreateInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    /// # of pAttachments
    pub attachmentCount: uint32_t,
    pub pColorWriteEnables: *const VkBool32,
}
impl_default_zeroed_with_s_type!(VkPipelineColorWriteCreateInfoEXT : VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT);
impl_extends!(VkPipelineColorWriteCreateInfoEXT : VkPipelineColorBlendStateCreateInfo);

/// `VkPipelineCompilerControlCreateInfoAMD`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPipelineCompilerControlCreateInfoAMD {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub compilerControlFlags: VkPipelineCompilerControlFlagsAMD,
}
impl_default_zeroed_with_s_type!(VkPipelineCompilerControlCreateInfoAMD : VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD);
impl_extends!(VkPipelineCompilerControlCreateInfoAMD : VkGraphicsPipelineCreateInfo, VkComputePipelineCreateInfo, VkExecutionGraphPipelineCreateInfoAMDX);

flags!(VkPipelineCompilerControlFlagsAMD);
from_into_transparent!(VkPipelineCompilerControlFlagsAMD: i32);
/// `VkPipelineCompilerControlFlagsAMD`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkPipelineCompilerControlFlagsAMD(pub i32);

impl_flags_display!(VkPipelineCompilerControlFlagsAMD {  });

flags!(VkPipelineCoverageModulationStateCreateFlagsNV);
from_into_transparent!(VkPipelineCoverageModulationStateCreateFlagsNV: i32);
/// `VkPipelineCoverageModulationStateCreateFlagsNV`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkPipelineCoverageModulationStateCreateFlagsNV(pub i32);

impl_flags_display!(VkPipelineCoverageModulationStateCreateFlagsNV {  });

/// `VkPipelineCoverageModulationStateCreateInfoNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPipelineCoverageModulationStateCreateInfoNV {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub flags: VkPipelineCoverageModulationStateCreateFlagsNV,
    pub coverageModulationMode: VkCoverageModulationModeNV,
    pub coverageModulationTableEnable: VkBool32,
    pub coverageModulationTableCount: uint32_t,
    pub pCoverageModulationTable: *const float,
}
impl_default_zeroed_with_s_type!(VkPipelineCoverageModulationStateCreateInfoNV : VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV);
impl_extends!(VkPipelineCoverageModulationStateCreateInfoNV : VkPipelineMultisampleStateCreateInfo);

flags!(VkPipelineCoverageReductionStateCreateFlagsNV);
from_into_transparent!(VkPipelineCoverageReductionStateCreateFlagsNV: i32);
/// `VkPipelineCoverageReductionStateCreateFlagsNV`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkPipelineCoverageReductionStateCreateFlagsNV(pub i32);

impl_flags_display!(VkPipelineCoverageReductionStateCreateFlagsNV {  });

/// `VkPipelineCoverageReductionStateCreateInfoNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPipelineCoverageReductionStateCreateInfoNV {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub flags: VkPipelineCoverageReductionStateCreateFlagsNV,
    pub coverageReductionMode: VkCoverageReductionModeNV,
}
impl_default_zeroed_with_s_type!(VkPipelineCoverageReductionStateCreateInfoNV : VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV);
impl_extends!(VkPipelineCoverageReductionStateCreateInfoNV : VkPipelineMultisampleStateCreateInfo);

flags!(VkPipelineCoverageToColorStateCreateFlagsNV);
from_into_transparent!(VkPipelineCoverageToColorStateCreateFlagsNV: i32);
/// `VkPipelineCoverageToColorStateCreateFlagsNV`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkPipelineCoverageToColorStateCreateFlagsNV(pub i32);

impl_flags_display!(VkPipelineCoverageToColorStateCreateFlagsNV {  });

/// `VkPipelineCoverageToColorStateCreateInfoNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPipelineCoverageToColorStateCreateInfoNV {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub flags: VkPipelineCoverageToColorStateCreateFlagsNV,
    pub coverageToColorEnable: VkBool32,
    pub coverageToColorLocation: uint32_t,
}
impl_default_zeroed_with_s_type!(VkPipelineCoverageToColorStateCreateInfoNV : VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV);
impl_extends!(VkPipelineCoverageToColorStateCreateInfoNV : VkPipelineMultisampleStateCreateInfo);

flags!(VkPipelineCreateFlags);
from_into_transparent!(VkPipelineCreateFlags: i32);
/// `VkPipelineCreateFlags`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkPipelineCreateFlags(pub i32);

/// `1 << 0`  
pub const VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT: VkPipelineCreateFlags = VkPipelineCreateFlags(1 << 0);
/// `1 << 1`  
pub const VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT: VkPipelineCreateFlags = VkPipelineCreateFlags(1 << 1);
/// `1 << 2`  
pub const VK_PIPELINE_CREATE_DERIVATIVE_BIT: VkPipelineCreateFlags = VkPipelineCreateFlags(1 << 2);
/// `1 << 4`  
pub const VK_PIPELINE_CREATE_DISPATCH_BASE_BIT: VkPipelineCreateFlags = VkPipelineCreateFlags(1 << 4);
/// `VK_PIPELINE_CREATE_DISPATCH_BASE_BIT`  
pub const VK_PIPELINE_CREATE_DISPATCH_BASE: VkPipelineCreateFlags = VK_PIPELINE_CREATE_DISPATCH_BASE_BIT;
/// `1 << 3`  
pub const VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT: VkPipelineCreateFlags = VkPipelineCreateFlags(1 << 3);
/// `1 << 8`  
pub const VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT: VkPipelineCreateFlags = VkPipelineCreateFlags(1 << 8);
/// `1 << 9`  
pub const VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT: VkPipelineCreateFlags = VkPipelineCreateFlags(1 << 9);
/// `1 << 27`  
pub const VK_PIPELINE_CREATE_NO_PROTECTED_ACCESS_BIT: VkPipelineCreateFlags = VkPipelineCreateFlags(1 << 27);
/// `1 << 30`  
pub const VK_PIPELINE_CREATE_PROTECTED_ACCESS_ONLY_BIT: VkPipelineCreateFlags = VkPipelineCreateFlags(1 << 30);
/// `VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT`  
pub const VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHR: VkPipelineCreateFlags = VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT;
/// `VK_PIPELINE_CREATE_DISPATCH_BASE_BIT`  
pub const VK_PIPELINE_CREATE_DISPATCH_BASE_BIT_KHR: VkPipelineCreateFlags = VK_PIPELINE_CREATE_DISPATCH_BASE_BIT;
/// `VK_PIPELINE_CREATE_DISPATCH_BASE_BIT`  
pub const VK_PIPELINE_CREATE_DISPATCH_BASE_KHR: VkPipelineCreateFlags = VK_PIPELINE_CREATE_DISPATCH_BASE_BIT;
/// `1 << 14`  
pub const VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_BIT_KHR: VkPipelineCreateFlags = VkPipelineCreateFlags(1 << 14);
/// `1 << 15`  
pub const VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_BIT_KHR: VkPipelineCreateFlags = VkPipelineCreateFlags(1 << 15);
/// `1 << 16`  
pub const VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_MISS_SHADERS_BIT_KHR: VkPipelineCreateFlags = VkPipelineCreateFlags(1 << 16);
/// `1 << 17`  
pub const VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_BIT_KHR: VkPipelineCreateFlags = VkPipelineCreateFlags(1 << 17);
/// `1 << 12`  
pub const VK_PIPELINE_CREATE_RAY_TRACING_SKIP_TRIANGLES_BIT_KHR: VkPipelineCreateFlags = VkPipelineCreateFlags(1 << 12);
/// `1 << 13`  
pub const VK_PIPELINE_CREATE_RAY_TRACING_SKIP_AABBS_BIT_KHR: VkPipelineCreateFlags = VkPipelineCreateFlags(1 << 13);
/// `1 << 19`  
pub const VK_PIPELINE_CREATE_RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_BIT_KHR: VkPipelineCreateFlags = VkPipelineCreateFlags(1 << 19);
/// `1 << 5`  
pub const VK_PIPELINE_CREATE_DEFER_COMPILE_BIT_NV: VkPipelineCreateFlags = VkPipelineCreateFlags(1 << 5);
/// `1 << 22`  
pub const VK_PIPELINE_CREATE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT: VkPipelineCreateFlags = VkPipelineCreateFlags(1 << 22);
/// `VK_PIPELINE_CREATE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT`  
pub const VK_PIPELINE_RASTERIZATION_STATE_CREATE_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT: VkPipelineCreateFlags = VK_PIPELINE_CREATE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT;
/// `1 << 21`  
pub const VK_PIPELINE_CREATE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR: VkPipelineCreateFlags = VkPipelineCreateFlags(1 << 21);
/// `VK_PIPELINE_CREATE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR`  
pub const VK_PIPELINE_RASTERIZATION_STATE_CREATE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR: VkPipelineCreateFlags = VK_PIPELINE_CREATE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR;
/// `1 << 6`  
pub const VK_PIPELINE_CREATE_CAPTURE_STATISTICS_BIT_KHR: VkPipelineCreateFlags = VkPipelineCreateFlags(1 << 6);
/// `1 << 7`  
pub const VK_PIPELINE_CREATE_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR: VkPipelineCreateFlags = VkPipelineCreateFlags(1 << 7);
/// `1 << 18`  
pub const VK_PIPELINE_CREATE_INDIRECT_BINDABLE_BIT_NV: VkPipelineCreateFlags = VkPipelineCreateFlags(1 << 18);
/// `1 << 11`  
pub const VK_PIPELINE_CREATE_LIBRARY_BIT_KHR: VkPipelineCreateFlags = VkPipelineCreateFlags(1 << 11);
/// `VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT`  
pub const VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT_EXT: VkPipelineCreateFlags = VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT;
/// `VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT`  
pub const VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT_EXT: VkPipelineCreateFlags = VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT;
/// `1 << 29`  
pub const VK_PIPELINE_CREATE_DESCRIPTOR_BUFFER_BIT_EXT: VkPipelineCreateFlags = VkPipelineCreateFlags(1 << 29);
/// `1 << 23`  
pub const VK_PIPELINE_CREATE_RETAIN_LINK_TIME_OPTIMIZATION_INFO_BIT_EXT: VkPipelineCreateFlags = VkPipelineCreateFlags(1 << 23);
/// `1 << 10`  
pub const VK_PIPELINE_CREATE_LINK_TIME_OPTIMIZATION_BIT_EXT: VkPipelineCreateFlags = VkPipelineCreateFlags(1 << 10);
/// `1 << 20`  
pub const VK_PIPELINE_CREATE_RAY_TRACING_ALLOW_MOTION_BIT_NV: VkPipelineCreateFlags = VkPipelineCreateFlags(1 << 20);
/// `1 << 25`  
pub const VK_PIPELINE_CREATE_COLOR_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT: VkPipelineCreateFlags = VkPipelineCreateFlags(1 << 25);
/// `1 << 26`  
pub const VK_PIPELINE_CREATE_DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT: VkPipelineCreateFlags = VkPipelineCreateFlags(1 << 26);
/// `1 << 24`  
pub const VK_PIPELINE_CREATE_RAY_TRACING_OPACITY_MICROMAP_BIT_EXT: VkPipelineCreateFlags = VkPipelineCreateFlags(1 << 24);
/// `1 << 28`  
pub const VK_PIPELINE_CREATE_RAY_TRACING_DISPLACEMENT_MICROMAP_BIT_NV: VkPipelineCreateFlags = VkPipelineCreateFlags(1 << 28);
/// `VK_PIPELINE_CREATE_NO_PROTECTED_ACCESS_BIT`  
pub const VK_PIPELINE_CREATE_NO_PROTECTED_ACCESS_BIT_EXT: VkPipelineCreateFlags = VK_PIPELINE_CREATE_NO_PROTECTED_ACCESS_BIT;
/// `VK_PIPELINE_CREATE_PROTECTED_ACCESS_ONLY_BIT`  
pub const VK_PIPELINE_CREATE_PROTECTED_ACCESS_ONLY_BIT_EXT: VkPipelineCreateFlags = VK_PIPELINE_CREATE_PROTECTED_ACCESS_ONLY_BIT;

impl_flags_display!(VkPipelineCreateFlags { VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT, VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT, VK_PIPELINE_CREATE_DERIVATIVE_BIT, VK_PIPELINE_CREATE_DISPATCH_BASE_BIT, VK_PIPELINE_CREATE_DISPATCH_BASE, VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT, VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT, VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT, VK_PIPELINE_CREATE_NO_PROTECTED_ACCESS_BIT, VK_PIPELINE_CREATE_PROTECTED_ACCESS_ONLY_BIT, VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHR, VK_PIPELINE_CREATE_DISPATCH_BASE_BIT_KHR, VK_PIPELINE_CREATE_DISPATCH_BASE_KHR, VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_BIT_KHR, VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_BIT_KHR, VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_MISS_SHADERS_BIT_KHR, VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_BIT_KHR, VK_PIPELINE_CREATE_RAY_TRACING_SKIP_TRIANGLES_BIT_KHR, VK_PIPELINE_CREATE_RAY_TRACING_SKIP_AABBS_BIT_KHR, VK_PIPELINE_CREATE_RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_BIT_KHR, VK_PIPELINE_CREATE_DEFER_COMPILE_BIT_NV, VK_PIPELINE_CREATE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT, VK_PIPELINE_RASTERIZATION_STATE_CREATE_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT, VK_PIPELINE_CREATE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR, VK_PIPELINE_RASTERIZATION_STATE_CREATE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR, VK_PIPELINE_CREATE_CAPTURE_STATISTICS_BIT_KHR, VK_PIPELINE_CREATE_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR, VK_PIPELINE_CREATE_INDIRECT_BINDABLE_BIT_NV, VK_PIPELINE_CREATE_LIBRARY_BIT_KHR, VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT_EXT, VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT_EXT, VK_PIPELINE_CREATE_DESCRIPTOR_BUFFER_BIT_EXT, VK_PIPELINE_CREATE_RETAIN_LINK_TIME_OPTIMIZATION_INFO_BIT_EXT, VK_PIPELINE_CREATE_LINK_TIME_OPTIMIZATION_BIT_EXT, VK_PIPELINE_CREATE_RAY_TRACING_ALLOW_MOTION_BIT_NV, VK_PIPELINE_CREATE_COLOR_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT, VK_PIPELINE_CREATE_DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT, VK_PIPELINE_CREATE_RAY_TRACING_OPACITY_MICROMAP_BIT_EXT, VK_PIPELINE_CREATE_RAY_TRACING_DISPLACEMENT_MICROMAP_BIT_NV, VK_PIPELINE_CREATE_NO_PROTECTED_ACCESS_BIT_EXT, VK_PIPELINE_CREATE_PROTECTED_ACCESS_ONLY_BIT_EXT });

flags!(VkPipelineCreateFlags2);
from_into_transparent!(VkPipelineCreateFlags2: i64);
/// `VkPipelineCreateFlags2`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkPipelineCreateFlags2(pub i64);

/// `1 << 0`  
pub const VK_PIPELINE_CREATE_2_DISABLE_OPTIMIZATION_BIT: VkPipelineCreateFlags2 = VkPipelineCreateFlags2(1 << 0);
/// `1 << 1`  
pub const VK_PIPELINE_CREATE_2_ALLOW_DERIVATIVES_BIT: VkPipelineCreateFlags2 = VkPipelineCreateFlags2(1 << 1);
/// `1 << 2`  
pub const VK_PIPELINE_CREATE_2_DERIVATIVE_BIT: VkPipelineCreateFlags2 = VkPipelineCreateFlags2(1 << 2);
/// `1 << 3`  
pub const VK_PIPELINE_CREATE_2_VIEW_INDEX_FROM_DEVICE_INDEX_BIT: VkPipelineCreateFlags2 = VkPipelineCreateFlags2(1 << 3);
/// `1 << 4`  
pub const VK_PIPELINE_CREATE_2_DISPATCH_BASE_BIT: VkPipelineCreateFlags2 = VkPipelineCreateFlags2(1 << 4);
/// `1 << 8`  
pub const VK_PIPELINE_CREATE_2_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT: VkPipelineCreateFlags2 = VkPipelineCreateFlags2(1 << 8);
/// `1 << 9`  
pub const VK_PIPELINE_CREATE_2_EARLY_RETURN_ON_FAILURE_BIT: VkPipelineCreateFlags2 = VkPipelineCreateFlags2(1 << 9);
/// `1 << 27`  
pub const VK_PIPELINE_CREATE_2_NO_PROTECTED_ACCESS_BIT: VkPipelineCreateFlags2 = VkPipelineCreateFlags2(1 << 27);
/// `1 << 30`  
pub const VK_PIPELINE_CREATE_2_PROTECTED_ACCESS_ONLY_BIT: VkPipelineCreateFlags2 = VkPipelineCreateFlags2(1 << 30);
/// `1 << 46`  
pub const VK_PIPELINE_CREATE_2_RESERVED_46_BIT_IMG: VkPipelineCreateFlags2 = VkPipelineCreateFlags2(1 << 46);
/// `1 << 32`  
pub const VK_PIPELINE_CREATE_2_EXECUTION_GRAPH_BIT_AMDX: VkPipelineCreateFlags2 = VkPipelineCreateFlags2(1 << 32);
/// `1 << 36`  
pub const VK_PIPELINE_CREATE_2_DESCRIPTOR_HEAP_BIT_EXT: VkPipelineCreateFlags2 = VkPipelineCreateFlags2(1 << 36);
/// `VK_PIPELINE_CREATE_2_RAY_TRACING_SKIP_TRIANGLES_BIT_KHR`  
pub const VK_PIPELINE_CREATE_2_RAY_TRACING_SKIP_BUILT_IN_PRIMITIVES_BIT_KHR: VkPipelineCreateFlags2 = VK_PIPELINE_CREATE_2_RAY_TRACING_SKIP_TRIANGLES_BIT_KHR;
/// `1 << 33`  
pub const VK_PIPELINE_CREATE_2_RAY_TRACING_ALLOW_SPHERES_AND_LINEAR_SWEPT_SPHERES_BIT_NV: VkPipelineCreateFlags2 = VkPipelineCreateFlags2(1 << 33);
/// `1 << 34`  
pub const VK_PIPELINE_CREATE_2_ENABLE_LEGACY_DITHERING_BIT_EXT: VkPipelineCreateFlags2 = VkPipelineCreateFlags2(1 << 34);
/// `VK_PIPELINE_CREATE_2_DISABLE_OPTIMIZATION_BIT`  
pub const VK_PIPELINE_CREATE_2_DISABLE_OPTIMIZATION_BIT_KHR: VkPipelineCreateFlags2 = VK_PIPELINE_CREATE_2_DISABLE_OPTIMIZATION_BIT;
/// `VK_PIPELINE_CREATE_2_ALLOW_DERIVATIVES_BIT`  
pub const VK_PIPELINE_CREATE_2_ALLOW_DERIVATIVES_BIT_KHR: VkPipelineCreateFlags2 = VK_PIPELINE_CREATE_2_ALLOW_DERIVATIVES_BIT;
/// `VK_PIPELINE_CREATE_2_DERIVATIVE_BIT`  
pub const VK_PIPELINE_CREATE_2_DERIVATIVE_BIT_KHR: VkPipelineCreateFlags2 = VK_PIPELINE_CREATE_2_DERIVATIVE_BIT;
/// `VK_PIPELINE_CREATE_2_VIEW_INDEX_FROM_DEVICE_INDEX_BIT`  
pub const VK_PIPELINE_CREATE_2_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHR: VkPipelineCreateFlags2 = VK_PIPELINE_CREATE_2_VIEW_INDEX_FROM_DEVICE_INDEX_BIT;
/// `VK_PIPELINE_CREATE_2_DISPATCH_BASE_BIT`  
pub const VK_PIPELINE_CREATE_2_DISPATCH_BASE_BIT_KHR: VkPipelineCreateFlags2 = VK_PIPELINE_CREATE_2_DISPATCH_BASE_BIT;
/// `1 << 5`  
pub const VK_PIPELINE_CREATE_2_DEFER_COMPILE_BIT_NV: VkPipelineCreateFlags2 = VkPipelineCreateFlags2(1 << 5);
/// `1 << 6`  
pub const VK_PIPELINE_CREATE_2_CAPTURE_STATISTICS_BIT_KHR: VkPipelineCreateFlags2 = VkPipelineCreateFlags2(1 << 6);
/// `1 << 7`  
pub const VK_PIPELINE_CREATE_2_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR: VkPipelineCreateFlags2 = VkPipelineCreateFlags2(1 << 7);
/// `VK_PIPELINE_CREATE_2_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT`  
pub const VK_PIPELINE_CREATE_2_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT_KHR: VkPipelineCreateFlags2 = VK_PIPELINE_CREATE_2_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT;
/// `VK_PIPELINE_CREATE_2_EARLY_RETURN_ON_FAILURE_BIT`  
pub const VK_PIPELINE_CREATE_2_EARLY_RETURN_ON_FAILURE_BIT_KHR: VkPipelineCreateFlags2 = VK_PIPELINE_CREATE_2_EARLY_RETURN_ON_FAILURE_BIT;
/// `1 << 10`  
pub const VK_PIPELINE_CREATE_2_LINK_TIME_OPTIMIZATION_BIT_EXT: VkPipelineCreateFlags2 = VkPipelineCreateFlags2(1 << 10);
/// `1 << 23`  
pub const VK_PIPELINE_CREATE_2_RETAIN_LINK_TIME_OPTIMIZATION_INFO_BIT_EXT: VkPipelineCreateFlags2 = VkPipelineCreateFlags2(1 << 23);
/// `1 << 11`  
pub const VK_PIPELINE_CREATE_2_LIBRARY_BIT_KHR: VkPipelineCreateFlags2 = VkPipelineCreateFlags2(1 << 11);
/// `1 << 12`  
pub const VK_PIPELINE_CREATE_2_RAY_TRACING_SKIP_TRIANGLES_BIT_KHR: VkPipelineCreateFlags2 = VkPipelineCreateFlags2(1 << 12);
/// `1 << 13`  
pub const VK_PIPELINE_CREATE_2_RAY_TRACING_SKIP_AABBS_BIT_KHR: VkPipelineCreateFlags2 = VkPipelineCreateFlags2(1 << 13);
/// `1 << 14`  
pub const VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_BIT_KHR: VkPipelineCreateFlags2 = VkPipelineCreateFlags2(1 << 14);
/// `1 << 15`  
pub const VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_BIT_KHR: VkPipelineCreateFlags2 = VkPipelineCreateFlags2(1 << 15);
/// `1 << 16`  
pub const VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_MISS_SHADERS_BIT_KHR: VkPipelineCreateFlags2 = VkPipelineCreateFlags2(1 << 16);
/// `1 << 17`  
pub const VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_BIT_KHR: VkPipelineCreateFlags2 = VkPipelineCreateFlags2(1 << 17);
/// `1 << 19`  
pub const VK_PIPELINE_CREATE_2_RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_BIT_KHR: VkPipelineCreateFlags2 = VkPipelineCreateFlags2(1 << 19);
/// `1 << 18`  
pub const VK_PIPELINE_CREATE_2_INDIRECT_BINDABLE_BIT_NV: VkPipelineCreateFlags2 = VkPipelineCreateFlags2(1 << 18);
/// `1 << 20`  
pub const VK_PIPELINE_CREATE_2_RAY_TRACING_ALLOW_MOTION_BIT_NV: VkPipelineCreateFlags2 = VkPipelineCreateFlags2(1 << 20);
/// `1 << 21`  
pub const VK_PIPELINE_CREATE_2_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR: VkPipelineCreateFlags2 = VkPipelineCreateFlags2(1 << 21);
/// `1 << 22`  
pub const VK_PIPELINE_CREATE_2_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT: VkPipelineCreateFlags2 = VkPipelineCreateFlags2(1 << 22);
/// `1 << 24`  
pub const VK_PIPELINE_CREATE_2_RAY_TRACING_OPACITY_MICROMAP_BIT_EXT: VkPipelineCreateFlags2 = VkPipelineCreateFlags2(1 << 24);
/// `1 << 25`  
pub const VK_PIPELINE_CREATE_2_COLOR_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT: VkPipelineCreateFlags2 = VkPipelineCreateFlags2(1 << 25);
/// `1 << 26`  
pub const VK_PIPELINE_CREATE_2_DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT: VkPipelineCreateFlags2 = VkPipelineCreateFlags2(1 << 26);
/// `VK_PIPELINE_CREATE_2_NO_PROTECTED_ACCESS_BIT`  
pub const VK_PIPELINE_CREATE_2_NO_PROTECTED_ACCESS_BIT_EXT: VkPipelineCreateFlags2 = VK_PIPELINE_CREATE_2_NO_PROTECTED_ACCESS_BIT;
/// `VK_PIPELINE_CREATE_2_PROTECTED_ACCESS_ONLY_BIT`  
pub const VK_PIPELINE_CREATE_2_PROTECTED_ACCESS_ONLY_BIT_EXT: VkPipelineCreateFlags2 = VK_PIPELINE_CREATE_2_PROTECTED_ACCESS_ONLY_BIT;
/// `1 << 28`  
pub const VK_PIPELINE_CREATE_2_RAY_TRACING_DISPLACEMENT_MICROMAP_BIT_NV: VkPipelineCreateFlags2 = VkPipelineCreateFlags2(1 << 28);
/// `1 << 29`  
pub const VK_PIPELINE_CREATE_2_DESCRIPTOR_BUFFER_BIT_EXT: VkPipelineCreateFlags2 = VkPipelineCreateFlags2(1 << 29);
/// `1 << 37`  
pub const VK_PIPELINE_CREATE_2_DISALLOW_OPACITY_MICROMAP_BIT_ARM: VkPipelineCreateFlags2 = VkPipelineCreateFlags2(1 << 37);
/// `1 << 39`  
pub const VK_PIPELINE_CREATE_2_INSTRUMENT_SHADERS_BIT_ARM: VkPipelineCreateFlags2 = VkPipelineCreateFlags2(1 << 39);
/// `1 << 31`  
pub const VK_PIPELINE_CREATE_2_CAPTURE_DATA_BIT_KHR: VkPipelineCreateFlags2 = VkPipelineCreateFlags2(1 << 31);
/// `1 << 38`  
pub const VK_PIPELINE_CREATE_2_INDIRECT_BINDABLE_BIT_EXT: VkPipelineCreateFlags2 = VkPipelineCreateFlags2(1 << 38);
/// `1 << 35`  
pub const VK_PIPELINE_CREATE_2_RESERVED_35_BIT_KHR: VkPipelineCreateFlags2 = VkPipelineCreateFlags2(1 << 35);
/// `1 << 40`  
pub const VK_PIPELINE_CREATE_2_PER_LAYER_FRAGMENT_DENSITY_BIT_VALVE: VkPipelineCreateFlags2 = VkPipelineCreateFlags2(1 << 40);
/// `1 << 43`  
pub const VK_PIPELINE_CREATE_2_64_BIT_INDEXING_BIT_EXT: VkPipelineCreateFlags2 = VkPipelineCreateFlags2(1 << 43);
/// `1 << 45`  
pub const VK_PIPELINE_CREATE_2_RESERVED_45_BIT_EXT: VkPipelineCreateFlags2 = VkPipelineCreateFlags2(1 << 45);
/// `1 << 47`  
pub const VK_PIPELINE_CREATE_2_RESERVED_47_BIT_AMD: VkPipelineCreateFlags2 = VkPipelineCreateFlags2(1 << 47);
/// `1 << 48`  
pub const VK_PIPELINE_CREATE_2_RESERVED_48_BIT_HUAWEI: VkPipelineCreateFlags2 = VkPipelineCreateFlags2(1 << 48);

impl_flags_display!(VkPipelineCreateFlags2 { VK_PIPELINE_CREATE_2_DISABLE_OPTIMIZATION_BIT, VK_PIPELINE_CREATE_2_ALLOW_DERIVATIVES_BIT, VK_PIPELINE_CREATE_2_DERIVATIVE_BIT, VK_PIPELINE_CREATE_2_VIEW_INDEX_FROM_DEVICE_INDEX_BIT, VK_PIPELINE_CREATE_2_DISPATCH_BASE_BIT, VK_PIPELINE_CREATE_2_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT, VK_PIPELINE_CREATE_2_EARLY_RETURN_ON_FAILURE_BIT, VK_PIPELINE_CREATE_2_NO_PROTECTED_ACCESS_BIT, VK_PIPELINE_CREATE_2_PROTECTED_ACCESS_ONLY_BIT, VK_PIPELINE_CREATE_2_RESERVED_46_BIT_IMG, VK_PIPELINE_CREATE_2_EXECUTION_GRAPH_BIT_AMDX, VK_PIPELINE_CREATE_2_DESCRIPTOR_HEAP_BIT_EXT, VK_PIPELINE_CREATE_2_RAY_TRACING_SKIP_BUILT_IN_PRIMITIVES_BIT_KHR, VK_PIPELINE_CREATE_2_RAY_TRACING_ALLOW_SPHERES_AND_LINEAR_SWEPT_SPHERES_BIT_NV, VK_PIPELINE_CREATE_2_ENABLE_LEGACY_DITHERING_BIT_EXT, VK_PIPELINE_CREATE_2_DISABLE_OPTIMIZATION_BIT_KHR, VK_PIPELINE_CREATE_2_ALLOW_DERIVATIVES_BIT_KHR, VK_PIPELINE_CREATE_2_DERIVATIVE_BIT_KHR, VK_PIPELINE_CREATE_2_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHR, VK_PIPELINE_CREATE_2_DISPATCH_BASE_BIT_KHR, VK_PIPELINE_CREATE_2_DEFER_COMPILE_BIT_NV, VK_PIPELINE_CREATE_2_CAPTURE_STATISTICS_BIT_KHR, VK_PIPELINE_CREATE_2_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR, VK_PIPELINE_CREATE_2_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT_KHR, VK_PIPELINE_CREATE_2_EARLY_RETURN_ON_FAILURE_BIT_KHR, VK_PIPELINE_CREATE_2_LINK_TIME_OPTIMIZATION_BIT_EXT, VK_PIPELINE_CREATE_2_RETAIN_LINK_TIME_OPTIMIZATION_INFO_BIT_EXT, VK_PIPELINE_CREATE_2_LIBRARY_BIT_KHR, VK_PIPELINE_CREATE_2_RAY_TRACING_SKIP_TRIANGLES_BIT_KHR, VK_PIPELINE_CREATE_2_RAY_TRACING_SKIP_AABBS_BIT_KHR, VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_BIT_KHR, VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_BIT_KHR, VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_MISS_SHADERS_BIT_KHR, VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_BIT_KHR, VK_PIPELINE_CREATE_2_RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_BIT_KHR, VK_PIPELINE_CREATE_2_INDIRECT_BINDABLE_BIT_NV, VK_PIPELINE_CREATE_2_RAY_TRACING_ALLOW_MOTION_BIT_NV, VK_PIPELINE_CREATE_2_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR, VK_PIPELINE_CREATE_2_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT, VK_PIPELINE_CREATE_2_RAY_TRACING_OPACITY_MICROMAP_BIT_EXT, VK_PIPELINE_CREATE_2_COLOR_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT, VK_PIPELINE_CREATE_2_DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT, VK_PIPELINE_CREATE_2_NO_PROTECTED_ACCESS_BIT_EXT, VK_PIPELINE_CREATE_2_PROTECTED_ACCESS_ONLY_BIT_EXT, VK_PIPELINE_CREATE_2_RAY_TRACING_DISPLACEMENT_MICROMAP_BIT_NV, VK_PIPELINE_CREATE_2_DESCRIPTOR_BUFFER_BIT_EXT, VK_PIPELINE_CREATE_2_DISALLOW_OPACITY_MICROMAP_BIT_ARM, VK_PIPELINE_CREATE_2_INSTRUMENT_SHADERS_BIT_ARM, VK_PIPELINE_CREATE_2_CAPTURE_DATA_BIT_KHR, VK_PIPELINE_CREATE_2_INDIRECT_BINDABLE_BIT_EXT, VK_PIPELINE_CREATE_2_RESERVED_35_BIT_KHR, VK_PIPELINE_CREATE_2_PER_LAYER_FRAGMENT_DENSITY_BIT_VALVE, VK_PIPELINE_CREATE_2_64_BIT_INDEXING_BIT_EXT, VK_PIPELINE_CREATE_2_RESERVED_45_BIT_EXT, VK_PIPELINE_CREATE_2_RESERVED_47_BIT_AMD, VK_PIPELINE_CREATE_2_RESERVED_48_BIT_HUAWEI });

/// `VkPipelineCreateFlags2CreateInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPipelineCreateFlags2CreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub flags: VkPipelineCreateFlags2,
}
impl_default_zeroed_with_s_type!(VkPipelineCreateFlags2CreateInfo : VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO);
impl_extends!(VkPipelineCreateFlags2CreateInfo : VkComputePipelineCreateInfo, VkGraphicsPipelineCreateInfo, VkRayTracingPipelineCreateInfoNV, VkRayTracingPipelineCreateInfoKHR);

/// `VkPipelineCreateFlags2CreateInfo`
pub type VkPipelineCreateFlags2CreateInfoKHR = VkPipelineCreateFlags2CreateInfo;

/// `VkPipelineCreateFlags2`
pub type VkPipelineCreateFlags2KHR = VkPipelineCreateFlags2;

/// `VkPipelineCreateInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPipelineCreateInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
}
impl_default_zeroed_with_s_type!(VkPipelineCreateInfoKHR : VK_STRUCTURE_TYPE_PIPELINE_CREATE_INFO_KHR);

/// `VkPipelineCreationFeedback`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPipelineCreationFeedback {
    pub flags: VkPipelineCreationFeedbackFlags,
    pub duration: uint64_t,
}
impl_default_zeroed!(VkPipelineCreationFeedback);

/// `VkPipelineCreationFeedbackCreateInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPipelineCreationFeedbackCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    /// Output pipeline creation feedback.
    pub pPipelineCreationFeedback: *mut VkPipelineCreationFeedback,
    pub pipelineStageCreationFeedbackCount: uint32_t,
    /// One entry for each shader stage specified in the parent Vk*PipelineCreateInfo struct
    pub pPipelineStageCreationFeedbacks: *mut VkPipelineCreationFeedback,
}
impl_default_zeroed_with_s_type!(VkPipelineCreationFeedbackCreateInfo : VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO);
impl_extends!(VkPipelineCreationFeedbackCreateInfo : VkGraphicsPipelineCreateInfo, VkComputePipelineCreateInfo, VkRayTracingPipelineCreateInfoNV, VkRayTracingPipelineCreateInfoKHR, VkExecutionGraphPipelineCreateInfoAMDX, VkDataGraphPipelineCreateInfoARM);

/// `VkPipelineCreationFeedbackCreateInfo`
pub type VkPipelineCreationFeedbackCreateInfoEXT = VkPipelineCreationFeedbackCreateInfo;

/// `VkPipelineCreationFeedback`
pub type VkPipelineCreationFeedbackEXT = VkPipelineCreationFeedback;

flags!(VkPipelineCreationFeedbackFlags);
from_into_transparent!(VkPipelineCreationFeedbackFlags: i32);
/// `VkPipelineCreationFeedbackFlags`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkPipelineCreationFeedbackFlags(pub i32);

/// `1 << 0`  
pub const VK_PIPELINE_CREATION_FEEDBACK_VALID_BIT: VkPipelineCreationFeedbackFlags = VkPipelineCreationFeedbackFlags(1 << 0);
/// `1 << 1`  
pub const VK_PIPELINE_CREATION_FEEDBACK_APPLICATION_PIPELINE_CACHE_HIT_BIT: VkPipelineCreationFeedbackFlags = VkPipelineCreationFeedbackFlags(1 << 1);
/// `1 << 2`  
pub const VK_PIPELINE_CREATION_FEEDBACK_BASE_PIPELINE_ACCELERATION_BIT: VkPipelineCreationFeedbackFlags = VkPipelineCreationFeedbackFlags(1 << 2);
/// `VK_PIPELINE_CREATION_FEEDBACK_VALID_BIT`  
pub const VK_PIPELINE_CREATION_FEEDBACK_VALID_BIT_EXT: VkPipelineCreationFeedbackFlags = VK_PIPELINE_CREATION_FEEDBACK_VALID_BIT;
/// `VK_PIPELINE_CREATION_FEEDBACK_APPLICATION_PIPELINE_CACHE_HIT_BIT`  
pub const VK_PIPELINE_CREATION_FEEDBACK_APPLICATION_PIPELINE_CACHE_HIT_BIT_EXT: VkPipelineCreationFeedbackFlags = VK_PIPELINE_CREATION_FEEDBACK_APPLICATION_PIPELINE_CACHE_HIT_BIT;
/// `VK_PIPELINE_CREATION_FEEDBACK_BASE_PIPELINE_ACCELERATION_BIT`  
pub const VK_PIPELINE_CREATION_FEEDBACK_BASE_PIPELINE_ACCELERATION_BIT_EXT: VkPipelineCreationFeedbackFlags = VK_PIPELINE_CREATION_FEEDBACK_BASE_PIPELINE_ACCELERATION_BIT;

impl_flags_display!(VkPipelineCreationFeedbackFlags { VK_PIPELINE_CREATION_FEEDBACK_VALID_BIT, VK_PIPELINE_CREATION_FEEDBACK_APPLICATION_PIPELINE_CACHE_HIT_BIT, VK_PIPELINE_CREATION_FEEDBACK_BASE_PIPELINE_ACCELERATION_BIT, VK_PIPELINE_CREATION_FEEDBACK_VALID_BIT_EXT, VK_PIPELINE_CREATION_FEEDBACK_APPLICATION_PIPELINE_CACHE_HIT_BIT_EXT, VK_PIPELINE_CREATION_FEEDBACK_BASE_PIPELINE_ACCELERATION_BIT_EXT });

/// `VkPipelineCreationFeedbackFlags`
pub type VkPipelineCreationFeedbackFlagsEXT = VkPipelineCreationFeedbackFlags;

flags!(VkPipelineDepthStencilStateCreateFlags);
from_into_transparent!(VkPipelineDepthStencilStateCreateFlags: i32);
/// `VkPipelineDepthStencilStateCreateFlags`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkPipelineDepthStencilStateCreateFlags(pub i32);

/// `VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_EXT`  
pub const VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_ARM: VkPipelineDepthStencilStateCreateFlags = VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_EXT;
/// `VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_EXT`  
pub const VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_ARM: VkPipelineDepthStencilStateCreateFlags = VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_EXT;
/// `1 << 0`  
pub const VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_EXT: VkPipelineDepthStencilStateCreateFlags = VkPipelineDepthStencilStateCreateFlags(1 << 0);
/// `1 << 1`  
pub const VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_EXT: VkPipelineDepthStencilStateCreateFlags = VkPipelineDepthStencilStateCreateFlags(1 << 1);

impl_flags_display!(VkPipelineDepthStencilStateCreateFlags { VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_ARM, VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_ARM, VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_EXT, VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_EXT });

/// `VkPipelineDepthStencilStateCreateInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPipelineDepthStencilStateCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub flags: VkPipelineDepthStencilStateCreateFlags,
    pub depthTestEnable: VkBool32,
    pub depthWriteEnable: VkBool32,
    pub depthCompareOp: VkCompareOp,
    /// optional (depth_bounds_test)
    pub depthBoundsTestEnable: VkBool32,
    pub stencilTestEnable: VkBool32,
    pub front: VkStencilOpState,
    pub back: VkStencilOpState,
    pub minDepthBounds: float,
    pub maxDepthBounds: float,
}
impl_default_zeroed_with_s_type!(VkPipelineDepthStencilStateCreateInfo : VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO);

flags!(VkPipelineDiscardRectangleStateCreateFlagsEXT);
from_into_transparent!(VkPipelineDiscardRectangleStateCreateFlagsEXT: i32);
/// `VkPipelineDiscardRectangleStateCreateFlagsEXT`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkPipelineDiscardRectangleStateCreateFlagsEXT(pub i32);

impl_flags_display!(VkPipelineDiscardRectangleStateCreateFlagsEXT {  });

/// `VkPipelineDiscardRectangleStateCreateInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPipelineDiscardRectangleStateCreateInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub flags: VkPipelineDiscardRectangleStateCreateFlagsEXT,
    pub discardRectangleMode: VkDiscardRectangleModeEXT,
    pub discardRectangleCount: uint32_t,
    pub pDiscardRectangles: *const VkRect2D,
}
impl_default_zeroed_with_s_type!(VkPipelineDiscardRectangleStateCreateInfoEXT : VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT);
impl_extends!(VkPipelineDiscardRectangleStateCreateInfoEXT : VkGraphicsPipelineCreateInfo);

flags!(VkPipelineDynamicStateCreateFlags);
from_into_transparent!(VkPipelineDynamicStateCreateFlags: i32);
/// `VkPipelineDynamicStateCreateFlags`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkPipelineDynamicStateCreateFlags(pub i32);

impl_flags_display!(VkPipelineDynamicStateCreateFlags {  });

/// `VkPipelineDynamicStateCreateInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPipelineDynamicStateCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub flags: VkPipelineDynamicStateCreateFlags,
    pub dynamicStateCount: uint32_t,
    pub pDynamicStates: *const VkDynamicState,
}
impl_default_zeroed_with_s_type!(VkPipelineDynamicStateCreateInfo : VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO);

/// `VkPipelineExecutableInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPipelineExecutableInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub pipeline: VkPipeline,
    pub executableIndex: uint32_t,
}
impl_default_zeroed_with_s_type!(VkPipelineExecutableInfoKHR : VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR);

/// `VkPipelineExecutableInternalRepresentationKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPipelineExecutableInternalRepresentationKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub name: [c_char; VK_MAX_DESCRIPTION_SIZE as usize],
    pub description: [c_char; VK_MAX_DESCRIPTION_SIZE as usize],
    pub isText: VkBool32,
    pub dataSize: size_t,
    pub pData: *mut void,
}
impl_default_zeroed_with_s_type!(VkPipelineExecutableInternalRepresentationKHR : VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR);

/// `VkPipelineExecutablePropertiesKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPipelineExecutablePropertiesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub stages: VkShaderStageFlags,
    pub name: [c_char; VK_MAX_DESCRIPTION_SIZE as usize],
    pub description: [c_char; VK_MAX_DESCRIPTION_SIZE as usize],
    pub subgroupSize: uint32_t,
}
impl_default_zeroed_with_s_type!(VkPipelineExecutablePropertiesKHR : VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_PROPERTIES_KHR);

from_into_transparent!(VkPipelineExecutableStatisticFormatKHR: i32);
/// `VkPipelineExecutableStatisticFormatKHR`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkPipelineExecutableStatisticFormatKHR(pub i32);

/// `0`  
pub const VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_BOOL32_KHR: VkPipelineExecutableStatisticFormatKHR = VkPipelineExecutableStatisticFormatKHR(0);
/// `1`  
pub const VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_INT64_KHR: VkPipelineExecutableStatisticFormatKHR = VkPipelineExecutableStatisticFormatKHR(1);
/// `2`  
pub const VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_UINT64_KHR: VkPipelineExecutableStatisticFormatKHR = VkPipelineExecutableStatisticFormatKHR(2);
/// `3`  
pub const VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_FLOAT64_KHR: VkPipelineExecutableStatisticFormatKHR = VkPipelineExecutableStatisticFormatKHR(3);

impl_enum_display!(VkPipelineExecutableStatisticFormatKHR { VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_BOOL32_KHR, VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_INT64_KHR, VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_UINT64_KHR, VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_FLOAT64_KHR });

/// `VkPipelineExecutableStatisticKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPipelineExecutableStatisticKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub name: [c_char; VK_MAX_DESCRIPTION_SIZE as usize],
    pub description: [c_char; VK_MAX_DESCRIPTION_SIZE as usize],
    pub format: VkPipelineExecutableStatisticFormatKHR,
    pub value: VkPipelineExecutableStatisticValueKHR,
}
impl_default_zeroed_with_s_type!(VkPipelineExecutableStatisticKHR : VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR);

/// `VkPipelineExecutableStatisticValueKHR`
#[repr(C)]
#[derive(Clone, Copy)]
pub union VkPipelineExecutableStatisticValueKHR {
    pub b32: VkBool32,
    pub i64: int64_t,
    pub u64: uint64_t,
    pub f64: double,
}
impl_debug_for_union!(VkPipelineExecutableStatisticValueKHR);
impl_default_zeroed!(VkPipelineExecutableStatisticValueKHR);

/// `VkPipelineFragmentDensityMapLayeredCreateInfoVALVE`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPipelineFragmentDensityMapLayeredCreateInfoVALVE {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub maxFragmentDensityMapLayers: uint32_t,
}
impl_default_zeroed_with_s_type!(VkPipelineFragmentDensityMapLayeredCreateInfoVALVE : VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_DENSITY_MAP_LAYERED_CREATE_INFO_VALVE);
impl_extends!(VkPipelineFragmentDensityMapLayeredCreateInfoVALVE : VkGraphicsPipelineCreateInfo);

/// `VkPipelineFragmentShadingRateEnumStateCreateInfoNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPipelineFragmentShadingRateEnumStateCreateInfoNV {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub shadingRateType: VkFragmentShadingRateTypeNV,
    pub shadingRate: VkFragmentShadingRateNV,
    pub combinerOps: [VkFragmentShadingRateCombinerOpKHR; 2 as usize],
}
impl_default_zeroed_with_s_type!(VkPipelineFragmentShadingRateEnumStateCreateInfoNV : VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV);
impl_extends!(VkPipelineFragmentShadingRateEnumStateCreateInfoNV : VkGraphicsPipelineCreateInfo);

/// `VkPipelineFragmentShadingRateStateCreateInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPipelineFragmentShadingRateStateCreateInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub fragmentSize: VkExtent2D,
    pub combinerOps: [VkFragmentShadingRateCombinerOpKHR; 2 as usize],
}
impl_default_zeroed_with_s_type!(VkPipelineFragmentShadingRateStateCreateInfoKHR : VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR);
impl_extends!(VkPipelineFragmentShadingRateStateCreateInfoKHR : VkGraphicsPipelineCreateInfo);

/// `VkPipelineIndirectDeviceAddressInfoNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPipelineIndirectDeviceAddressInfoNV {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub pipelineBindPoint: VkPipelineBindPoint,
    pub pipeline: VkPipeline,
}
impl_default_zeroed_with_s_type!(VkPipelineIndirectDeviceAddressInfoNV : VK_STRUCTURE_TYPE_PIPELINE_INDIRECT_DEVICE_ADDRESS_INFO_NV);

/// `VkPipelineInfoKHR`
pub type VkPipelineInfoEXT = VkPipelineInfoKHR;

/// `VkPipelineInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPipelineInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub pipeline: VkPipeline,
}
impl_default_zeroed_with_s_type!(VkPipelineInfoKHR : VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR);

flags!(VkPipelineInputAssemblyStateCreateFlags);
from_into_transparent!(VkPipelineInputAssemblyStateCreateFlags: i32);
/// `VkPipelineInputAssemblyStateCreateFlags`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkPipelineInputAssemblyStateCreateFlags(pub i32);

impl_flags_display!(VkPipelineInputAssemblyStateCreateFlags {  });

/// `VkPipelineInputAssemblyStateCreateInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPipelineInputAssemblyStateCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub flags: VkPipelineInputAssemblyStateCreateFlags,
    pub topology: VkPrimitiveTopology,
    pub primitiveRestartEnable: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPipelineInputAssemblyStateCreateInfo : VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO);

/// `VkPipelineLayout` : `VkDevice`
#[repr(transparent)]
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkPipelineLayout(pub u64);
from_into_transparent!(VkPipelineLayout: u64);
impl_handle!(VkPipelineLayout: VK_OBJECT_TYPE_PIPELINE_LAYOUT; SubHandle = VkDevice);

flags!(VkPipelineLayoutCreateFlags);
from_into_transparent!(VkPipelineLayoutCreateFlags: i32);
/// `VkPipelineLayoutCreateFlags`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkPipelineLayoutCreateFlags(pub i32);

/// `1 << 0`  
pub const VK_PIPELINE_LAYOUT_CREATE_RESERVED_0_BIT_AMD: VkPipelineLayoutCreateFlags = VkPipelineLayoutCreateFlags(1 << 0);
/// `1 << 1`  
pub const VK_PIPELINE_LAYOUT_CREATE_INDEPENDENT_SETS_BIT_EXT: VkPipelineLayoutCreateFlags = VkPipelineLayoutCreateFlags(1 << 1);

impl_flags_display!(VkPipelineLayoutCreateFlags { VK_PIPELINE_LAYOUT_CREATE_RESERVED_0_BIT_AMD, VK_PIPELINE_LAYOUT_CREATE_INDEPENDENT_SETS_BIT_EXT });

/// `VkPipelineLayoutCreateInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPipelineLayoutCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub flags: VkPipelineLayoutCreateFlags,
    /// Number of descriptor sets interfaced by the pipeline
    pub setLayoutCount: uint32_t,
    /// Array of setCount number of descriptor set layout objects defining the layout of the
    pub pSetLayouts: *const VkDescriptorSetLayout,
    /// Number of push-constant ranges used by the pipeline
    pub pushConstantRangeCount: uint32_t,
    /// Array of pushConstantRangeCount number of ranges used by various shader stages
    pub pPushConstantRanges: *const VkPushConstantRange,
}
impl_default_zeroed_with_s_type!(VkPipelineLayoutCreateInfo : VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO);
impl_extends!(VkPipelineLayoutCreateInfo : VkBindDescriptorSetsInfo, VkPushConstantsInfo, VkPushDescriptorSetInfo, VkPushDescriptorSetWithTemplateInfo, VkSetDescriptorBufferOffsetsInfoEXT, VkBindDescriptorBufferEmbeddedSamplersInfoEXT, VkIndirectCommandsLayoutCreateInfoEXT);

/// `VkPipelineLibraryCreateInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPipelineLibraryCreateInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub libraryCount: uint32_t,
    pub pLibraries: *const VkPipeline,
}
impl_default_zeroed_with_s_type!(VkPipelineLibraryCreateInfoKHR : VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR);
impl_extends!(VkPipelineLibraryCreateInfoKHR : VkGraphicsPipelineCreateInfo);

from_into_transparent!(VkPipelineMatchControl: i32);
/// `VkPipelineMatchControl`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkPipelineMatchControl(pub i32);

/// `0`  
pub const VK_PIPELINE_MATCH_CONTROL_APPLICATION_UUID_EXACT_MATCH: VkPipelineMatchControl = VkPipelineMatchControl(0);

impl_enum_display!(VkPipelineMatchControl { VK_PIPELINE_MATCH_CONTROL_APPLICATION_UUID_EXACT_MATCH });

flags!(VkPipelineMultisampleStateCreateFlags);
from_into_transparent!(VkPipelineMultisampleStateCreateFlags: i32);
/// `VkPipelineMultisampleStateCreateFlags`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkPipelineMultisampleStateCreateFlags(pub i32);

impl_flags_display!(VkPipelineMultisampleStateCreateFlags {  });

/// `VkPipelineMultisampleStateCreateInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPipelineMultisampleStateCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub flags: VkPipelineMultisampleStateCreateFlags,
    /// Number of samples used for rasterization
    pub rasterizationSamples: VkSampleCountFlags,
    /// optional (GL45)
    pub sampleShadingEnable: VkBool32,
    /// optional (GL45)
    pub minSampleShading: float,
    /// Array of sampleMask words
    pub pSampleMask: *const VkSampleMask,
    pub alphaToCoverageEnable: VkBool32,
    pub alphaToOneEnable: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPipelineMultisampleStateCreateInfo : VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO);

/// `VkPipelineOfflineCreateInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPipelineOfflineCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub pipelineIdentifier: [uint8_t; VK_UUID_SIZE as usize],
    pub matchControl: VkPipelineMatchControl,
    pub poolEntrySize: VkDeviceSize,
}
impl_default_zeroed_with_s_type!(VkPipelineOfflineCreateInfo : VK_STRUCTURE_TYPE_PIPELINE_OFFLINE_CREATE_INFO);
impl_extends!(VkPipelineOfflineCreateInfo : VkGraphicsPipelineCreateInfo, VkComputePipelineCreateInfo, VkRayTracingPipelineCreateInfoKHR, VkRayTracingPipelineCreateInfoNV);

/// `VkPipelinePoolSize`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPipelinePoolSize {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub poolEntrySize: VkDeviceSize,
    pub poolEntryCount: uint32_t,
}
impl_default_zeroed_with_s_type!(VkPipelinePoolSize : VK_STRUCTURE_TYPE_PIPELINE_POOL_SIZE);

/// `VkPipelinePropertiesIdentifierEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPipelinePropertiesIdentifierEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub pipelineIdentifier: [uint8_t; VK_UUID_SIZE as usize],
}
impl_default_zeroed_with_s_type!(VkPipelinePropertiesIdentifierEXT : VK_STRUCTURE_TYPE_PIPELINE_PROPERTIES_IDENTIFIER_EXT);

flags!(VkPipelineRasterizationConservativeStateCreateFlagsEXT);
from_into_transparent!(VkPipelineRasterizationConservativeStateCreateFlagsEXT: i32);
/// `VkPipelineRasterizationConservativeStateCreateFlagsEXT`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkPipelineRasterizationConservativeStateCreateFlagsEXT(pub i32);

impl_flags_display!(VkPipelineRasterizationConservativeStateCreateFlagsEXT {  });

/// `VkPipelineRasterizationConservativeStateCreateInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPipelineRasterizationConservativeStateCreateInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    /// Reserved
    pub flags: VkPipelineRasterizationConservativeStateCreateFlagsEXT,
    /// Conservative rasterization mode
    pub conservativeRasterizationMode: VkConservativeRasterizationModeEXT,
    /// Extra overestimation to add to the primitive
    pub extraPrimitiveOverestimationSize: float,
}
impl_default_zeroed_with_s_type!(VkPipelineRasterizationConservativeStateCreateInfoEXT : VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT);
impl_extends!(VkPipelineRasterizationConservativeStateCreateInfoEXT : VkPipelineRasterizationStateCreateInfo);

flags!(VkPipelineRasterizationDepthClipStateCreateFlagsEXT);
from_into_transparent!(VkPipelineRasterizationDepthClipStateCreateFlagsEXT: i32);
/// `VkPipelineRasterizationDepthClipStateCreateFlagsEXT`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkPipelineRasterizationDepthClipStateCreateFlagsEXT(pub i32);

impl_flags_display!(VkPipelineRasterizationDepthClipStateCreateFlagsEXT {  });

/// `VkPipelineRasterizationDepthClipStateCreateInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPipelineRasterizationDepthClipStateCreateInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    /// Reserved
    pub flags: VkPipelineRasterizationDepthClipStateCreateFlagsEXT,
    pub depthClipEnable: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPipelineRasterizationDepthClipStateCreateInfoEXT : VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT);
impl_extends!(VkPipelineRasterizationDepthClipStateCreateInfoEXT : VkPipelineRasterizationStateCreateInfo);

/// `VkPipelineRasterizationLineStateCreateInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPipelineRasterizationLineStateCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub lineRasterizationMode: VkLineRasterizationMode,
    pub stippledLineEnable: VkBool32,
    pub lineStippleFactor: uint32_t,
    pub lineStipplePattern: uint16_t,
}
impl_default_zeroed_with_s_type!(VkPipelineRasterizationLineStateCreateInfo : VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO);
impl_extends!(VkPipelineRasterizationLineStateCreateInfo : VkPipelineRasterizationStateCreateInfo);

/// `VkPipelineRasterizationLineStateCreateInfo`
pub type VkPipelineRasterizationLineStateCreateInfoEXT = VkPipelineRasterizationLineStateCreateInfo;

/// `VkPipelineRasterizationLineStateCreateInfo`
pub type VkPipelineRasterizationLineStateCreateInfoKHR = VkPipelineRasterizationLineStateCreateInfo;

/// `VkPipelineRasterizationProvokingVertexStateCreateInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPipelineRasterizationProvokingVertexStateCreateInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub provokingVertexMode: VkProvokingVertexModeEXT,
}
impl_default_zeroed_with_s_type!(VkPipelineRasterizationProvokingVertexStateCreateInfoEXT : VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT);
impl_extends!(VkPipelineRasterizationProvokingVertexStateCreateInfoEXT : VkPipelineRasterizationStateCreateInfo);

flags!(VkPipelineRasterizationStateCreateFlags);
from_into_transparent!(VkPipelineRasterizationStateCreateFlags: i32);
/// `VkPipelineRasterizationStateCreateFlags`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkPipelineRasterizationStateCreateFlags(pub i32);

impl_flags_display!(VkPipelineRasterizationStateCreateFlags {  });

/// `VkPipelineRasterizationStateCreateInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPipelineRasterizationStateCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub flags: VkPipelineRasterizationStateCreateFlags,
    pub depthClampEnable: VkBool32,
    pub rasterizerDiscardEnable: VkBool32,
    /// optional (GL45)
    pub polygonMode: VkPolygonMode,
    pub cullMode: VkCullModeFlags,
    pub frontFace: VkFrontFace,
    pub depthBiasEnable: VkBool32,
    pub depthBiasConstantFactor: float,
    pub depthBiasClamp: float,
    pub depthBiasSlopeFactor: float,
    pub lineWidth: float,
}
impl_default_zeroed_with_s_type!(VkPipelineRasterizationStateCreateInfo : VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO);

/// `VkPipelineRasterizationStateRasterizationOrderAMD`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPipelineRasterizationStateRasterizationOrderAMD {
    pub sType: VkStructureType,
    pub pNext: *const void,
    /// Rasterization order to use for the pipeline
    pub rasterizationOrder: VkRasterizationOrderAMD,
}
impl_default_zeroed_with_s_type!(VkPipelineRasterizationStateRasterizationOrderAMD : VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD);
impl_extends!(VkPipelineRasterizationStateRasterizationOrderAMD : VkPipelineRasterizationStateCreateInfo);

flags!(VkPipelineRasterizationStateStreamCreateFlagsEXT);
from_into_transparent!(VkPipelineRasterizationStateStreamCreateFlagsEXT: i32);
/// `VkPipelineRasterizationStateStreamCreateFlagsEXT`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkPipelineRasterizationStateStreamCreateFlagsEXT(pub i32);

impl_flags_display!(VkPipelineRasterizationStateStreamCreateFlagsEXT {  });

/// `VkPipelineRasterizationStateStreamCreateInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPipelineRasterizationStateStreamCreateInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub flags: VkPipelineRasterizationStateStreamCreateFlagsEXT,
    pub rasterizationStream: uint32_t,
}
impl_default_zeroed_with_s_type!(VkPipelineRasterizationStateStreamCreateInfoEXT : VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT);
impl_extends!(VkPipelineRasterizationStateStreamCreateInfoEXT : VkPipelineRasterizationStateCreateInfo);

/// `VkPipelineRenderingCreateInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPipelineRenderingCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub viewMask: uint32_t,
    pub colorAttachmentCount: uint32_t,
    pub pColorAttachmentFormats: *const VkFormat,
    pub depthAttachmentFormat: VkFormat,
    pub stencilAttachmentFormat: VkFormat,
}
impl_default_zeroed_with_s_type!(VkPipelineRenderingCreateInfo : VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO);
impl_extends!(VkPipelineRenderingCreateInfo : VkGraphicsPipelineCreateInfo);

/// `VkPipelineRenderingCreateInfo`
pub type VkPipelineRenderingCreateInfoKHR = VkPipelineRenderingCreateInfo;

/// `VkPipelineRepresentativeFragmentTestStateCreateInfoNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPipelineRepresentativeFragmentTestStateCreateInfoNV {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub representativeFragmentTestEnable: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPipelineRepresentativeFragmentTestStateCreateInfoNV : VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV);
impl_extends!(VkPipelineRepresentativeFragmentTestStateCreateInfoNV : VkGraphicsPipelineCreateInfo);

from_into_transparent!(VkPipelineRobustnessBufferBehavior: i32);
/// `VkPipelineRobustnessBufferBehavior`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkPipelineRobustnessBufferBehavior(pub i32);

/// `0`  
pub const VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DEVICE_DEFAULT: VkPipelineRobustnessBufferBehavior = VkPipelineRobustnessBufferBehavior(0);
/// `1`  
pub const VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DISABLED: VkPipelineRobustnessBufferBehavior = VkPipelineRobustnessBufferBehavior(1);
/// `2`  
pub const VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS: VkPipelineRobustnessBufferBehavior = VkPipelineRobustnessBufferBehavior(2);
/// `3`  
pub const VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2: VkPipelineRobustnessBufferBehavior = VkPipelineRobustnessBufferBehavior(3);
/// `VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DEVICE_DEFAULT`  
pub const VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DEVICE_DEFAULT_EXT: VkPipelineRobustnessBufferBehavior = VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DEVICE_DEFAULT;
/// `VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DISABLED`  
pub const VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DISABLED_EXT: VkPipelineRobustnessBufferBehavior = VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DISABLED;
/// `VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS`  
pub const VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_EXT: VkPipelineRobustnessBufferBehavior = VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS;
/// `VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2`  
pub const VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2_EXT: VkPipelineRobustnessBufferBehavior = VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2;

impl_enum_display!(VkPipelineRobustnessBufferBehavior { VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DEVICE_DEFAULT, VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DISABLED, VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS, VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2, VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DEVICE_DEFAULT_EXT, VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DISABLED_EXT, VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_EXT, VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2_EXT });

/// `VkPipelineRobustnessBufferBehavior`
pub type VkPipelineRobustnessBufferBehaviorEXT = VkPipelineRobustnessBufferBehavior;

/// `VkPipelineRobustnessCreateInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPipelineRobustnessCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub storageBuffers: VkPipelineRobustnessBufferBehavior,
    pub uniformBuffers: VkPipelineRobustnessBufferBehavior,
    pub vertexInputs: VkPipelineRobustnessBufferBehavior,
    pub images: VkPipelineRobustnessImageBehavior,
}
impl_default_zeroed_with_s_type!(VkPipelineRobustnessCreateInfo : VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO);
impl_extends!(VkPipelineRobustnessCreateInfo : VkGraphicsPipelineCreateInfo, VkComputePipelineCreateInfo, VkPipelineShaderStageCreateInfo, VkRayTracingPipelineCreateInfoKHR);

/// `VkPipelineRobustnessCreateInfo`
pub type VkPipelineRobustnessCreateInfoEXT = VkPipelineRobustnessCreateInfo;

from_into_transparent!(VkPipelineRobustnessImageBehavior: i32);
/// `VkPipelineRobustnessImageBehavior`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkPipelineRobustnessImageBehavior(pub i32);

/// `0`  
pub const VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DEVICE_DEFAULT: VkPipelineRobustnessImageBehavior = VkPipelineRobustnessImageBehavior(0);
/// `1`  
pub const VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DISABLED: VkPipelineRobustnessImageBehavior = VkPipelineRobustnessImageBehavior(1);
/// `2`  
pub const VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS: VkPipelineRobustnessImageBehavior = VkPipelineRobustnessImageBehavior(2);
/// `3`  
pub const VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS_2: VkPipelineRobustnessImageBehavior = VkPipelineRobustnessImageBehavior(3);
/// `VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DEVICE_DEFAULT`  
pub const VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DEVICE_DEFAULT_EXT: VkPipelineRobustnessImageBehavior = VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DEVICE_DEFAULT;
/// `VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DISABLED`  
pub const VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DISABLED_EXT: VkPipelineRobustnessImageBehavior = VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DISABLED;
/// `VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS`  
pub const VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS_EXT: VkPipelineRobustnessImageBehavior = VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS;
/// `VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS_2`  
pub const VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS_2_EXT: VkPipelineRobustnessImageBehavior = VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS_2;

impl_enum_display!(VkPipelineRobustnessImageBehavior { VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DEVICE_DEFAULT, VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DISABLED, VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS, VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS_2, VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DEVICE_DEFAULT_EXT, VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DISABLED_EXT, VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS_EXT, VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS_2_EXT });

/// `VkPipelineRobustnessImageBehavior`
pub type VkPipelineRobustnessImageBehaviorEXT = VkPipelineRobustnessImageBehavior;

/// `VkPipelineSampleLocationsStateCreateInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPipelineSampleLocationsStateCreateInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub sampleLocationsEnable: VkBool32,
    pub sampleLocationsInfo: VkSampleLocationsInfoEXT,
}
impl_default_zeroed_with_s_type!(VkPipelineSampleLocationsStateCreateInfoEXT : VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT);
impl_extends!(VkPipelineSampleLocationsStateCreateInfoEXT : VkPipelineMultisampleStateCreateInfo);

flags!(VkPipelineShaderStageCreateFlags);
from_into_transparent!(VkPipelineShaderStageCreateFlags: i32);
/// `VkPipelineShaderStageCreateFlags`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkPipelineShaderStageCreateFlags(pub i32);

/// `1 << 0`  
pub const VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT: VkPipelineShaderStageCreateFlags = VkPipelineShaderStageCreateFlags(1 << 0);
/// `1 << 1`  
pub const VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT: VkPipelineShaderStageCreateFlags = VkPipelineShaderStageCreateFlags(1 << 1);
/// `VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT`  
pub const VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT: VkPipelineShaderStageCreateFlags = VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT;
/// `VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT`  
pub const VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT: VkPipelineShaderStageCreateFlags = VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT;
/// `1 << 3`  
pub const VK_PIPELINE_SHADER_STAGE_CREATE_RESERVED_3_BIT_KHR: VkPipelineShaderStageCreateFlags = VkPipelineShaderStageCreateFlags(1 << 3);

impl_flags_display!(VkPipelineShaderStageCreateFlags { VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT, VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT, VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT, VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT, VK_PIPELINE_SHADER_STAGE_CREATE_RESERVED_3_BIT_KHR });

/// `VkPipelineShaderStageCreateInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPipelineShaderStageCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub flags: VkPipelineShaderStageCreateFlags,
    /// Shader stage
    pub stage: VkShaderStageFlags,
    /// Module containing entry point
    pub module: VkShaderModule,
    /// Null-terminated entry point name
    pub pName: *const c_char,
    pub pSpecializationInfo: *const VkSpecializationInfo,
}
impl_default_zeroed_with_s_type!(VkPipelineShaderStageCreateInfo : VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO);

/// `VkPipelineShaderStageModuleIdentifierCreateInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPipelineShaderStageModuleIdentifierCreateInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub identifierSize: uint32_t,
    pub pIdentifier: *const uint8_t,
}
impl_default_zeroed_with_s_type!(VkPipelineShaderStageModuleIdentifierCreateInfoEXT : VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT);
impl_extends!(VkPipelineShaderStageModuleIdentifierCreateInfoEXT : VkPipelineShaderStageCreateInfo);

/// `VkPipelineShaderStageNodeCreateInfoAMDX`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPipelineShaderStageNodeCreateInfoAMDX {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub pName: *const c_char,
    pub index: uint32_t,
}
impl_default_zeroed_with_s_type!(VkPipelineShaderStageNodeCreateInfoAMDX : VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_NODE_CREATE_INFO_AMDX);
impl_extends!(VkPipelineShaderStageNodeCreateInfoAMDX : VkPipelineShaderStageCreateInfo);

/// `VkPipelineShaderStageRequiredSubgroupSizeCreateInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPipelineShaderStageRequiredSubgroupSizeCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub requiredSubgroupSize: uint32_t,
}
impl_default_zeroed_with_s_type!(VkPipelineShaderStageRequiredSubgroupSizeCreateInfo : VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO);
impl_extends!(VkPipelineShaderStageRequiredSubgroupSizeCreateInfo : VkPipelineShaderStageCreateInfo, VkShaderCreateInfoEXT);

/// `VkPipelineShaderStageRequiredSubgroupSizeCreateInfo`
pub type VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT = VkPipelineShaderStageRequiredSubgroupSizeCreateInfo;

flags!(VkPipelineStageFlags);
from_into_transparent!(VkPipelineStageFlags: i32);
/// `VkPipelineStageFlags`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkPipelineStageFlags(pub i32);

/// `1 << 0`  
/// 
/// Before subsequent commands are processed
pub const VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT: VkPipelineStageFlags = VkPipelineStageFlags(1 << 0);
/// `1 << 1`  
/// 
/// Draw/DispatchIndirect command fetch
pub const VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT: VkPipelineStageFlags = VkPipelineStageFlags(1 << 1);
/// `1 << 2`  
/// 
/// Vertex/index fetch
pub const VK_PIPELINE_STAGE_VERTEX_INPUT_BIT: VkPipelineStageFlags = VkPipelineStageFlags(1 << 2);
/// `1 << 3`  
/// 
/// Vertex shading
pub const VK_PIPELINE_STAGE_VERTEX_SHADER_BIT: VkPipelineStageFlags = VkPipelineStageFlags(1 << 3);
/// `1 << 4`  
/// 
/// Tessellation control shading
pub const VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT: VkPipelineStageFlags = VkPipelineStageFlags(1 << 4);
/// `1 << 5`  
/// 
/// Tessellation evaluation shading
pub const VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT: VkPipelineStageFlags = VkPipelineStageFlags(1 << 5);
/// `1 << 6`  
/// 
/// Geometry shading
pub const VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT: VkPipelineStageFlags = VkPipelineStageFlags(1 << 6);
/// `1 << 7`  
/// 
/// Fragment shading
pub const VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT: VkPipelineStageFlags = VkPipelineStageFlags(1 << 7);
/// `1 << 8`  
/// 
/// Early fragment (depth and stencil) tests
pub const VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT: VkPipelineStageFlags = VkPipelineStageFlags(1 << 8);
/// `1 << 9`  
/// 
/// Late fragment (depth and stencil) tests
pub const VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT: VkPipelineStageFlags = VkPipelineStageFlags(1 << 9);
/// `1 << 10`  
/// 
/// Color attachment writes
pub const VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT: VkPipelineStageFlags = VkPipelineStageFlags(1 << 10);
/// `1 << 11`  
/// 
/// Compute shading
pub const VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT: VkPipelineStageFlags = VkPipelineStageFlags(1 << 11);
/// `1 << 12`  
/// 
/// Transfer/copy operations
pub const VK_PIPELINE_STAGE_TRANSFER_BIT: VkPipelineStageFlags = VkPipelineStageFlags(1 << 12);
/// `1 << 13`  
/// 
/// After previous commands have completed
pub const VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT: VkPipelineStageFlags = VkPipelineStageFlags(1 << 13);
/// `1 << 14`  
/// 
/// Indicates host (CPU) is a source/sink of the dependency
pub const VK_PIPELINE_STAGE_HOST_BIT: VkPipelineStageFlags = VkPipelineStageFlags(1 << 14);
/// `1 << 15`  
/// 
/// All stages of the graphics pipeline
pub const VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT: VkPipelineStageFlags = VkPipelineStageFlags(1 << 15);
/// `1 << 16`  
/// 
/// All stages supported on the queue
pub const VK_PIPELINE_STAGE_ALL_COMMANDS_BIT: VkPipelineStageFlags = VkPipelineStageFlags(1 << 16);
/// `0`  
pub const VK_PIPELINE_STAGE_NONE: VkPipelineStageFlags = VkPipelineStageFlags(0);
/// `1 << 24`  
pub const VK_PIPELINE_STAGE_TRANSFORM_FEEDBACK_BIT_EXT: VkPipelineStageFlags = VkPipelineStageFlags(1 << 24);
/// `1 << 18`  
/// 
/// A pipeline stage for conditional rendering predicate fetch
pub const VK_PIPELINE_STAGE_CONDITIONAL_RENDERING_BIT_EXT: VkPipelineStageFlags = VkPipelineStageFlags(1 << 18);
/// `1 << 25`  
pub const VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR: VkPipelineStageFlags = VkPipelineStageFlags(1 << 25);
/// `1 << 21`  
pub const VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR: VkPipelineStageFlags = VkPipelineStageFlags(1 << 21);
/// `VK_PIPELINE_STAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR`  
pub const VK_PIPELINE_STAGE_SHADING_RATE_IMAGE_BIT_NV: VkPipelineStageFlags = VK_PIPELINE_STAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR;
/// `VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR`  
pub const VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_NV: VkPipelineStageFlags = VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR;
/// `VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR`  
pub const VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_NV: VkPipelineStageFlags = VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR;
/// `VK_PIPELINE_STAGE_TASK_SHADER_BIT_EXT`  
pub const VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV: VkPipelineStageFlags = VK_PIPELINE_STAGE_TASK_SHADER_BIT_EXT;
/// `VK_PIPELINE_STAGE_MESH_SHADER_BIT_EXT`  
pub const VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV: VkPipelineStageFlags = VK_PIPELINE_STAGE_MESH_SHADER_BIT_EXT;
/// `1 << 23`  
pub const VK_PIPELINE_STAGE_FRAGMENT_DENSITY_PROCESS_BIT_EXT: VkPipelineStageFlags = VkPipelineStageFlags(1 << 23);
/// `1 << 22`  
pub const VK_PIPELINE_STAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR: VkPipelineStageFlags = VkPipelineStageFlags(1 << 22);
/// `VK_PIPELINE_STAGE_COMMAND_PREPROCESS_BIT_EXT`  
pub const VK_PIPELINE_STAGE_COMMAND_PREPROCESS_BIT_NV: VkPipelineStageFlags = VK_PIPELINE_STAGE_COMMAND_PREPROCESS_BIT_EXT;
/// `VK_PIPELINE_STAGE_NONE`  
pub const VK_PIPELINE_STAGE_NONE_KHR: VkPipelineStageFlags = VK_PIPELINE_STAGE_NONE;
/// `1 << 19`  
pub const VK_PIPELINE_STAGE_TASK_SHADER_BIT_EXT: VkPipelineStageFlags = VkPipelineStageFlags(1 << 19);
/// `1 << 20`  
pub const VK_PIPELINE_STAGE_MESH_SHADER_BIT_EXT: VkPipelineStageFlags = VkPipelineStageFlags(1 << 20);
/// `1 << 17`  
pub const VK_PIPELINE_STAGE_COMMAND_PREPROCESS_BIT_EXT: VkPipelineStageFlags = VkPipelineStageFlags(1 << 17);

impl_flags_display!(VkPipelineStageFlags { VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT, VK_PIPELINE_STAGE_VERTEX_INPUT_BIT, VK_PIPELINE_STAGE_VERTEX_SHADER_BIT, VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT, VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT, VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT, VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, VK_PIPELINE_STAGE_HOST_BIT, VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_NONE, VK_PIPELINE_STAGE_TRANSFORM_FEEDBACK_BIT_EXT, VK_PIPELINE_STAGE_CONDITIONAL_RENDERING_BIT_EXT, VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR, VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR, VK_PIPELINE_STAGE_SHADING_RATE_IMAGE_BIT_NV, VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_NV, VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_NV, VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV, VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV, VK_PIPELINE_STAGE_FRAGMENT_DENSITY_PROCESS_BIT_EXT, VK_PIPELINE_STAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR, VK_PIPELINE_STAGE_COMMAND_PREPROCESS_BIT_NV, VK_PIPELINE_STAGE_NONE_KHR, VK_PIPELINE_STAGE_TASK_SHADER_BIT_EXT, VK_PIPELINE_STAGE_MESH_SHADER_BIT_EXT, VK_PIPELINE_STAGE_COMMAND_PREPROCESS_BIT_EXT });

flags!(VkPipelineStageFlags2);
from_into_transparent!(VkPipelineStageFlags2: i64);
/// `VkPipelineStageFlags2`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkPipelineStageFlags2(pub i64);

/// `0`  
pub const VK_PIPELINE_STAGE_2_NONE: VkPipelineStageFlags2 = VkPipelineStageFlags2(0);
/// `1 << 0`  
pub const VK_PIPELINE_STAGE_2_TOP_OF_PIPE_BIT: VkPipelineStageFlags2 = VkPipelineStageFlags2(1 << 0);
/// `1 << 1`  
pub const VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT: VkPipelineStageFlags2 = VkPipelineStageFlags2(1 << 1);
/// `1 << 2`  
pub const VK_PIPELINE_STAGE_2_VERTEX_INPUT_BIT: VkPipelineStageFlags2 = VkPipelineStageFlags2(1 << 2);
/// `1 << 3`  
pub const VK_PIPELINE_STAGE_2_VERTEX_SHADER_BIT: VkPipelineStageFlags2 = VkPipelineStageFlags2(1 << 3);
/// `1 << 4`  
pub const VK_PIPELINE_STAGE_2_TESSELLATION_CONTROL_SHADER_BIT: VkPipelineStageFlags2 = VkPipelineStageFlags2(1 << 4);
/// `1 << 5`  
pub const VK_PIPELINE_STAGE_2_TESSELLATION_EVALUATION_SHADER_BIT: VkPipelineStageFlags2 = VkPipelineStageFlags2(1 << 5);
/// `1 << 6`  
pub const VK_PIPELINE_STAGE_2_GEOMETRY_SHADER_BIT: VkPipelineStageFlags2 = VkPipelineStageFlags2(1 << 6);
/// `1 << 7`  
pub const VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT: VkPipelineStageFlags2 = VkPipelineStageFlags2(1 << 7);
/// `1 << 8`  
pub const VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS_BIT: VkPipelineStageFlags2 = VkPipelineStageFlags2(1 << 8);
/// `1 << 9`  
pub const VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT: VkPipelineStageFlags2 = VkPipelineStageFlags2(1 << 9);
/// `1 << 10`  
pub const VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT: VkPipelineStageFlags2 = VkPipelineStageFlags2(1 << 10);
/// `1 << 11`  
pub const VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT: VkPipelineStageFlags2 = VkPipelineStageFlags2(1 << 11);
/// `1 << 12`  
pub const VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT: VkPipelineStageFlags2 = VkPipelineStageFlags2(1 << 12);
/// `VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT`  
pub const VK_PIPELINE_STAGE_2_TRANSFER_BIT: VkPipelineStageFlags2 = VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT;
/// `1 << 13`  
pub const VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT: VkPipelineStageFlags2 = VkPipelineStageFlags2(1 << 13);
/// `1 << 14`  
pub const VK_PIPELINE_STAGE_2_HOST_BIT: VkPipelineStageFlags2 = VkPipelineStageFlags2(1 << 14);
/// `1 << 15`  
pub const VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT: VkPipelineStageFlags2 = VkPipelineStageFlags2(1 << 15);
/// `1 << 16`  
pub const VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT: VkPipelineStageFlags2 = VkPipelineStageFlags2(1 << 16);
/// `1 << 32`  
pub const VK_PIPELINE_STAGE_2_COPY_BIT: VkPipelineStageFlags2 = VkPipelineStageFlags2(1 << 32);
/// `1 << 33`  
pub const VK_PIPELINE_STAGE_2_RESOLVE_BIT: VkPipelineStageFlags2 = VkPipelineStageFlags2(1 << 33);
/// `1 << 34`  
pub const VK_PIPELINE_STAGE_2_BLIT_BIT: VkPipelineStageFlags2 = VkPipelineStageFlags2(1 << 34);
/// `1 << 35`  
pub const VK_PIPELINE_STAGE_2_CLEAR_BIT: VkPipelineStageFlags2 = VkPipelineStageFlags2(1 << 35);
/// `1 << 36`  
pub const VK_PIPELINE_STAGE_2_INDEX_INPUT_BIT: VkPipelineStageFlags2 = VkPipelineStageFlags2(1 << 36);
/// `1 << 37`  
pub const VK_PIPELINE_STAGE_2_VERTEX_ATTRIBUTE_INPUT_BIT: VkPipelineStageFlags2 = VkPipelineStageFlags2(1 << 37);
/// `1 << 38`  
pub const VK_PIPELINE_STAGE_2_PRE_RASTERIZATION_SHADERS_BIT: VkPipelineStageFlags2 = VkPipelineStageFlags2(1 << 38);
/// `1 << 26`  
pub const VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR: VkPipelineStageFlags2 = VkPipelineStageFlags2(1 << 26);
/// `1 << 27`  
pub const VK_PIPELINE_STAGE_2_VIDEO_ENCODE_BIT_KHR: VkPipelineStageFlags2 = VkPipelineStageFlags2(1 << 27);
/// `VK_PIPELINE_STAGE_2_NONE`  
pub const VK_PIPELINE_STAGE_2_NONE_KHR: VkPipelineStageFlags2 = VK_PIPELINE_STAGE_2_NONE;
/// `VK_PIPELINE_STAGE_2_TOP_OF_PIPE_BIT`  
pub const VK_PIPELINE_STAGE_2_TOP_OF_PIPE_BIT_KHR: VkPipelineStageFlags2 = VK_PIPELINE_STAGE_2_TOP_OF_PIPE_BIT;
/// `VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT`  
pub const VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT_KHR: VkPipelineStageFlags2 = VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT;
/// `VK_PIPELINE_STAGE_2_VERTEX_INPUT_BIT`  
pub const VK_PIPELINE_STAGE_2_VERTEX_INPUT_BIT_KHR: VkPipelineStageFlags2 = VK_PIPELINE_STAGE_2_VERTEX_INPUT_BIT;
/// `VK_PIPELINE_STAGE_2_VERTEX_SHADER_BIT`  
pub const VK_PIPELINE_STAGE_2_VERTEX_SHADER_BIT_KHR: VkPipelineStageFlags2 = VK_PIPELINE_STAGE_2_VERTEX_SHADER_BIT;
/// `VK_PIPELINE_STAGE_2_TESSELLATION_CONTROL_SHADER_BIT`  
pub const VK_PIPELINE_STAGE_2_TESSELLATION_CONTROL_SHADER_BIT_KHR: VkPipelineStageFlags2 = VK_PIPELINE_STAGE_2_TESSELLATION_CONTROL_SHADER_BIT;
/// `VK_PIPELINE_STAGE_2_TESSELLATION_EVALUATION_SHADER_BIT`  
pub const VK_PIPELINE_STAGE_2_TESSELLATION_EVALUATION_SHADER_BIT_KHR: VkPipelineStageFlags2 = VK_PIPELINE_STAGE_2_TESSELLATION_EVALUATION_SHADER_BIT;
/// `VK_PIPELINE_STAGE_2_GEOMETRY_SHADER_BIT`  
pub const VK_PIPELINE_STAGE_2_GEOMETRY_SHADER_BIT_KHR: VkPipelineStageFlags2 = VK_PIPELINE_STAGE_2_GEOMETRY_SHADER_BIT;
/// `VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT`  
pub const VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT_KHR: VkPipelineStageFlags2 = VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT;
/// `VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS_BIT`  
pub const VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS_BIT_KHR: VkPipelineStageFlags2 = VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS_BIT;
/// `VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT`  
pub const VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT_KHR: VkPipelineStageFlags2 = VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT;
/// `VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT`  
pub const VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT_KHR: VkPipelineStageFlags2 = VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT;
/// `VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT`  
pub const VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT_KHR: VkPipelineStageFlags2 = VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT;
/// `VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT`  
pub const VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT_KHR: VkPipelineStageFlags2 = VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT;
/// `VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT`  
pub const VK_PIPELINE_STAGE_2_TRANSFER_BIT_KHR: VkPipelineStageFlags2 = VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT;
/// `VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT`  
pub const VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT_KHR: VkPipelineStageFlags2 = VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT;
/// `VK_PIPELINE_STAGE_2_HOST_BIT`  
pub const VK_PIPELINE_STAGE_2_HOST_BIT_KHR: VkPipelineStageFlags2 = VK_PIPELINE_STAGE_2_HOST_BIT;
/// `VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT`  
pub const VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR: VkPipelineStageFlags2 = VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT;
/// `VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT`  
pub const VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR: VkPipelineStageFlags2 = VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT;
/// `VK_PIPELINE_STAGE_2_COPY_BIT`  
pub const VK_PIPELINE_STAGE_2_COPY_BIT_KHR: VkPipelineStageFlags2 = VK_PIPELINE_STAGE_2_COPY_BIT;
/// `VK_PIPELINE_STAGE_2_RESOLVE_BIT`  
pub const VK_PIPELINE_STAGE_2_RESOLVE_BIT_KHR: VkPipelineStageFlags2 = VK_PIPELINE_STAGE_2_RESOLVE_BIT;
/// `VK_PIPELINE_STAGE_2_BLIT_BIT`  
pub const VK_PIPELINE_STAGE_2_BLIT_BIT_KHR: VkPipelineStageFlags2 = VK_PIPELINE_STAGE_2_BLIT_BIT;
/// `VK_PIPELINE_STAGE_2_CLEAR_BIT`  
pub const VK_PIPELINE_STAGE_2_CLEAR_BIT_KHR: VkPipelineStageFlags2 = VK_PIPELINE_STAGE_2_CLEAR_BIT;
/// `VK_PIPELINE_STAGE_2_INDEX_INPUT_BIT`  
pub const VK_PIPELINE_STAGE_2_INDEX_INPUT_BIT_KHR: VkPipelineStageFlags2 = VK_PIPELINE_STAGE_2_INDEX_INPUT_BIT;
/// `VK_PIPELINE_STAGE_2_VERTEX_ATTRIBUTE_INPUT_BIT`  
pub const VK_PIPELINE_STAGE_2_VERTEX_ATTRIBUTE_INPUT_BIT_KHR: VkPipelineStageFlags2 = VK_PIPELINE_STAGE_2_VERTEX_ATTRIBUTE_INPUT_BIT;
/// `VK_PIPELINE_STAGE_2_PRE_RASTERIZATION_SHADERS_BIT`  
pub const VK_PIPELINE_STAGE_2_PRE_RASTERIZATION_SHADERS_BIT_KHR: VkPipelineStageFlags2 = VK_PIPELINE_STAGE_2_PRE_RASTERIZATION_SHADERS_BIT;
/// `1 << 24`  
pub const VK_PIPELINE_STAGE_2_TRANSFORM_FEEDBACK_BIT_EXT: VkPipelineStageFlags2 = VkPipelineStageFlags2(1 << 24);
/// `1 << 18`  
/// 
/// A pipeline stage for conditional rendering predicate fetch
pub const VK_PIPELINE_STAGE_2_CONDITIONAL_RENDERING_BIT_EXT: VkPipelineStageFlags2 = VkPipelineStageFlags2(1 << 18);
/// `VK_PIPELINE_STAGE_2_COMMAND_PREPROCESS_BIT_EXT`  
pub const VK_PIPELINE_STAGE_2_COMMAND_PREPROCESS_BIT_NV: VkPipelineStageFlags2 = VK_PIPELINE_STAGE_2_COMMAND_PREPROCESS_BIT_EXT;
/// `1 << 17`  
pub const VK_PIPELINE_STAGE_2_COMMAND_PREPROCESS_BIT_EXT: VkPipelineStageFlags2 = VkPipelineStageFlags2(1 << 17);
/// `1 << 22`  
pub const VK_PIPELINE_STAGE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR: VkPipelineStageFlags2 = VkPipelineStageFlags2(1 << 22);
/// `VK_PIPELINE_STAGE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR`  
pub const VK_PIPELINE_STAGE_2_SHADING_RATE_IMAGE_BIT_NV: VkPipelineStageFlags2 = VK_PIPELINE_STAGE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR;
/// `1 << 25`  
pub const VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_KHR: VkPipelineStageFlags2 = VkPipelineStageFlags2(1 << 25);
/// `1 << 21`  
pub const VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_KHR: VkPipelineStageFlags2 = VkPipelineStageFlags2(1 << 21);
/// `VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_KHR`  
pub const VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_NV: VkPipelineStageFlags2 = VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_KHR;
/// `VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_KHR`  
pub const VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_NV: VkPipelineStageFlags2 = VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_KHR;
/// `1 << 23`  
pub const VK_PIPELINE_STAGE_2_FRAGMENT_DENSITY_PROCESS_BIT_EXT: VkPipelineStageFlags2 = VkPipelineStageFlags2(1 << 23);
/// `VK_PIPELINE_STAGE_2_TASK_SHADER_BIT_EXT`  
pub const VK_PIPELINE_STAGE_2_TASK_SHADER_BIT_NV: VkPipelineStageFlags2 = VK_PIPELINE_STAGE_2_TASK_SHADER_BIT_EXT;
/// `VK_PIPELINE_STAGE_2_MESH_SHADER_BIT_EXT`  
pub const VK_PIPELINE_STAGE_2_MESH_SHADER_BIT_NV: VkPipelineStageFlags2 = VK_PIPELINE_STAGE_2_MESH_SHADER_BIT_EXT;
/// `1 << 19`  
pub const VK_PIPELINE_STAGE_2_TASK_SHADER_BIT_EXT: VkPipelineStageFlags2 = VkPipelineStageFlags2(1 << 19);
/// `1 << 20`  
pub const VK_PIPELINE_STAGE_2_MESH_SHADER_BIT_EXT: VkPipelineStageFlags2 = VkPipelineStageFlags2(1 << 20);
/// `1 << 39`  
pub const VK_PIPELINE_STAGE_2_SUBPASS_SHADER_BIT_HUAWEI: VkPipelineStageFlags2 = VkPipelineStageFlags2(1 << 39);
/// `VK_PIPELINE_STAGE_2_SUBPASS_SHADER_BIT_HUAWEI`  
pub const VK_PIPELINE_STAGE_2_SUBPASS_SHADING_BIT_HUAWEI: VkPipelineStageFlags2 = VK_PIPELINE_STAGE_2_SUBPASS_SHADER_BIT_HUAWEI;
/// `1 << 40`  
pub const VK_PIPELINE_STAGE_2_INVOCATION_MASK_BIT_HUAWEI: VkPipelineStageFlags2 = VkPipelineStageFlags2(1 << 40);
/// `1 << 28`  
pub const VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_COPY_BIT_KHR: VkPipelineStageFlags2 = VkPipelineStageFlags2(1 << 28);
/// `1 << 30`  
pub const VK_PIPELINE_STAGE_2_MICROMAP_BUILD_BIT_EXT: VkPipelineStageFlags2 = VkPipelineStageFlags2(1 << 30);
/// `1 << 41`  
pub const VK_PIPELINE_STAGE_2_CLUSTER_CULLING_SHADER_BIT_HUAWEI: VkPipelineStageFlags2 = VkPipelineStageFlags2(1 << 41);
/// `1 << 29`  
pub const VK_PIPELINE_STAGE_2_OPTICAL_FLOW_BIT_NV: VkPipelineStageFlags2 = VkPipelineStageFlags2(1 << 29);
/// `1 << 44`  
pub const VK_PIPELINE_STAGE_2_CONVERT_COOPERATIVE_VECTOR_MATRIX_BIT_NV: VkPipelineStageFlags2 = VkPipelineStageFlags2(1 << 44);
/// `1 << 42`  
pub const VK_PIPELINE_STAGE_2_DATA_GRAPH_BIT_ARM: VkPipelineStageFlags2 = VkPipelineStageFlags2(1 << 42);
/// `1 << 46`  
pub const VK_PIPELINE_STAGE_2_COPY_INDIRECT_BIT_KHR: VkPipelineStageFlags2 = VkPipelineStageFlags2(1 << 46);
/// `1 << 45`  
pub const VK_PIPELINE_STAGE_2_MEMORY_DECOMPRESSION_BIT_EXT: VkPipelineStageFlags2 = VkPipelineStageFlags2(1 << 45);
/// `1 << 49`  
pub const VK_PIPELINE_STAGE_2_RESERVED_49_BIT_EXT: VkPipelineStageFlags2 = VkPipelineStageFlags2(1 << 49);
/// `1 << 47`  
pub const VK_PIPELINE_STAGE_2_RESERVED_47_BIT_KHR: VkPipelineStageFlags2 = VkPipelineStageFlags2(1 << 47);
/// `1 << 43`  
pub const VK_PIPELINE_STAGE_2_RESERVED_43_BIT_ARM: VkPipelineStageFlags2 = VkPipelineStageFlags2(1 << 43);
/// `1 << 48`  
pub const VK_PIPELINE_STAGE_2_RESERVED_48_BIT_HUAWEI: VkPipelineStageFlags2 = VkPipelineStageFlags2(1 << 48);

impl_flags_display!(VkPipelineStageFlags2 { VK_PIPELINE_STAGE_2_NONE, VK_PIPELINE_STAGE_2_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT, VK_PIPELINE_STAGE_2_VERTEX_INPUT_BIT, VK_PIPELINE_STAGE_2_VERTEX_SHADER_BIT, VK_PIPELINE_STAGE_2_TESSELLATION_CONTROL_SHADER_BIT, VK_PIPELINE_STAGE_2_TESSELLATION_EVALUATION_SHADER_BIT, VK_PIPELINE_STAGE_2_GEOMETRY_SHADER_BIT, VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT, VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS_BIT, VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT, VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT, VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT, VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT, VK_PIPELINE_STAGE_2_TRANSFER_BIT, VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT, VK_PIPELINE_STAGE_2_HOST_BIT, VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT, VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_2_COPY_BIT, VK_PIPELINE_STAGE_2_RESOLVE_BIT, VK_PIPELINE_STAGE_2_BLIT_BIT, VK_PIPELINE_STAGE_2_CLEAR_BIT, VK_PIPELINE_STAGE_2_INDEX_INPUT_BIT, VK_PIPELINE_STAGE_2_VERTEX_ATTRIBUTE_INPUT_BIT, VK_PIPELINE_STAGE_2_PRE_RASTERIZATION_SHADERS_BIT, VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR, VK_PIPELINE_STAGE_2_VIDEO_ENCODE_BIT_KHR, VK_PIPELINE_STAGE_2_NONE_KHR, VK_PIPELINE_STAGE_2_TOP_OF_PIPE_BIT_KHR, VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT_KHR, VK_PIPELINE_STAGE_2_VERTEX_INPUT_BIT_KHR, VK_PIPELINE_STAGE_2_VERTEX_SHADER_BIT_KHR, VK_PIPELINE_STAGE_2_TESSELLATION_CONTROL_SHADER_BIT_KHR, VK_PIPELINE_STAGE_2_TESSELLATION_EVALUATION_SHADER_BIT_KHR, VK_PIPELINE_STAGE_2_GEOMETRY_SHADER_BIT_KHR, VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT_KHR, VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS_BIT_KHR, VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT_KHR, VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT_KHR, VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT_KHR, VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT_KHR, VK_PIPELINE_STAGE_2_TRANSFER_BIT_KHR, VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT_KHR, VK_PIPELINE_STAGE_2_HOST_BIT_KHR, VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR, VK_PIPELINE_STAGE_2_COPY_BIT_KHR, VK_PIPELINE_STAGE_2_RESOLVE_BIT_KHR, VK_PIPELINE_STAGE_2_BLIT_BIT_KHR, VK_PIPELINE_STAGE_2_CLEAR_BIT_KHR, VK_PIPELINE_STAGE_2_INDEX_INPUT_BIT_KHR, VK_PIPELINE_STAGE_2_VERTEX_ATTRIBUTE_INPUT_BIT_KHR, VK_PIPELINE_STAGE_2_PRE_RASTERIZATION_SHADERS_BIT_KHR, VK_PIPELINE_STAGE_2_TRANSFORM_FEEDBACK_BIT_EXT, VK_PIPELINE_STAGE_2_CONDITIONAL_RENDERING_BIT_EXT, VK_PIPELINE_STAGE_2_COMMAND_PREPROCESS_BIT_NV, VK_PIPELINE_STAGE_2_COMMAND_PREPROCESS_BIT_EXT, VK_PIPELINE_STAGE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR, VK_PIPELINE_STAGE_2_SHADING_RATE_IMAGE_BIT_NV, VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_KHR, VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_KHR, VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_NV, VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_NV, VK_PIPELINE_STAGE_2_FRAGMENT_DENSITY_PROCESS_BIT_EXT, VK_PIPELINE_STAGE_2_TASK_SHADER_BIT_NV, VK_PIPELINE_STAGE_2_MESH_SHADER_BIT_NV, VK_PIPELINE_STAGE_2_TASK_SHADER_BIT_EXT, VK_PIPELINE_STAGE_2_MESH_SHADER_BIT_EXT, VK_PIPELINE_STAGE_2_SUBPASS_SHADER_BIT_HUAWEI, VK_PIPELINE_STAGE_2_SUBPASS_SHADING_BIT_HUAWEI, VK_PIPELINE_STAGE_2_INVOCATION_MASK_BIT_HUAWEI, VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_COPY_BIT_KHR, VK_PIPELINE_STAGE_2_MICROMAP_BUILD_BIT_EXT, VK_PIPELINE_STAGE_2_CLUSTER_CULLING_SHADER_BIT_HUAWEI, VK_PIPELINE_STAGE_2_OPTICAL_FLOW_BIT_NV, VK_PIPELINE_STAGE_2_CONVERT_COOPERATIVE_VECTOR_MATRIX_BIT_NV, VK_PIPELINE_STAGE_2_DATA_GRAPH_BIT_ARM, VK_PIPELINE_STAGE_2_COPY_INDIRECT_BIT_KHR, VK_PIPELINE_STAGE_2_MEMORY_DECOMPRESSION_BIT_EXT, VK_PIPELINE_STAGE_2_RESERVED_49_BIT_EXT, VK_PIPELINE_STAGE_2_RESERVED_47_BIT_KHR, VK_PIPELINE_STAGE_2_RESERVED_43_BIT_ARM, VK_PIPELINE_STAGE_2_RESERVED_48_BIT_HUAWEI });

/// `VkPipelineStageFlags2`
pub type VkPipelineStageFlags2KHR = VkPipelineStageFlags2;

/// `VkPipelineTessellationDomainOriginStateCreateInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPipelineTessellationDomainOriginStateCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub domainOrigin: VkTessellationDomainOrigin,
}
impl_default_zeroed_with_s_type!(VkPipelineTessellationDomainOriginStateCreateInfo : VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO);
impl_extends!(VkPipelineTessellationDomainOriginStateCreateInfo : VkPipelineTessellationStateCreateInfo);

/// `VkPipelineTessellationDomainOriginStateCreateInfo`
pub type VkPipelineTessellationDomainOriginStateCreateInfoKHR = VkPipelineTessellationDomainOriginStateCreateInfo;

flags!(VkPipelineTessellationStateCreateFlags);
from_into_transparent!(VkPipelineTessellationStateCreateFlags: i32);
/// `VkPipelineTessellationStateCreateFlags`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkPipelineTessellationStateCreateFlags(pub i32);

impl_flags_display!(VkPipelineTessellationStateCreateFlags {  });

/// `VkPipelineTessellationStateCreateInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPipelineTessellationStateCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub flags: VkPipelineTessellationStateCreateFlags,
    pub patchControlPoints: uint32_t,
}
impl_default_zeroed_with_s_type!(VkPipelineTessellationStateCreateInfo : VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO);

/// `VkPipelineVertexInputDivisorStateCreateInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPipelineVertexInputDivisorStateCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub vertexBindingDivisorCount: uint32_t,
    pub pVertexBindingDivisors: *const VkVertexInputBindingDivisorDescription,
}
impl_default_zeroed_with_s_type!(VkPipelineVertexInputDivisorStateCreateInfo : VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO);
impl_extends!(VkPipelineVertexInputDivisorStateCreateInfo : VkPipelineVertexInputStateCreateInfo);

/// `VkPipelineVertexInputDivisorStateCreateInfo`
pub type VkPipelineVertexInputDivisorStateCreateInfoEXT = VkPipelineVertexInputDivisorStateCreateInfo;

/// `VkPipelineVertexInputDivisorStateCreateInfo`
pub type VkPipelineVertexInputDivisorStateCreateInfoKHR = VkPipelineVertexInputDivisorStateCreateInfo;

flags!(VkPipelineVertexInputStateCreateFlags);
from_into_transparent!(VkPipelineVertexInputStateCreateFlags: i32);
/// `VkPipelineVertexInputStateCreateFlags`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkPipelineVertexInputStateCreateFlags(pub i32);

impl_flags_display!(VkPipelineVertexInputStateCreateFlags {  });

/// `VkPipelineVertexInputStateCreateInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPipelineVertexInputStateCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub flags: VkPipelineVertexInputStateCreateFlags,
    /// number of bindings
    pub vertexBindingDescriptionCount: uint32_t,
    pub pVertexBindingDescriptions: *const VkVertexInputBindingDescription,
    /// number of attributes
    pub vertexAttributeDescriptionCount: uint32_t,
    pub pVertexAttributeDescriptions: *const VkVertexInputAttributeDescription,
}
impl_default_zeroed_with_s_type!(VkPipelineVertexInputStateCreateInfo : VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO);

/// `VkPipelineViewportCoarseSampleOrderStateCreateInfoNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPipelineViewportCoarseSampleOrderStateCreateInfoNV {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub sampleOrderType: VkCoarseSampleOrderTypeNV,
    pub customSampleOrderCount: uint32_t,
    pub pCustomSampleOrders: *const VkCoarseSampleOrderCustomNV,
}
impl_default_zeroed_with_s_type!(VkPipelineViewportCoarseSampleOrderStateCreateInfoNV : VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV);
impl_extends!(VkPipelineViewportCoarseSampleOrderStateCreateInfoNV : VkPipelineViewportStateCreateInfo);

/// `VkPipelineViewportDepthClampControlCreateInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPipelineViewportDepthClampControlCreateInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub depthClampMode: VkDepthClampModeEXT,
    pub pDepthClampRange: *const VkDepthClampRangeEXT,
}
impl_default_zeroed_with_s_type!(VkPipelineViewportDepthClampControlCreateInfoEXT : VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT);
impl_extends!(VkPipelineViewportDepthClampControlCreateInfoEXT : VkPipelineViewportStateCreateInfo);

/// `VkPipelineViewportDepthClipControlCreateInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPipelineViewportDepthClipControlCreateInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub negativeOneToOne: VkBool32,
}
impl_default_zeroed_with_s_type!(VkPipelineViewportDepthClipControlCreateInfoEXT : VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT);
impl_extends!(VkPipelineViewportDepthClipControlCreateInfoEXT : VkPipelineViewportStateCreateInfo);

/// `VkPipelineViewportExclusiveScissorStateCreateInfoNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPipelineViewportExclusiveScissorStateCreateInfoNV {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub exclusiveScissorCount: uint32_t,
    pub pExclusiveScissors: *const VkRect2D,
}
impl_default_zeroed_with_s_type!(VkPipelineViewportExclusiveScissorStateCreateInfoNV : VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV);
impl_extends!(VkPipelineViewportExclusiveScissorStateCreateInfoNV : VkPipelineViewportStateCreateInfo);

/// `VkPipelineViewportShadingRateImageStateCreateInfoNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPipelineViewportShadingRateImageStateCreateInfoNV {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub shadingRateImageEnable: VkBool32,
    pub viewportCount: uint32_t,
    pub pShadingRatePalettes: *const VkShadingRatePaletteNV,
}
impl_default_zeroed_with_s_type!(VkPipelineViewportShadingRateImageStateCreateInfoNV : VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV);
impl_extends!(VkPipelineViewportShadingRateImageStateCreateInfoNV : VkPipelineViewportStateCreateInfo);

flags!(VkPipelineViewportStateCreateFlags);
from_into_transparent!(VkPipelineViewportStateCreateFlags: i32);
/// `VkPipelineViewportStateCreateFlags`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkPipelineViewportStateCreateFlags(pub i32);

impl_flags_display!(VkPipelineViewportStateCreateFlags {  });

/// `VkPipelineViewportStateCreateInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPipelineViewportStateCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub flags: VkPipelineViewportStateCreateFlags,
    pub viewportCount: uint32_t,
    pub pViewports: *const VkViewport,
    pub scissorCount: uint32_t,
    pub pScissors: *const VkRect2D,
}
impl_default_zeroed_with_s_type!(VkPipelineViewportStateCreateInfo : VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO);

flags!(VkPipelineViewportSwizzleStateCreateFlagsNV);
from_into_transparent!(VkPipelineViewportSwizzleStateCreateFlagsNV: i32);
/// `VkPipelineViewportSwizzleStateCreateFlagsNV`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkPipelineViewportSwizzleStateCreateFlagsNV(pub i32);

impl_flags_display!(VkPipelineViewportSwizzleStateCreateFlagsNV {  });

/// `VkPipelineViewportSwizzleStateCreateInfoNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPipelineViewportSwizzleStateCreateInfoNV {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub flags: VkPipelineViewportSwizzleStateCreateFlagsNV,
    pub viewportCount: uint32_t,
    pub pViewportSwizzles: *const VkViewportSwizzleNV,
}
impl_default_zeroed_with_s_type!(VkPipelineViewportSwizzleStateCreateInfoNV : VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV);
impl_extends!(VkPipelineViewportSwizzleStateCreateInfoNV : VkPipelineViewportStateCreateInfo);

/// `VkPipelineViewportWScalingStateCreateInfoNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPipelineViewportWScalingStateCreateInfoNV {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub viewportWScalingEnable: VkBool32,
    pub viewportCount: uint32_t,
    pub pViewportWScalings: *const VkViewportWScalingNV,
}
impl_default_zeroed_with_s_type!(VkPipelineViewportWScalingStateCreateInfoNV : VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV);
impl_extends!(VkPipelineViewportWScalingStateCreateInfoNV : VkPipelineViewportStateCreateInfo);

from_into_transparent!(VkPointClippingBehavior: i32);
/// `VkPointClippingBehavior`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkPointClippingBehavior(pub i32);

/// `0`  
pub const VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES: VkPointClippingBehavior = VkPointClippingBehavior(0);
/// `1`  
pub const VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY: VkPointClippingBehavior = VkPointClippingBehavior(1);
/// `VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES`  
pub const VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES_KHR: VkPointClippingBehavior = VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES;
/// `VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY`  
pub const VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY_KHR: VkPointClippingBehavior = VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY;

impl_enum_display!(VkPointClippingBehavior { VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES, VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY, VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES_KHR, VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY_KHR });

/// `VkPointClippingBehavior`
pub type VkPointClippingBehaviorKHR = VkPointClippingBehavior;

from_into_transparent!(VkPolygonMode: i32);
/// `VkPolygonMode`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkPolygonMode(pub i32);

/// `0`  
pub const VK_POLYGON_MODE_FILL: VkPolygonMode = VkPolygonMode(0);
/// `1`  
pub const VK_POLYGON_MODE_LINE: VkPolygonMode = VkPolygonMode(1);
/// `2`  
pub const VK_POLYGON_MODE_POINT: VkPolygonMode = VkPolygonMode(2);
/// `1000153000`  
pub const VK_POLYGON_MODE_FILL_RECTANGLE_NV: VkPolygonMode = VkPolygonMode(1000153000);

impl_enum_display!(VkPolygonMode { VK_POLYGON_MODE_FILL, VK_POLYGON_MODE_LINE, VK_POLYGON_MODE_POINT, VK_POLYGON_MODE_FILL_RECTANGLE_NV });

/// `VkPresentFrameTokenGGP`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPresentFrameTokenGGP {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub frameToken: GgpFrameToken,
}
impl_default_zeroed_with_s_type!(VkPresentFrameTokenGGP : VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP);
impl_extends!(VkPresentFrameTokenGGP : VkPresentInfoKHR);

/// `VkPresentGravityFlagsKHR`
pub type VkPresentGravityFlagsEXT = VkPresentGravityFlagsKHR;

flags!(VkPresentGravityFlagsKHR);
from_into_transparent!(VkPresentGravityFlagsKHR: i32);
/// `VkPresentGravityFlagsKHR`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkPresentGravityFlagsKHR(pub i32);

/// `1 << 0`  
pub const VK_PRESENT_GRAVITY_MIN_BIT_KHR: VkPresentGravityFlagsKHR = VkPresentGravityFlagsKHR(1 << 0);
/// `VK_PRESENT_GRAVITY_MIN_BIT_KHR`  
pub const VK_PRESENT_GRAVITY_MIN_BIT_EXT: VkPresentGravityFlagsKHR = VK_PRESENT_GRAVITY_MIN_BIT_KHR;
/// `1 << 1`  
pub const VK_PRESENT_GRAVITY_MAX_BIT_KHR: VkPresentGravityFlagsKHR = VkPresentGravityFlagsKHR(1 << 1);
/// `VK_PRESENT_GRAVITY_MAX_BIT_KHR`  
pub const VK_PRESENT_GRAVITY_MAX_BIT_EXT: VkPresentGravityFlagsKHR = VK_PRESENT_GRAVITY_MAX_BIT_KHR;
/// `1 << 2`  
pub const VK_PRESENT_GRAVITY_CENTERED_BIT_KHR: VkPresentGravityFlagsKHR = VkPresentGravityFlagsKHR(1 << 2);
/// `VK_PRESENT_GRAVITY_CENTERED_BIT_KHR`  
pub const VK_PRESENT_GRAVITY_CENTERED_BIT_EXT: VkPresentGravityFlagsKHR = VK_PRESENT_GRAVITY_CENTERED_BIT_KHR;

impl_flags_display!(VkPresentGravityFlagsKHR { VK_PRESENT_GRAVITY_MIN_BIT_KHR, VK_PRESENT_GRAVITY_MIN_BIT_EXT, VK_PRESENT_GRAVITY_MAX_BIT_KHR, VK_PRESENT_GRAVITY_MAX_BIT_EXT, VK_PRESENT_GRAVITY_CENTERED_BIT_KHR, VK_PRESENT_GRAVITY_CENTERED_BIT_EXT });

/// `VkPresentId2KHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPresentId2KHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    /// Copy of VkPresentInfoKHR::swapchainCount
    pub swapchainCount: uint32_t,
    /// Present ID values for each swapchain
    pub pPresentIds: *const uint64_t,
}
impl_default_zeroed_with_s_type!(VkPresentId2KHR : VK_STRUCTURE_TYPE_PRESENT_ID_2_KHR);
impl_extends!(VkPresentId2KHR : VkPresentInfoKHR);

/// `VkPresentIdKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPresentIdKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    /// Copy of VkPresentInfoKHR::swapchainCount
    pub swapchainCount: uint32_t,
    /// Present ID values for each swapchain
    pub pPresentIds: *const uint64_t,
}
impl_default_zeroed_with_s_type!(VkPresentIdKHR : VK_STRUCTURE_TYPE_PRESENT_ID_KHR);
impl_extends!(VkPresentIdKHR : VkPresentInfoKHR);

/// `VkPresentInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPresentInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    /// Number of semaphores to wait for before presenting
    pub waitSemaphoreCount: uint32_t,
    /// Semaphores to wait for before presenting
    pub pWaitSemaphores: *const VkSemaphore,
    /// Number of swapchains to present in this call
    pub swapchainCount: uint32_t,
    /// Swapchains to present an image from
    pub pSwapchains: *const VkSwapchainKHR,
    /// Indices of which presentable images to present
    pub pImageIndices: *const uint32_t,
    /// Optional (i.e. if non-NULL) VkResult for each swapchain
    pub pResults: *mut VkResult,
}
impl_default_zeroed_with_s_type!(VkPresentInfoKHR : VK_STRUCTURE_TYPE_PRESENT_INFO_KHR);

from_into_transparent!(VkPresentModeKHR: i32);
/// `VkPresentModeKHR`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkPresentModeKHR(pub i32);

/// `0`  
pub const VK_PRESENT_MODE_IMMEDIATE_KHR: VkPresentModeKHR = VkPresentModeKHR(0);
/// `1`  
pub const VK_PRESENT_MODE_MAILBOX_KHR: VkPresentModeKHR = VkPresentModeKHR(1);
/// `2`  
pub const VK_PRESENT_MODE_FIFO_KHR: VkPresentModeKHR = VkPresentModeKHR(2);
/// `3`  
pub const VK_PRESENT_MODE_FIFO_RELAXED_KHR: VkPresentModeKHR = VkPresentModeKHR(3);
/// `1000111000`  
pub const VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR: VkPresentModeKHR = VkPresentModeKHR(1000111000);
/// `1000111001`  
pub const VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR: VkPresentModeKHR = VkPresentModeKHR(1000111001);
/// `VK_PRESENT_MODE_FIFO_LATEST_READY_KHR`  
pub const VK_PRESENT_MODE_FIFO_LATEST_READY_EXT: VkPresentModeKHR = VK_PRESENT_MODE_FIFO_LATEST_READY_KHR;
/// `1000361000`  
pub const VK_PRESENT_MODE_FIFO_LATEST_READY_KHR: VkPresentModeKHR = VkPresentModeKHR(1000361000);

impl_enum_display!(VkPresentModeKHR { VK_PRESENT_MODE_IMMEDIATE_KHR, VK_PRESENT_MODE_MAILBOX_KHR, VK_PRESENT_MODE_FIFO_KHR, VK_PRESENT_MODE_FIFO_RELAXED_KHR, VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR, VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR, VK_PRESENT_MODE_FIFO_LATEST_READY_EXT, VK_PRESENT_MODE_FIFO_LATEST_READY_KHR });

/// `VkPresentRegionKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPresentRegionKHR {
    /// Number of rectangles in pRectangles
    pub rectangleCount: uint32_t,
    /// Array of rectangles that have changed in a swapchain's image(s)
    pub pRectangles: *const VkRectLayerKHR,
}
impl_default_zeroed!(VkPresentRegionKHR);

/// `VkPresentRegionsKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPresentRegionsKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    /// Copy of VkPresentInfoKHR::swapchainCount
    pub swapchainCount: uint32_t,
    /// The regions that have changed
    pub pRegions: *const VkPresentRegionKHR,
}
impl_default_zeroed_with_s_type!(VkPresentRegionsKHR : VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR);
impl_extends!(VkPresentRegionsKHR : VkPresentInfoKHR);

/// `VkPresentScalingFlagsKHR`
pub type VkPresentScalingFlagsEXT = VkPresentScalingFlagsKHR;

flags!(VkPresentScalingFlagsKHR);
from_into_transparent!(VkPresentScalingFlagsKHR: i32);
/// `VkPresentScalingFlagsKHR`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkPresentScalingFlagsKHR(pub i32);

/// `1 << 0`  
pub const VK_PRESENT_SCALING_ONE_TO_ONE_BIT_KHR: VkPresentScalingFlagsKHR = VkPresentScalingFlagsKHR(1 << 0);
/// `VK_PRESENT_SCALING_ONE_TO_ONE_BIT_KHR`  
pub const VK_PRESENT_SCALING_ONE_TO_ONE_BIT_EXT: VkPresentScalingFlagsKHR = VK_PRESENT_SCALING_ONE_TO_ONE_BIT_KHR;
/// `1 << 1`  
pub const VK_PRESENT_SCALING_ASPECT_RATIO_STRETCH_BIT_KHR: VkPresentScalingFlagsKHR = VkPresentScalingFlagsKHR(1 << 1);
/// `VK_PRESENT_SCALING_ASPECT_RATIO_STRETCH_BIT_KHR`  
pub const VK_PRESENT_SCALING_ASPECT_RATIO_STRETCH_BIT_EXT: VkPresentScalingFlagsKHR = VK_PRESENT_SCALING_ASPECT_RATIO_STRETCH_BIT_KHR;
/// `1 << 2`  
pub const VK_PRESENT_SCALING_STRETCH_BIT_KHR: VkPresentScalingFlagsKHR = VkPresentScalingFlagsKHR(1 << 2);
/// `VK_PRESENT_SCALING_STRETCH_BIT_KHR`  
pub const VK_PRESENT_SCALING_STRETCH_BIT_EXT: VkPresentScalingFlagsKHR = VK_PRESENT_SCALING_STRETCH_BIT_KHR;

impl_flags_display!(VkPresentScalingFlagsKHR { VK_PRESENT_SCALING_ONE_TO_ONE_BIT_KHR, VK_PRESENT_SCALING_ONE_TO_ONE_BIT_EXT, VK_PRESENT_SCALING_ASPECT_RATIO_STRETCH_BIT_KHR, VK_PRESENT_SCALING_ASPECT_RATIO_STRETCH_BIT_EXT, VK_PRESENT_SCALING_STRETCH_BIT_KHR, VK_PRESENT_SCALING_STRETCH_BIT_EXT });

flags!(VkPresentStageFlagsEXT);
from_into_transparent!(VkPresentStageFlagsEXT: i32);
/// `VkPresentStageFlagsEXT`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkPresentStageFlagsEXT(pub i32);

/// `1 << 0`  
pub const VK_PRESENT_STAGE_QUEUE_OPERATIONS_END_BIT_EXT: VkPresentStageFlagsEXT = VkPresentStageFlagsEXT(1 << 0);
/// `1 << 1`  
pub const VK_PRESENT_STAGE_REQUEST_DEQUEUED_BIT_EXT: VkPresentStageFlagsEXT = VkPresentStageFlagsEXT(1 << 1);
/// `1 << 2`  
pub const VK_PRESENT_STAGE_IMAGE_FIRST_PIXEL_OUT_BIT_EXT: VkPresentStageFlagsEXT = VkPresentStageFlagsEXT(1 << 2);
/// `1 << 3`  
pub const VK_PRESENT_STAGE_IMAGE_FIRST_PIXEL_VISIBLE_BIT_EXT: VkPresentStageFlagsEXT = VkPresentStageFlagsEXT(1 << 3);

impl_flags_display!(VkPresentStageFlagsEXT { VK_PRESENT_STAGE_QUEUE_OPERATIONS_END_BIT_EXT, VK_PRESENT_STAGE_REQUEST_DEQUEUED_BIT_EXT, VK_PRESENT_STAGE_IMAGE_FIRST_PIXEL_OUT_BIT_EXT, VK_PRESENT_STAGE_IMAGE_FIRST_PIXEL_VISIBLE_BIT_EXT });

/// `VkPresentStageTimeEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPresentStageTimeEXT {
    pub stage: VkPresentStageFlagsEXT,
    /// Time in nanoseconds of the associated stage
    pub time: uint64_t,
}
impl_default_zeroed!(VkPresentStageTimeEXT);

/// `VkPresentTimeGOOGLE`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPresentTimeGOOGLE {
    /// Application-provided identifier
    pub presentID: uint32_t,
    /// Earliest time an image should be presented
    pub desiredPresentTime: uint64_t,
}
impl_default_zeroed!(VkPresentTimeGOOGLE);

/// `VkPresentTimesInfoGOOGLE`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPresentTimesInfoGOOGLE {
    pub sType: VkStructureType,
    pub pNext: *const void,
    /// Copy of VkPresentInfoKHR::swapchainCount
    pub swapchainCount: uint32_t,
    /// The earliest times to present images
    pub pTimes: *const VkPresentTimeGOOGLE,
}
impl_default_zeroed_with_s_type!(VkPresentTimesInfoGOOGLE : VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE);
impl_extends!(VkPresentTimesInfoGOOGLE : VkPresentInfoKHR);

/// `VkPresentTimingInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPresentTimingInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub flags: VkPresentTimingInfoFlagsEXT,
    pub targetTime: uint64_t,
    /// Time domain to interpret the target present time and collect present stages timings with
    pub timeDomainId: uint64_t,
    /// Present stages to collect timing information for
    pub presentStageQueries: VkPresentStageFlagsEXT,
    /// Target stage-local time domain's stage
    pub targetTimeDomainPresentStage: VkPresentStageFlagsEXT,
}
impl_default_zeroed_with_s_type!(VkPresentTimingInfoEXT : VK_STRUCTURE_TYPE_PRESENT_TIMING_INFO_EXT);

flags!(VkPresentTimingInfoFlagsEXT);
from_into_transparent!(VkPresentTimingInfoFlagsEXT: i32);
/// `VkPresentTimingInfoFlagsEXT`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkPresentTimingInfoFlagsEXT(pub i32);

/// `1 << 0`  
pub const VK_PRESENT_TIMING_INFO_PRESENT_AT_RELATIVE_TIME_BIT_EXT: VkPresentTimingInfoFlagsEXT = VkPresentTimingInfoFlagsEXT(1 << 0);
/// `1 << 1`  
pub const VK_PRESENT_TIMING_INFO_PRESENT_AT_NEAREST_REFRESH_CYCLE_BIT_EXT: VkPresentTimingInfoFlagsEXT = VkPresentTimingInfoFlagsEXT(1 << 1);

impl_flags_display!(VkPresentTimingInfoFlagsEXT { VK_PRESENT_TIMING_INFO_PRESENT_AT_RELATIVE_TIME_BIT_EXT, VK_PRESENT_TIMING_INFO_PRESENT_AT_NEAREST_REFRESH_CYCLE_BIT_EXT });

/// `VkPresentTimingSurfaceCapabilitiesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPresentTimingSurfaceCapabilitiesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    /// presentation timings of the surface can be queried using vkGetPastPresentationTimingEXT
    pub presentTimingSupported: VkBool32,
    /// surface can be presented using absolute times
    pub presentAtAbsoluteTimeSupported: VkBool32,
    /// surface can be presented using relative times
    pub presentAtRelativeTimeSupported: VkBool32,
    /// present stages that can be queried
    pub presentStageQueries: VkPresentStageFlagsEXT,
}
impl_default_zeroed_with_s_type!(VkPresentTimingSurfaceCapabilitiesEXT : VK_STRUCTURE_TYPE_PRESENT_TIMING_SURFACE_CAPABILITIES_EXT);
impl_extends!(VkPresentTimingSurfaceCapabilitiesEXT : VkSurfaceCapabilities2KHR);

/// `VkPresentTimingsInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPresentTimingsInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    /// Copy of VkPresentInfoKHR::swapchainCount
    pub swapchainCount: uint32_t,
    /// Present timing details for each swapchain
    pub pTimingInfos: *const VkPresentTimingInfoEXT,
}
impl_default_zeroed_with_s_type!(VkPresentTimingsInfoEXT : VK_STRUCTURE_TYPE_PRESENT_TIMINGS_INFO_EXT);
impl_extends!(VkPresentTimingsInfoEXT : VkPresentInfoKHR);

/// `VkPresentWait2InfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPresentWait2InfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub presentId: uint64_t,
    pub timeout: uint64_t,
}
impl_default_zeroed_with_s_type!(VkPresentWait2InfoKHR : VK_STRUCTURE_TYPE_PRESENT_WAIT_2_INFO_KHR);

from_into_transparent!(VkPrimitiveTopology: i32);
/// `VkPrimitiveTopology`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkPrimitiveTopology(pub i32);

/// `0`  
pub const VK_PRIMITIVE_TOPOLOGY_POINT_LIST: VkPrimitiveTopology = VkPrimitiveTopology(0);
/// `1`  
pub const VK_PRIMITIVE_TOPOLOGY_LINE_LIST: VkPrimitiveTopology = VkPrimitiveTopology(1);
/// `2`  
pub const VK_PRIMITIVE_TOPOLOGY_LINE_STRIP: VkPrimitiveTopology = VkPrimitiveTopology(2);
/// `3`  
pub const VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST: VkPrimitiveTopology = VkPrimitiveTopology(3);
/// `4`  
pub const VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP: VkPrimitiveTopology = VkPrimitiveTopology(4);
/// `5`  
pub const VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN: VkPrimitiveTopology = VkPrimitiveTopology(5);
/// `6`  
pub const VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY: VkPrimitiveTopology = VkPrimitiveTopology(6);
/// `7`  
pub const VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY: VkPrimitiveTopology = VkPrimitiveTopology(7);
/// `8`  
pub const VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY: VkPrimitiveTopology = VkPrimitiveTopology(8);
/// `9`  
pub const VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY: VkPrimitiveTopology = VkPrimitiveTopology(9);
/// `10`  
pub const VK_PRIMITIVE_TOPOLOGY_PATCH_LIST: VkPrimitiveTopology = VkPrimitiveTopology(10);

impl_enum_display!(VkPrimitiveTopology { VK_PRIMITIVE_TOPOLOGY_POINT_LIST, VK_PRIMITIVE_TOPOLOGY_LINE_LIST, VK_PRIMITIVE_TOPOLOGY_LINE_STRIP, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN, VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY, VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY, VK_PRIMITIVE_TOPOLOGY_PATCH_LIST });

/// `VkPrivateDataSlot` : `VkDevice`
#[repr(transparent)]
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkPrivateDataSlot(pub u64);
from_into_transparent!(VkPrivateDataSlot: u64);
impl_handle!(VkPrivateDataSlot: VK_OBJECT_TYPE_PRIVATE_DATA_SLOT; SubHandle = VkDevice);

flags!(VkPrivateDataSlotCreateFlags);
from_into_transparent!(VkPrivateDataSlotCreateFlags: i32);
/// `VkPrivateDataSlotCreateFlags`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkPrivateDataSlotCreateFlags(pub i32);

/// `1 << 0`  
pub const VK_PRIVATE_DATA_SLOT_CREATE_RESERVED_0_BIT_NV: VkPrivateDataSlotCreateFlags = VkPrivateDataSlotCreateFlags(1 << 0);

impl_flags_display!(VkPrivateDataSlotCreateFlags { VK_PRIVATE_DATA_SLOT_CREATE_RESERVED_0_BIT_NV });

/// `VkPrivateDataSlotCreateFlags`
pub type VkPrivateDataSlotCreateFlagsEXT = VkPrivateDataSlotCreateFlags;

/// `VkPrivateDataSlotCreateInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPrivateDataSlotCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub flags: VkPrivateDataSlotCreateFlags,
}
impl_default_zeroed_with_s_type!(VkPrivateDataSlotCreateInfo : VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO);

/// `VkPrivateDataSlotCreateInfo`
pub type VkPrivateDataSlotCreateInfoEXT = VkPrivateDataSlotCreateInfo;

/// `VkPrivateDataSlot`
pub type VkPrivateDataSlotEXT = VkPrivateDataSlot;

/// `VkProtectedSubmitInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkProtectedSubmitInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    /// Submit protected command buffers
    pub protectedSubmit: VkBool32,
}
impl_default_zeroed_with_s_type!(VkProtectedSubmitInfo : VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO);
impl_extends!(VkProtectedSubmitInfo : VkSubmitInfo);

from_into_transparent!(VkProvokingVertexModeEXT: i32);
/// `VkProvokingVertexModeEXT`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkProvokingVertexModeEXT(pub i32);

/// `0`  
pub const VK_PROVOKING_VERTEX_MODE_FIRST_VERTEX_EXT: VkProvokingVertexModeEXT = VkProvokingVertexModeEXT(0);
/// `1`  
pub const VK_PROVOKING_VERTEX_MODE_LAST_VERTEX_EXT: VkProvokingVertexModeEXT = VkProvokingVertexModeEXT(1);

impl_enum_display!(VkProvokingVertexModeEXT { VK_PROVOKING_VERTEX_MODE_FIRST_VERTEX_EXT, VK_PROVOKING_VERTEX_MODE_LAST_VERTEX_EXT });

/// `VkPushConstantBankInfoNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPushConstantBankInfoNV {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub bank: uint32_t,
}
impl_default_zeroed_with_s_type!(VkPushConstantBankInfoNV : VK_STRUCTURE_TYPE_PUSH_CONSTANT_BANK_INFO_NV);
impl_extends!(VkPushConstantBankInfoNV : VkDescriptorSetAndBindingMappingEXT, VkPushDataInfoEXT, VkPushConstantsInfo, VkIndirectCommandsLayoutTokenEXT);

/// `VkPushConstantRange`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPushConstantRange {
    /// Which stages use the range
    pub stageFlags: VkShaderStageFlags,
    /// Start of the range, in bytes
    pub offset: uint32_t,
    /// Size of the range, in bytes
    pub size: uint32_t,
}
impl_default_zeroed!(VkPushConstantRange);

/// `VkPushConstantsInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPushConstantsInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub layout: VkPipelineLayout,
    pub stageFlags: VkShaderStageFlags,
    pub offset: uint32_t,
    pub size: uint32_t,
    pub pValues: *const void,
}
impl_default_zeroed_with_s_type!(VkPushConstantsInfo : VK_STRUCTURE_TYPE_PUSH_CONSTANTS_INFO);

/// `VkPushConstantsInfo`
pub type VkPushConstantsInfoKHR = VkPushConstantsInfo;

/// `VkPushDataInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPushDataInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub offset: uint32_t,
    pub data: VkHostAddressRangeConstEXT,
}
impl_default_zeroed_with_s_type!(VkPushDataInfoEXT : VK_STRUCTURE_TYPE_PUSH_DATA_INFO_EXT);

/// `VkPushDescriptorSetInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPushDescriptorSetInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub stageFlags: VkShaderStageFlags,
    pub layout: VkPipelineLayout,
    pub set: uint32_t,
    pub descriptorWriteCount: uint32_t,
    pub pDescriptorWrites: *const VkWriteDescriptorSet,
}
impl_default_zeroed_with_s_type!(VkPushDescriptorSetInfo : VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_INFO);

/// `VkPushDescriptorSetInfo`
pub type VkPushDescriptorSetInfoKHR = VkPushDescriptorSetInfo;

/// `VkPushDescriptorSetWithTemplateInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkPushDescriptorSetWithTemplateInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub descriptorUpdateTemplate: VkDescriptorUpdateTemplate,
    pub layout: VkPipelineLayout,
    pub set: uint32_t,
    pub pData: *const void,
}
impl_default_zeroed_with_s_type!(VkPushDescriptorSetWithTemplateInfo : VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO);

/// `VkPushDescriptorSetWithTemplateInfo`
pub type VkPushDescriptorSetWithTemplateInfoKHR = VkPushDescriptorSetWithTemplateInfo;

flags!(VkQueryControlFlags);
from_into_transparent!(VkQueryControlFlags: i32);
/// `VkQueryControlFlags`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkQueryControlFlags(pub i32);

/// `1 << 0`  
/// 
/// Require precise results to be collected by the query
pub const VK_QUERY_CONTROL_PRECISE_BIT: VkQueryControlFlags = VkQueryControlFlags(1 << 0);

impl_flags_display!(VkQueryControlFlags { VK_QUERY_CONTROL_PRECISE_BIT });

/// `VkQueryLowLatencySupportNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkQueryLowLatencySupportNV {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub pQueriedLowLatencyData: *mut void,
}
impl_default_zeroed_with_s_type!(VkQueryLowLatencySupportNV : VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV);
impl_extends!(VkQueryLowLatencySupportNV : VkSemaphoreCreateInfo);

flags!(VkQueryPipelineStatisticFlags);
from_into_transparent!(VkQueryPipelineStatisticFlags: i32);
/// `VkQueryPipelineStatisticFlags`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkQueryPipelineStatisticFlags(pub i32);

/// `1 << 0`  
/// 
/// Optional
pub const VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT: VkQueryPipelineStatisticFlags = VkQueryPipelineStatisticFlags(1 << 0);
/// `1 << 1`  
/// 
/// Optional
pub const VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT: VkQueryPipelineStatisticFlags = VkQueryPipelineStatisticFlags(1 << 1);
/// `1 << 2`  
/// 
/// Optional
pub const VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT: VkQueryPipelineStatisticFlags = VkQueryPipelineStatisticFlags(1 << 2);
/// `1 << 3`  
/// 
/// Optional
pub const VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT: VkQueryPipelineStatisticFlags = VkQueryPipelineStatisticFlags(1 << 3);
/// `1 << 4`  
/// 
/// Optional
pub const VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT: VkQueryPipelineStatisticFlags = VkQueryPipelineStatisticFlags(1 << 4);
/// `1 << 5`  
/// 
/// Optional
pub const VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT: VkQueryPipelineStatisticFlags = VkQueryPipelineStatisticFlags(1 << 5);
/// `1 << 6`  
/// 
/// Optional
pub const VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT: VkQueryPipelineStatisticFlags = VkQueryPipelineStatisticFlags(1 << 6);
/// `1 << 7`  
/// 
/// Optional
pub const VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT: VkQueryPipelineStatisticFlags = VkQueryPipelineStatisticFlags(1 << 7);
/// `1 << 8`  
/// 
/// Optional
pub const VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT: VkQueryPipelineStatisticFlags = VkQueryPipelineStatisticFlags(1 << 8);
/// `1 << 9`  
/// 
/// Optional
pub const VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT: VkQueryPipelineStatisticFlags = VkQueryPipelineStatisticFlags(1 << 9);
/// `1 << 10`  
/// 
/// Optional
pub const VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT: VkQueryPipelineStatisticFlags = VkQueryPipelineStatisticFlags(1 << 10);
/// `1 << 11`  
pub const VK_QUERY_PIPELINE_STATISTIC_TASK_SHADER_INVOCATIONS_BIT_EXT: VkQueryPipelineStatisticFlags = VkQueryPipelineStatisticFlags(1 << 11);
/// `1 << 12`  
pub const VK_QUERY_PIPELINE_STATISTIC_MESH_SHADER_INVOCATIONS_BIT_EXT: VkQueryPipelineStatisticFlags = VkQueryPipelineStatisticFlags(1 << 12);
/// `1 << 13`  
pub const VK_QUERY_PIPELINE_STATISTIC_CLUSTER_CULLING_SHADER_INVOCATIONS_BIT_HUAWEI: VkQueryPipelineStatisticFlags = VkQueryPipelineStatisticFlags(1 << 13);

impl_flags_display!(VkQueryPipelineStatisticFlags { VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT, VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT, VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT, VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT, VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT, VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT, VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT, VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT, VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT, VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT, VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT, VK_QUERY_PIPELINE_STATISTIC_TASK_SHADER_INVOCATIONS_BIT_EXT, VK_QUERY_PIPELINE_STATISTIC_MESH_SHADER_INVOCATIONS_BIT_EXT, VK_QUERY_PIPELINE_STATISTIC_CLUSTER_CULLING_SHADER_INVOCATIONS_BIT_HUAWEI });

/// `VkQueryPool` : `VkDevice`
#[repr(transparent)]
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkQueryPool(pub u64);
from_into_transparent!(VkQueryPool: u64);
impl_handle!(VkQueryPool: VK_OBJECT_TYPE_QUERY_POOL; SubHandle = VkDevice);

flags!(VkQueryPoolCreateFlags);
from_into_transparent!(VkQueryPoolCreateFlags: i32);
/// `VkQueryPoolCreateFlags`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkQueryPoolCreateFlags(pub i32);

/// `1 << 0`  
pub const VK_QUERY_POOL_CREATE_RESET_BIT_KHR: VkQueryPoolCreateFlags = VkQueryPoolCreateFlags(1 << 0);

impl_flags_display!(VkQueryPoolCreateFlags { VK_QUERY_POOL_CREATE_RESET_BIT_KHR });

/// `VkQueryPoolCreateInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkQueryPoolCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub flags: VkQueryPoolCreateFlags,
    pub queryType: VkQueryType,
    pub queryCount: uint32_t,
    /// Optional
    pub pipelineStatistics: VkQueryPipelineStatisticFlags,
}
impl_default_zeroed_with_s_type!(VkQueryPoolCreateInfo : VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO);

/// `VkQueryPoolPerformanceQueryCreateInfoINTEL`
pub type VkQueryPoolCreateInfoINTEL = VkQueryPoolPerformanceQueryCreateInfoINTEL;

/// `VkQueryPoolPerformanceCreateInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkQueryPoolPerformanceCreateInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub queueFamilyIndex: uint32_t,
    pub counterIndexCount: uint32_t,
    pub pCounterIndices: *const uint32_t,
}
impl_default_zeroed_with_s_type!(VkQueryPoolPerformanceCreateInfoKHR : VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR);
impl_extends!(VkQueryPoolPerformanceCreateInfoKHR : VkQueryPoolCreateInfo);

/// `VkQueryPoolPerformanceQueryCreateInfoINTEL`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkQueryPoolPerformanceQueryCreateInfoINTEL {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub performanceCountersSampling: VkQueryPoolSamplingModeINTEL,
}
impl_default_zeroed_with_s_type!(VkQueryPoolPerformanceQueryCreateInfoINTEL : VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL);
impl_extends!(VkQueryPoolPerformanceQueryCreateInfoINTEL : VkQueryPoolCreateInfo);

from_into_transparent!(VkQueryPoolSamplingModeINTEL: i32);
/// `VkQueryPoolSamplingModeINTEL`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkQueryPoolSamplingModeINTEL(pub i32);

/// `0`  
pub const VK_QUERY_POOL_SAMPLING_MODE_MANUAL_INTEL: VkQueryPoolSamplingModeINTEL = VkQueryPoolSamplingModeINTEL(0);

impl_enum_display!(VkQueryPoolSamplingModeINTEL { VK_QUERY_POOL_SAMPLING_MODE_MANUAL_INTEL });

/// `VkQueryPoolVideoEncodeFeedbackCreateInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkQueryPoolVideoEncodeFeedbackCreateInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub encodeFeedbackFlags: VkVideoEncodeFeedbackFlagsKHR,
}
impl_default_zeroed_with_s_type!(VkQueryPoolVideoEncodeFeedbackCreateInfoKHR : VK_STRUCTURE_TYPE_QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO_KHR);
impl_extends!(VkQueryPoolVideoEncodeFeedbackCreateInfoKHR : VkQueryPoolCreateInfo);

flags!(VkQueryResultFlags);
from_into_transparent!(VkQueryResultFlags: i32);
/// `VkQueryResultFlags`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkQueryResultFlags(pub i32);

/// `1 << 0`  
/// 
/// Results of the queries are written to the destination buffer as 64-bit values
pub const VK_QUERY_RESULT_64_BIT: VkQueryResultFlags = VkQueryResultFlags(1 << 0);
/// `1 << 1`  
/// 
/// Results of the queries are waited on before proceeding with the result copy
pub const VK_QUERY_RESULT_WAIT_BIT: VkQueryResultFlags = VkQueryResultFlags(1 << 1);
/// `1 << 2`  
/// 
/// Besides the results of the query, the availability of the results is also written
pub const VK_QUERY_RESULT_WITH_AVAILABILITY_BIT: VkQueryResultFlags = VkQueryResultFlags(1 << 2);
/// `1 << 3`  
/// 
/// Copy the partial results of the query even if the final results are not available
pub const VK_QUERY_RESULT_PARTIAL_BIT: VkQueryResultFlags = VkQueryResultFlags(1 << 3);
/// `1 << 4`  
pub const VK_QUERY_RESULT_WITH_STATUS_BIT_KHR: VkQueryResultFlags = VkQueryResultFlags(1 << 4);

impl_flags_display!(VkQueryResultFlags { VK_QUERY_RESULT_64_BIT, VK_QUERY_RESULT_WAIT_BIT, VK_QUERY_RESULT_WITH_AVAILABILITY_BIT, VK_QUERY_RESULT_PARTIAL_BIT, VK_QUERY_RESULT_WITH_STATUS_BIT_KHR });

from_into_transparent!(VkQueryResultStatusKHR: i32);
/// `VkQueryResultStatusKHR`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkQueryResultStatusKHR(pub i32);

/// `-1`  
pub const VK_QUERY_RESULT_STATUS_ERROR_KHR: VkQueryResultStatusKHR = VkQueryResultStatusKHR(-1);
/// `0`  
pub const VK_QUERY_RESULT_STATUS_NOT_READY_KHR: VkQueryResultStatusKHR = VkQueryResultStatusKHR(0);
/// `1`  
pub const VK_QUERY_RESULT_STATUS_COMPLETE_KHR: VkQueryResultStatusKHR = VkQueryResultStatusKHR(1);
/// `-1000299000`  
pub const VK_QUERY_RESULT_STATUS_INSUFFICIENT_BITSTREAM_BUFFER_RANGE_KHR: VkQueryResultStatusKHR = VkQueryResultStatusKHR(-1000299000);

impl_enum_display!(VkQueryResultStatusKHR { VK_QUERY_RESULT_STATUS_ERROR_KHR, VK_QUERY_RESULT_STATUS_NOT_READY_KHR, VK_QUERY_RESULT_STATUS_COMPLETE_KHR, VK_QUERY_RESULT_STATUS_INSUFFICIENT_BITSTREAM_BUFFER_RANGE_KHR });

from_into_transparent!(VkQueryType: i32);
/// `VkQueryType`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkQueryType(pub i32);

/// `0`  
pub const VK_QUERY_TYPE_OCCLUSION: VkQueryType = VkQueryType(0);
/// `1`  
/// 
/// Optional
pub const VK_QUERY_TYPE_PIPELINE_STATISTICS: VkQueryType = VkQueryType(1);
/// `2`  
pub const VK_QUERY_TYPE_TIMESTAMP: VkQueryType = VkQueryType(2);
/// `1000023000`  
pub const VK_QUERY_TYPE_RESULT_STATUS_ONLY_KHR: VkQueryType = VkQueryType(1000023000);
/// `1000028004`  
pub const VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT: VkQueryType = VkQueryType(1000028004);
/// `1000116000`  
pub const VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR: VkQueryType = VkQueryType(1000116000);
/// `1000150000`  
pub const VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_KHR: VkQueryType = VkQueryType(1000150000);
/// `1000150001`  
pub const VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SERIALIZATION_SIZE_KHR: VkQueryType = VkQueryType(1000150001);
/// `1000165000`  
pub const VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV: VkQueryType = VkQueryType(1000165000);
/// `1000210000`  
pub const VK_QUERY_TYPE_PERFORMANCE_QUERY_INTEL: VkQueryType = VkQueryType(1000210000);
/// `1000299000`  
pub const VK_QUERY_TYPE_VIDEO_ENCODE_FEEDBACK_KHR: VkQueryType = VkQueryType(1000299000);
/// `1000328000`  
pub const VK_QUERY_TYPE_MESH_PRIMITIVES_GENERATED_EXT: VkQueryType = VkQueryType(1000328000);
/// `1000382000`  
pub const VK_QUERY_TYPE_PRIMITIVES_GENERATED_EXT: VkQueryType = VkQueryType(1000382000);
/// `1000386000`  
pub const VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SERIALIZATION_BOTTOM_LEVEL_POINTERS_KHR: VkQueryType = VkQueryType(1000386000);
/// `1000386001`  
pub const VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SIZE_KHR: VkQueryType = VkQueryType(1000386001);
/// `1000396000`  
pub const VK_QUERY_TYPE_MICROMAP_SERIALIZATION_SIZE_EXT: VkQueryType = VkQueryType(1000396000);
/// `1000396001`  
pub const VK_QUERY_TYPE_MICROMAP_COMPACTED_SIZE_EXT: VkQueryType = VkQueryType(1000396001);

impl_enum_display!(VkQueryType { VK_QUERY_TYPE_OCCLUSION, VK_QUERY_TYPE_PIPELINE_STATISTICS, VK_QUERY_TYPE_TIMESTAMP, VK_QUERY_TYPE_RESULT_STATUS_ONLY_KHR, VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT, VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR, VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_KHR, VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SERIALIZATION_SIZE_KHR, VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV, VK_QUERY_TYPE_PERFORMANCE_QUERY_INTEL, VK_QUERY_TYPE_VIDEO_ENCODE_FEEDBACK_KHR, VK_QUERY_TYPE_MESH_PRIMITIVES_GENERATED_EXT, VK_QUERY_TYPE_PRIMITIVES_GENERATED_EXT, VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SERIALIZATION_BOTTOM_LEVEL_POINTERS_KHR, VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SIZE_KHR, VK_QUERY_TYPE_MICROMAP_SERIALIZATION_SIZE_EXT, VK_QUERY_TYPE_MICROMAP_COMPACTED_SIZE_EXT });

/// `VkQueue` : `VkDevice`
#[repr(transparent)]
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkQueue(pub *mut void);
from_into_transparent!(VkQueue: *mut void);
from_into_transparent!(VkQueue: u64);
impl_handle!(VkQueue: VK_OBJECT_TYPE_QUEUE; SubHandle = VkDevice);

/// `VkQueueFamilyCheckpointProperties2NV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkQueueFamilyCheckpointProperties2NV {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub checkpointExecutionStageMask: VkPipelineStageFlags2,
}
impl_default_zeroed_with_s_type!(VkQueueFamilyCheckpointProperties2NV : VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV);
impl_extends!(VkQueueFamilyCheckpointProperties2NV : VkQueueFamilyProperties2);

/// `VkQueueFamilyCheckpointPropertiesNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkQueueFamilyCheckpointPropertiesNV {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub checkpointExecutionStageMask: VkPipelineStageFlags,
}
impl_default_zeroed_with_s_type!(VkQueueFamilyCheckpointPropertiesNV : VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV);
impl_extends!(VkQueueFamilyCheckpointPropertiesNV : VkQueueFamilyProperties2);

/// `VkQueueFamilyDataGraphProcessingEnginePropertiesARM`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkQueueFamilyDataGraphProcessingEnginePropertiesARM {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub foreignSemaphoreHandleTypes: VkExternalSemaphoreHandleTypeFlags,
    pub foreignMemoryHandleTypes: VkExternalMemoryHandleTypeFlags,
}
impl_default_zeroed_with_s_type!(VkQueueFamilyDataGraphProcessingEnginePropertiesARM : VK_STRUCTURE_TYPE_QUEUE_FAMILY_DATA_GRAPH_PROCESSING_ENGINE_PROPERTIES_ARM);

/// `VkQueueFamilyDataGraphPropertiesARM`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkQueueFamilyDataGraphPropertiesARM {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub engine: VkPhysicalDeviceDataGraphProcessingEngineARM,
    pub operation: VkPhysicalDeviceDataGraphOperationSupportARM,
}
impl_default_zeroed_with_s_type!(VkQueueFamilyDataGraphPropertiesARM : VK_STRUCTURE_TYPE_QUEUE_FAMILY_DATA_GRAPH_PROPERTIES_ARM);

/// `VkQueueFamilyGlobalPriorityProperties`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkQueueFamilyGlobalPriorityProperties {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub priorityCount: uint32_t,
    pub priorities: [VkQueueGlobalPriority; VK_MAX_GLOBAL_PRIORITY_SIZE as usize],
}
impl_default_zeroed_with_s_type!(VkQueueFamilyGlobalPriorityProperties : VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES);
impl_extends!(VkQueueFamilyGlobalPriorityProperties : VkQueueFamilyProperties2);

/// `VkQueueFamilyGlobalPriorityProperties`
pub type VkQueueFamilyGlobalPriorityPropertiesEXT = VkQueueFamilyGlobalPriorityProperties;

/// `VkQueueFamilyGlobalPriorityProperties`
pub type VkQueueFamilyGlobalPriorityPropertiesKHR = VkQueueFamilyGlobalPriorityProperties;

/// `VkQueueFamilyOwnershipTransferPropertiesKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkQueueFamilyOwnershipTransferPropertiesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub optimalImageTransferToQueueFamilies: uint32_t,
}
impl_default_zeroed_with_s_type!(VkQueueFamilyOwnershipTransferPropertiesKHR : VK_STRUCTURE_TYPE_QUEUE_FAMILY_OWNERSHIP_TRANSFER_PROPERTIES_KHR);
impl_extends!(VkQueueFamilyOwnershipTransferPropertiesKHR : VkQueueFamilyProperties2);

/// `VkQueueFamilyProperties`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkQueueFamilyProperties {
    /// Queue flags
    pub queueFlags: VkQueueFlags,
    pub queueCount: uint32_t,
    pub timestampValidBits: uint32_t,
    /// Minimum alignment requirement for image transfers
    pub minImageTransferGranularity: VkExtent3D,
}
impl_default_zeroed!(VkQueueFamilyProperties);

/// `VkQueueFamilyProperties2`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkQueueFamilyProperties2 {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub queueFamilyProperties: VkQueueFamilyProperties,
}
impl_default_zeroed_with_s_type!(VkQueueFamilyProperties2 : VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2);

/// `VkQueueFamilyProperties2`
pub type VkQueueFamilyProperties2KHR = VkQueueFamilyProperties2;

/// `VkQueueFamilyQueryResultStatusPropertiesKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkQueueFamilyQueryResultStatusPropertiesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub queryResultStatusSupport: VkBool32,
}
impl_default_zeroed_with_s_type!(VkQueueFamilyQueryResultStatusPropertiesKHR : VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR);
impl_extends!(VkQueueFamilyQueryResultStatusPropertiesKHR : VkQueueFamilyProperties2);

/// `VkQueueFamilyVideoPropertiesKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkQueueFamilyVideoPropertiesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub videoCodecOperations: VkVideoCodecOperationFlagsKHR,
}
impl_default_zeroed_with_s_type!(VkQueueFamilyVideoPropertiesKHR : VK_STRUCTURE_TYPE_QUEUE_FAMILY_VIDEO_PROPERTIES_KHR);
impl_extends!(VkQueueFamilyVideoPropertiesKHR : VkQueueFamilyProperties2);

flags!(VkQueueFlags);
from_into_transparent!(VkQueueFlags: i32);
/// `VkQueueFlags`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkQueueFlags(pub i32);

/// `1 << 0`  
/// 
/// Queue supports graphics operations
pub const VK_QUEUE_GRAPHICS_BIT: VkQueueFlags = VkQueueFlags(1 << 0);
/// `1 << 1`  
/// 
/// Queue supports compute operations
pub const VK_QUEUE_COMPUTE_BIT: VkQueueFlags = VkQueueFlags(1 << 1);
/// `1 << 2`  
/// 
/// Queue supports transfer operations
pub const VK_QUEUE_TRANSFER_BIT: VkQueueFlags = VkQueueFlags(1 << 2);
/// `1 << 3`  
/// 
/// Queue supports sparse resource memory management operations
pub const VK_QUEUE_SPARSE_BINDING_BIT: VkQueueFlags = VkQueueFlags(1 << 3);
/// `1 << 4`  
/// 
/// Queues may support protected operations
pub const VK_QUEUE_PROTECTED_BIT: VkQueueFlags = VkQueueFlags(1 << 4);
/// `1 << 5`  
pub const VK_QUEUE_VIDEO_DECODE_BIT_KHR: VkQueueFlags = VkQueueFlags(1 << 5);
/// `1 << 6`  
pub const VK_QUEUE_VIDEO_ENCODE_BIT_KHR: VkQueueFlags = VkQueueFlags(1 << 6);
/// `1 << 7`  
pub const VK_QUEUE_RESERVED_7_BIT_QCOM: VkQueueFlags = VkQueueFlags(1 << 7);
/// `1 << 8`  
pub const VK_QUEUE_OPTICAL_FLOW_BIT_NV: VkQueueFlags = VkQueueFlags(1 << 8);
/// `1 << 10`  
pub const VK_QUEUE_DATA_GRAPH_BIT_ARM: VkQueueFlags = VkQueueFlags(1 << 10);
/// `1 << 12`  
pub const VK_QUEUE_RESERVED_12_BIT_EXT: VkQueueFlags = VkQueueFlags(1 << 12);
/// `1 << 9`  
pub const VK_QUEUE_RESERVED_9_BIT_EXT: VkQueueFlags = VkQueueFlags(1 << 9);
/// `1 << 13`  
pub const VK_QUEUE_RESERVED_13_BIT_EXT: VkQueueFlags = VkQueueFlags(1 << 13);
/// `1 << 11`  
pub const VK_QUEUE_RESERVED_11_BIT_ARM: VkQueueFlags = VkQueueFlags(1 << 11);

impl_flags_display!(VkQueueFlags { VK_QUEUE_GRAPHICS_BIT, VK_QUEUE_COMPUTE_BIT, VK_QUEUE_TRANSFER_BIT, VK_QUEUE_SPARSE_BINDING_BIT, VK_QUEUE_PROTECTED_BIT, VK_QUEUE_VIDEO_DECODE_BIT_KHR, VK_QUEUE_VIDEO_ENCODE_BIT_KHR, VK_QUEUE_RESERVED_7_BIT_QCOM, VK_QUEUE_OPTICAL_FLOW_BIT_NV, VK_QUEUE_DATA_GRAPH_BIT_ARM, VK_QUEUE_RESERVED_12_BIT_EXT, VK_QUEUE_RESERVED_9_BIT_EXT, VK_QUEUE_RESERVED_13_BIT_EXT, VK_QUEUE_RESERVED_11_BIT_ARM });

from_into_transparent!(VkQueueGlobalPriority: i32);
/// `VkQueueGlobalPriority`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkQueueGlobalPriority(pub i32);

/// `128`  
pub const VK_QUEUE_GLOBAL_PRIORITY_LOW: VkQueueGlobalPriority = VkQueueGlobalPriority(128);
/// `256`  
pub const VK_QUEUE_GLOBAL_PRIORITY_MEDIUM: VkQueueGlobalPriority = VkQueueGlobalPriority(256);
/// `512`  
pub const VK_QUEUE_GLOBAL_PRIORITY_HIGH: VkQueueGlobalPriority = VkQueueGlobalPriority(512);
/// `1024`  
pub const VK_QUEUE_GLOBAL_PRIORITY_REALTIME: VkQueueGlobalPriority = VkQueueGlobalPriority(1024);
/// `VK_QUEUE_GLOBAL_PRIORITY_LOW`  
pub const VK_QUEUE_GLOBAL_PRIORITY_LOW_EXT: VkQueueGlobalPriority = VK_QUEUE_GLOBAL_PRIORITY_LOW;
/// `VK_QUEUE_GLOBAL_PRIORITY_MEDIUM`  
pub const VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_EXT: VkQueueGlobalPriority = VK_QUEUE_GLOBAL_PRIORITY_MEDIUM;
/// `VK_QUEUE_GLOBAL_PRIORITY_HIGH`  
pub const VK_QUEUE_GLOBAL_PRIORITY_HIGH_EXT: VkQueueGlobalPriority = VK_QUEUE_GLOBAL_PRIORITY_HIGH;
/// `VK_QUEUE_GLOBAL_PRIORITY_REALTIME`  
pub const VK_QUEUE_GLOBAL_PRIORITY_REALTIME_EXT: VkQueueGlobalPriority = VK_QUEUE_GLOBAL_PRIORITY_REALTIME;
/// `VK_QUEUE_GLOBAL_PRIORITY_LOW`  
pub const VK_QUEUE_GLOBAL_PRIORITY_LOW_KHR: VkQueueGlobalPriority = VK_QUEUE_GLOBAL_PRIORITY_LOW;
/// `VK_QUEUE_GLOBAL_PRIORITY_MEDIUM`  
pub const VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_KHR: VkQueueGlobalPriority = VK_QUEUE_GLOBAL_PRIORITY_MEDIUM;
/// `VK_QUEUE_GLOBAL_PRIORITY_HIGH`  
pub const VK_QUEUE_GLOBAL_PRIORITY_HIGH_KHR: VkQueueGlobalPriority = VK_QUEUE_GLOBAL_PRIORITY_HIGH;
/// `VK_QUEUE_GLOBAL_PRIORITY_REALTIME`  
pub const VK_QUEUE_GLOBAL_PRIORITY_REALTIME_KHR: VkQueueGlobalPriority = VK_QUEUE_GLOBAL_PRIORITY_REALTIME;

impl_enum_display!(VkQueueGlobalPriority { VK_QUEUE_GLOBAL_PRIORITY_LOW, VK_QUEUE_GLOBAL_PRIORITY_MEDIUM, VK_QUEUE_GLOBAL_PRIORITY_HIGH, VK_QUEUE_GLOBAL_PRIORITY_REALTIME, VK_QUEUE_GLOBAL_PRIORITY_LOW_EXT, VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_EXT, VK_QUEUE_GLOBAL_PRIORITY_HIGH_EXT, VK_QUEUE_GLOBAL_PRIORITY_REALTIME_EXT, VK_QUEUE_GLOBAL_PRIORITY_LOW_KHR, VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_KHR, VK_QUEUE_GLOBAL_PRIORITY_HIGH_KHR, VK_QUEUE_GLOBAL_PRIORITY_REALTIME_KHR });

/// `VkQueueGlobalPriority`
pub type VkQueueGlobalPriorityEXT = VkQueueGlobalPriority;

/// `VkQueueGlobalPriority`
pub type VkQueueGlobalPriorityKHR = VkQueueGlobalPriority;

from_into_transparent!(VkRasterizationOrderAMD: i32);
/// `VkRasterizationOrderAMD`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkRasterizationOrderAMD(pub i32);

/// `0`  
pub const VK_RASTERIZATION_ORDER_STRICT_AMD: VkRasterizationOrderAMD = VkRasterizationOrderAMD(0);
/// `1`  
pub const VK_RASTERIZATION_ORDER_RELAXED_AMD: VkRasterizationOrderAMD = VkRasterizationOrderAMD(1);

impl_enum_display!(VkRasterizationOrderAMD { VK_RASTERIZATION_ORDER_STRICT_AMD, VK_RASTERIZATION_ORDER_RELAXED_AMD });

from_into_transparent!(VkRayTracingInvocationReorderModeEXT: i32);
/// `VkRayTracingInvocationReorderModeEXT`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkRayTracingInvocationReorderModeEXT(pub i32);

/// `0`  
pub const VK_RAY_TRACING_INVOCATION_REORDER_MODE_NONE_EXT: VkRayTracingInvocationReorderModeEXT = VkRayTracingInvocationReorderModeEXT(0);
/// `1`  
pub const VK_RAY_TRACING_INVOCATION_REORDER_MODE_REORDER_EXT: VkRayTracingInvocationReorderModeEXT = VkRayTracingInvocationReorderModeEXT(1);
/// `VK_RAY_TRACING_INVOCATION_REORDER_MODE_NONE_EXT`  
pub const VK_RAY_TRACING_INVOCATION_REORDER_MODE_NONE_NV: VkRayTracingInvocationReorderModeEXT = VK_RAY_TRACING_INVOCATION_REORDER_MODE_NONE_EXT;
/// `VK_RAY_TRACING_INVOCATION_REORDER_MODE_REORDER_EXT`  
pub const VK_RAY_TRACING_INVOCATION_REORDER_MODE_REORDER_NV: VkRayTracingInvocationReorderModeEXT = VK_RAY_TRACING_INVOCATION_REORDER_MODE_REORDER_EXT;

impl_enum_display!(VkRayTracingInvocationReorderModeEXT { VK_RAY_TRACING_INVOCATION_REORDER_MODE_NONE_EXT, VK_RAY_TRACING_INVOCATION_REORDER_MODE_REORDER_EXT, VK_RAY_TRACING_INVOCATION_REORDER_MODE_NONE_NV, VK_RAY_TRACING_INVOCATION_REORDER_MODE_REORDER_NV });

/// `VkRayTracingInvocationReorderModeEXT`
pub type VkRayTracingInvocationReorderModeNV = VkRayTracingInvocationReorderModeEXT;

from_into_transparent!(VkRayTracingLssIndexingModeNV: i32);
/// `VkRayTracingLssIndexingModeNV`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkRayTracingLssIndexingModeNV(pub i32);

/// `0`  
pub const VK_RAY_TRACING_LSS_INDEXING_MODE_LIST_NV: VkRayTracingLssIndexingModeNV = VkRayTracingLssIndexingModeNV(0);
/// `1`  
pub const VK_RAY_TRACING_LSS_INDEXING_MODE_SUCCESSIVE_NV: VkRayTracingLssIndexingModeNV = VkRayTracingLssIndexingModeNV(1);

impl_enum_display!(VkRayTracingLssIndexingModeNV { VK_RAY_TRACING_LSS_INDEXING_MODE_LIST_NV, VK_RAY_TRACING_LSS_INDEXING_MODE_SUCCESSIVE_NV });

from_into_transparent!(VkRayTracingLssPrimitiveEndCapsModeNV: i32);
/// `VkRayTracingLssPrimitiveEndCapsModeNV`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkRayTracingLssPrimitiveEndCapsModeNV(pub i32);

/// `0`  
pub const VK_RAY_TRACING_LSS_PRIMITIVE_END_CAPS_MODE_NONE_NV: VkRayTracingLssPrimitiveEndCapsModeNV = VkRayTracingLssPrimitiveEndCapsModeNV(0);
/// `1`  
pub const VK_RAY_TRACING_LSS_PRIMITIVE_END_CAPS_MODE_CHAINED_NV: VkRayTracingLssPrimitiveEndCapsModeNV = VkRayTracingLssPrimitiveEndCapsModeNV(1);

impl_enum_display!(VkRayTracingLssPrimitiveEndCapsModeNV { VK_RAY_TRACING_LSS_PRIMITIVE_END_CAPS_MODE_NONE_NV, VK_RAY_TRACING_LSS_PRIMITIVE_END_CAPS_MODE_CHAINED_NV });

/// `VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub allowClusterAccelerationStructure: VkBool32,
}
impl_default_zeroed_with_s_type!(VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV : VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CLUSTER_ACCELERATION_STRUCTURE_CREATE_INFO_NV);
impl_extends!(VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV : VkRayTracingPipelineCreateInfoKHR);

/// `VkRayTracingPipelineCreateInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkRayTracingPipelineCreateInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    /// Pipeline creation flags
    pub flags: VkPipelineCreateFlags,
    pub stageCount: uint32_t,
    /// One entry for each active shader stage
    pub pStages: *const VkPipelineShaderStageCreateInfo,
    pub groupCount: uint32_t,
    pub pGroups: *const VkRayTracingShaderGroupCreateInfoKHR,
    pub maxPipelineRayRecursionDepth: uint32_t,
    pub pLibraryInfo: *const VkPipelineLibraryCreateInfoKHR,
    pub pLibraryInterface: *const VkRayTracingPipelineInterfaceCreateInfoKHR,
    pub pDynamicState: *const VkPipelineDynamicStateCreateInfo,
    /// Interface layout of the pipeline
    pub layout: VkPipelineLayout,
    /// 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 basePipelineHandle: VkPipeline,
    /// 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 basePipelineIndex: int32_t,
}
impl_default_zeroed_with_s_type!(VkRayTracingPipelineCreateInfoKHR : VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_KHR);

/// `VkRayTracingPipelineCreateInfoNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkRayTracingPipelineCreateInfoNV {
    pub sType: VkStructureType,
    pub pNext: *const void,
    /// Pipeline creation flags
    pub flags: VkPipelineCreateFlags,
    pub stageCount: uint32_t,
    /// One entry for each active shader stage
    pub pStages: *const VkPipelineShaderStageCreateInfo,
    pub groupCount: uint32_t,
    pub pGroups: *const VkRayTracingShaderGroupCreateInfoNV,
    pub maxRecursionDepth: uint32_t,
    /// Interface layout of the pipeline
    pub layout: VkPipelineLayout,
    /// 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 basePipelineHandle: VkPipeline,
    /// 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 basePipelineIndex: int32_t,
}
impl_default_zeroed_with_s_type!(VkRayTracingPipelineCreateInfoNV : VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_NV);

/// `VkRayTracingPipelineInterfaceCreateInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkRayTracingPipelineInterfaceCreateInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub maxPipelineRayPayloadSize: uint32_t,
    pub maxPipelineRayHitAttributeSize: uint32_t,
}
impl_default_zeroed_with_s_type!(VkRayTracingPipelineInterfaceCreateInfoKHR : VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR);

/// `VkRayTracingShaderGroupCreateInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkRayTracingShaderGroupCreateInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub r#type: VkRayTracingShaderGroupTypeKHR,
    pub generalShader: uint32_t,
    pub closestHitShader: uint32_t,
    pub anyHitShader: uint32_t,
    pub intersectionShader: uint32_t,
    pub pShaderGroupCaptureReplayHandle: *const void,
}
impl_default_zeroed_with_s_type!(VkRayTracingShaderGroupCreateInfoKHR : VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR);

/// `VkRayTracingShaderGroupCreateInfoNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkRayTracingShaderGroupCreateInfoNV {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub r#type: VkRayTracingShaderGroupTypeKHR,
    pub generalShader: uint32_t,
    pub closestHitShader: uint32_t,
    pub anyHitShader: uint32_t,
    pub intersectionShader: uint32_t,
}
impl_default_zeroed_with_s_type!(VkRayTracingShaderGroupCreateInfoNV : VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV);

from_into_transparent!(VkRayTracingShaderGroupTypeKHR: i32);
/// `VkRayTracingShaderGroupTypeKHR`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkRayTracingShaderGroupTypeKHR(pub i32);

/// `0`  
pub const VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_KHR: VkRayTracingShaderGroupTypeKHR = VkRayTracingShaderGroupTypeKHR(0);
/// `1`  
pub const VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_KHR: VkRayTracingShaderGroupTypeKHR = VkRayTracingShaderGroupTypeKHR(1);
/// `2`  
pub const VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_KHR: VkRayTracingShaderGroupTypeKHR = VkRayTracingShaderGroupTypeKHR(2);
/// `VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_KHR`  
pub const VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_NV: VkRayTracingShaderGroupTypeKHR = VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_KHR;
/// `VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_KHR`  
pub const VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_NV: VkRayTracingShaderGroupTypeKHR = VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_KHR;
/// `VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_KHR`  
pub const VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_NV: VkRayTracingShaderGroupTypeKHR = VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_KHR;

impl_enum_display!(VkRayTracingShaderGroupTypeKHR { VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_KHR, VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_KHR, VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_KHR, VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_NV, VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_NV, VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_NV });

/// `VkRayTracingShaderGroupTypeKHR`
pub type VkRayTracingShaderGroupTypeNV = VkRayTracingShaderGroupTypeKHR;

/// `VkRect2D`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkRect2D {
    pub offset: VkOffset2D,
    pub extent: VkExtent2D,
}
impl_default_zeroed!(VkRect2D);

/// `VkRectLayerKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkRectLayerKHR {
    /// upper-left corner of a rectangle that has not changed, in pixels of a presentation images
    pub offset: VkOffset2D,
    /// Dimensions of a rectangle that has not changed, in pixels of a presentation images
    pub extent: VkExtent2D,
    /// Layer of a swapchain's image(s), for stereoscopic-3D images
    pub layer: uint32_t,
}
impl_default_zeroed!(VkRectLayerKHR);

/// `VkRefreshCycleDurationGOOGLE`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkRefreshCycleDurationGOOGLE {
    /// Number of nanoseconds from the start of one refresh cycle to the next
    pub refreshDuration: uint64_t,
}
impl_default_zeroed!(VkRefreshCycleDurationGOOGLE);

flags!(VkRefreshObjectFlagsKHR);
from_into_transparent!(VkRefreshObjectFlagsKHR: i32);
/// `VkRefreshObjectFlagsKHR`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkRefreshObjectFlagsKHR(pub i32);

impl_flags_display!(VkRefreshObjectFlagsKHR {  });

/// `VkRefreshObjectKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkRefreshObjectKHR {
    pub objectType: VkObjectType,
    pub objectHandle: uint64_t,
    pub flags: VkRefreshObjectFlagsKHR,
}
impl_default_zeroed!(VkRefreshObjectKHR);

/// `VkRefreshObjectListKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkRefreshObjectListKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub objectCount: uint32_t,
    pub pObjects: *const VkRefreshObjectKHR,
}
impl_default_zeroed_with_s_type!(VkRefreshObjectListKHR : VK_STRUCTURE_TYPE_REFRESH_OBJECT_LIST_KHR);

/// `VkReleaseCapturedPipelineDataInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkReleaseCapturedPipelineDataInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub pipeline: VkPipeline,
}
impl_default_zeroed_with_s_type!(VkReleaseCapturedPipelineDataInfoKHR : VK_STRUCTURE_TYPE_RELEASE_CAPTURED_PIPELINE_DATA_INFO_KHR);

/// `VkReleaseSwapchainImagesInfoKHR`
pub type VkReleaseSwapchainImagesInfoEXT = VkReleaseSwapchainImagesInfoKHR;

/// `VkReleaseSwapchainImagesInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkReleaseSwapchainImagesInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    /// Swapchain for which images are being released
    pub swapchain: VkSwapchainKHR,
    /// Number of indices to release
    pub imageIndexCount: uint32_t,
    /// Indices of which presentable images to release
    pub pImageIndices: *const uint32_t,
}
impl_default_zeroed_with_s_type!(VkReleaseSwapchainImagesInfoKHR : VK_STRUCTURE_TYPE_RELEASE_SWAPCHAIN_IMAGES_INFO_KHR);

/// `VkRenderPass` : `VkDevice`
#[repr(transparent)]
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkRenderPass(pub u64);
from_into_transparent!(VkRenderPass: u64);
impl_handle!(VkRenderPass: VK_OBJECT_TYPE_RENDER_PASS; SubHandle = VkDevice);

/// `VkRenderPassAttachmentBeginInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkRenderPassAttachmentBeginInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub attachmentCount: uint32_t,
    pub pAttachments: *const VkImageView,
}
impl_default_zeroed_with_s_type!(VkRenderPassAttachmentBeginInfo : VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO);
impl_extends!(VkRenderPassAttachmentBeginInfo : VkRenderPassBeginInfo);

/// `VkRenderPassAttachmentBeginInfo`
pub type VkRenderPassAttachmentBeginInfoKHR = VkRenderPassAttachmentBeginInfo;

/// `VkRenderPassBeginInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkRenderPassBeginInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub renderPass: VkRenderPass,
    pub framebuffer: VkFramebuffer,
    pub renderArea: VkRect2D,
    pub clearValueCount: uint32_t,
    pub pClearValues: *const VkClearValue,
}
impl_default_zeroed_with_s_type!(VkRenderPassBeginInfo : VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO);

flags!(VkRenderPassCreateFlags);
from_into_transparent!(VkRenderPassCreateFlags: i32);
/// `VkRenderPassCreateFlags`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkRenderPassCreateFlags(pub i32);

/// `1 << 3`  
pub const VK_RENDER_PASS_CREATE_RESERVED_3_BIT_IMG: VkRenderPassCreateFlags = VkRenderPassCreateFlags(1 << 3);
/// `1 << 0`  
pub const VK_RENDER_PASS_CREATE_RESERVED_0_BIT_KHR: VkRenderPassCreateFlags = VkRenderPassCreateFlags(1 << 0);
/// `1 << 1`  
pub const VK_RENDER_PASS_CREATE_TRANSFORM_BIT_QCOM: VkRenderPassCreateFlags = VkRenderPassCreateFlags(1 << 1);
/// `1 << 2`  
pub const VK_RENDER_PASS_CREATE_PER_LAYER_FRAGMENT_DENSITY_BIT_VALVE: VkRenderPassCreateFlags = VkRenderPassCreateFlags(1 << 2);

impl_flags_display!(VkRenderPassCreateFlags { VK_RENDER_PASS_CREATE_RESERVED_3_BIT_IMG, VK_RENDER_PASS_CREATE_RESERVED_0_BIT_KHR, VK_RENDER_PASS_CREATE_TRANSFORM_BIT_QCOM, VK_RENDER_PASS_CREATE_PER_LAYER_FRAGMENT_DENSITY_BIT_VALVE });

/// `VkRenderPassCreateInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkRenderPassCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub flags: VkRenderPassCreateFlags,
    pub attachmentCount: uint32_t,
    pub pAttachments: *const VkAttachmentDescription,
    pub subpassCount: uint32_t,
    pub pSubpasses: *const VkSubpassDescription,
    pub dependencyCount: uint32_t,
    pub pDependencies: *const VkSubpassDependency,
}
impl_default_zeroed_with_s_type!(VkRenderPassCreateInfo : VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO);

/// `VkRenderPassCreateInfo2`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkRenderPassCreateInfo2 {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub flags: VkRenderPassCreateFlags,
    pub attachmentCount: uint32_t,
    pub pAttachments: *const VkAttachmentDescription2,
    pub subpassCount: uint32_t,
    pub pSubpasses: *const VkSubpassDescription2,
    pub dependencyCount: uint32_t,
    pub pDependencies: *const VkSubpassDependency2,
    pub correlatedViewMaskCount: uint32_t,
    pub pCorrelatedViewMasks: *const uint32_t,
}
impl_default_zeroed_with_s_type!(VkRenderPassCreateInfo2 : VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2);

/// `VkRenderPassCreateInfo2`
pub type VkRenderPassCreateInfo2KHR = VkRenderPassCreateInfo2;

/// `VkRenderPassCreationControlEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkRenderPassCreationControlEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub disallowMerging: VkBool32,
}
impl_default_zeroed_with_s_type!(VkRenderPassCreationControlEXT : VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_CONTROL_EXT);
impl_extends!(VkRenderPassCreationControlEXT : VkRenderPassCreateInfo2, VkSubpassDescription2);

/// `VkRenderPassCreationFeedbackCreateInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkRenderPassCreationFeedbackCreateInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub pRenderPassFeedback: *mut VkRenderPassCreationFeedbackInfoEXT,
}
impl_default_zeroed_with_s_type!(VkRenderPassCreationFeedbackCreateInfoEXT : VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT);
impl_extends!(VkRenderPassCreationFeedbackCreateInfoEXT : VkRenderPassCreateInfo2);

/// `VkRenderPassCreationFeedbackInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkRenderPassCreationFeedbackInfoEXT {
    pub postMergeSubpassCount: uint32_t,
}
impl_default_zeroed!(VkRenderPassCreationFeedbackInfoEXT);

/// `VkRenderPassFragmentDensityMapCreateInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkRenderPassFragmentDensityMapCreateInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub fragmentDensityMapAttachment: VkAttachmentReference,
}
impl_default_zeroed_with_s_type!(VkRenderPassFragmentDensityMapCreateInfoEXT : VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT);
impl_extends!(VkRenderPassFragmentDensityMapCreateInfoEXT : VkRenderPassCreateInfo, VkRenderPassCreateInfo2);

/// `VkRenderPassFragmentDensityMapOffsetEndInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkRenderPassFragmentDensityMapOffsetEndInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub fragmentDensityOffsetCount: uint32_t,
    pub pFragmentDensityOffsets: *const VkOffset2D,
}
impl_default_zeroed_with_s_type!(VkRenderPassFragmentDensityMapOffsetEndInfoEXT : VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_EXT);
impl_extends!(VkRenderPassFragmentDensityMapOffsetEndInfoEXT : VkSubpassEndInfo, VkRenderingEndInfoKHR);

/// `VkRenderPassInputAttachmentAspectCreateInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkRenderPassInputAttachmentAspectCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub aspectReferenceCount: uint32_t,
    pub pAspectReferences: *const VkInputAttachmentAspectReference,
}
impl_default_zeroed_with_s_type!(VkRenderPassInputAttachmentAspectCreateInfo : VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO);
impl_extends!(VkRenderPassInputAttachmentAspectCreateInfo : VkRenderPassCreateInfo);

/// `VkRenderPassInputAttachmentAspectCreateInfo`
pub type VkRenderPassInputAttachmentAspectCreateInfoKHR = VkRenderPassInputAttachmentAspectCreateInfo;

/// `VkRenderPassMultiviewCreateInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkRenderPassMultiviewCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub subpassCount: uint32_t,
    pub pViewMasks: *const uint32_t,
    pub dependencyCount: uint32_t,
    pub pViewOffsets: *const int32_t,
    pub correlationMaskCount: uint32_t,
    pub pCorrelationMasks: *const uint32_t,
}
impl_default_zeroed_with_s_type!(VkRenderPassMultiviewCreateInfo : VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO);
impl_extends!(VkRenderPassMultiviewCreateInfo : VkRenderPassCreateInfo);

/// `VkRenderPassMultiviewCreateInfo`
pub type VkRenderPassMultiviewCreateInfoKHR = VkRenderPassMultiviewCreateInfo;

/// `VkRenderPassPerformanceCountersByRegionBeginInfoARM`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkRenderPassPerformanceCountersByRegionBeginInfoARM {
    pub sType: VkStructureType,
    /// Pointer to next structure
    pub pNext: *mut void,
    pub counterAddressCount: uint32_t,
    pub pCounterAddresses: *const VkDeviceAddress,
    pub serializeRegions: VkBool32,
    pub counterIndexCount: uint32_t,
    pub pCounterIndices: *mut uint32_t,
}
impl_default_zeroed_with_s_type!(VkRenderPassPerformanceCountersByRegionBeginInfoARM : VK_STRUCTURE_TYPE_RENDER_PASS_PERFORMANCE_COUNTERS_BY_REGION_BEGIN_INFO_ARM);
impl_extends!(VkRenderPassPerformanceCountersByRegionBeginInfoARM : VkRenderPassBeginInfo, VkRenderingInfo);

/// `VkRenderPassSampleLocationsBeginInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkRenderPassSampleLocationsBeginInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub attachmentInitialSampleLocationsCount: uint32_t,
    pub pAttachmentInitialSampleLocations: *const VkAttachmentSampleLocationsEXT,
    pub postSubpassSampleLocationsCount: uint32_t,
    pub pPostSubpassSampleLocations: *const VkSubpassSampleLocationsEXT,
}
impl_default_zeroed_with_s_type!(VkRenderPassSampleLocationsBeginInfoEXT : VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT);
impl_extends!(VkRenderPassSampleLocationsBeginInfoEXT : VkRenderPassBeginInfo);

/// `VkRenderPassStripeBeginInfoARM`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkRenderPassStripeBeginInfoARM {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub stripeInfoCount: uint32_t,
    pub pStripeInfos: *const VkRenderPassStripeInfoARM,
}
impl_default_zeroed_with_s_type!(VkRenderPassStripeBeginInfoARM : VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_BEGIN_INFO_ARM);
impl_extends!(VkRenderPassStripeBeginInfoARM : VkRenderingInfo, VkRenderPassBeginInfo);

/// `VkRenderPassStripeInfoARM`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkRenderPassStripeInfoARM {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub stripeArea: VkRect2D,
}
impl_default_zeroed_with_s_type!(VkRenderPassStripeInfoARM : VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_INFO_ARM);

/// `VkRenderPassStripeSubmitInfoARM`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkRenderPassStripeSubmitInfoARM {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub stripeSemaphoreInfoCount: uint32_t,
    pub pStripeSemaphoreInfos: *const VkSemaphoreSubmitInfo,
}
impl_default_zeroed_with_s_type!(VkRenderPassStripeSubmitInfoARM : VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_SUBMIT_INFO_ARM);
impl_extends!(VkRenderPassStripeSubmitInfoARM : VkCommandBufferSubmitInfo);

/// `VkRenderPassSubpassFeedbackCreateInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkRenderPassSubpassFeedbackCreateInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub pSubpassFeedback: *mut VkRenderPassSubpassFeedbackInfoEXT,
}
impl_default_zeroed_with_s_type!(VkRenderPassSubpassFeedbackCreateInfoEXT : VK_STRUCTURE_TYPE_RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT);
impl_extends!(VkRenderPassSubpassFeedbackCreateInfoEXT : VkSubpassDescription2);

/// `VkRenderPassSubpassFeedbackInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkRenderPassSubpassFeedbackInfoEXT {
    pub subpassMergeStatus: VkSubpassMergeStatusEXT,
    pub description: [c_char; VK_MAX_DESCRIPTION_SIZE as usize],
    pub postMergeIndex: uint32_t,
}
impl_default_zeroed!(VkRenderPassSubpassFeedbackInfoEXT);

/// `VkRenderPassTileShadingCreateInfoQCOM`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkRenderPassTileShadingCreateInfoQCOM {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub flags: VkTileShadingRenderPassFlagsQCOM,
    pub tileApronSize: VkExtent2D,
}
impl_default_zeroed_with_s_type!(VkRenderPassTileShadingCreateInfoQCOM : VK_STRUCTURE_TYPE_RENDER_PASS_TILE_SHADING_CREATE_INFO_QCOM);
impl_extends!(VkRenderPassTileShadingCreateInfoQCOM : VkRenderPassCreateInfo, VkRenderPassCreateInfo2, VkRenderingInfo, VkCommandBufferInheritanceInfo);

/// `VkRenderPassTransformBeginInfoQCOM`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkRenderPassTransformBeginInfoQCOM {
    pub sType: VkStructureType,
    /// Pointer to next structure
    pub pNext: *const void,
    pub transform: VkSurfaceTransformFlagsKHR,
}
impl_default_zeroed_with_s_type!(VkRenderPassTransformBeginInfoQCOM : VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM);
impl_extends!(VkRenderPassTransformBeginInfoQCOM : VkRenderPassBeginInfo);

/// `VkRenderingAreaInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkRenderingAreaInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub viewMask: uint32_t,
    pub colorAttachmentCount: uint32_t,
    pub pColorAttachmentFormats: *const VkFormat,
    pub depthAttachmentFormat: VkFormat,
    pub stencilAttachmentFormat: VkFormat,
}
impl_default_zeroed_with_s_type!(VkRenderingAreaInfo : VK_STRUCTURE_TYPE_RENDERING_AREA_INFO);

/// `VkRenderingAreaInfo`
pub type VkRenderingAreaInfoKHR = VkRenderingAreaInfo;

/// `VkRenderingAttachmentFlagsInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkRenderingAttachmentFlagsInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub flags: VkRenderingAttachmentFlagsKHR,
}
impl_default_zeroed_with_s_type!(VkRenderingAttachmentFlagsInfoKHR : VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_FLAGS_INFO_KHR);
impl_extends!(VkRenderingAttachmentFlagsInfoKHR : VkRenderingAttachmentInfo);

flags!(VkRenderingAttachmentFlagsKHR);
from_into_transparent!(VkRenderingAttachmentFlagsKHR: i32);
/// `VkRenderingAttachmentFlagsKHR`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkRenderingAttachmentFlagsKHR(pub i32);

/// `1 << 0`  
pub const VK_RENDERING_ATTACHMENT_INPUT_ATTACHMENT_FEEDBACK_BIT_KHR: VkRenderingAttachmentFlagsKHR = VkRenderingAttachmentFlagsKHR(1 << 0);
/// `1 << 1`  
pub const VK_RENDERING_ATTACHMENT_RESOLVE_SKIP_TRANSFER_FUNCTION_BIT_KHR: VkRenderingAttachmentFlagsKHR = VkRenderingAttachmentFlagsKHR(1 << 1);
/// `1 << 2`  
pub const VK_RENDERING_ATTACHMENT_RESOLVE_ENABLE_TRANSFER_FUNCTION_BIT_KHR: VkRenderingAttachmentFlagsKHR = VkRenderingAttachmentFlagsKHR(1 << 2);

impl_flags_display!(VkRenderingAttachmentFlagsKHR { VK_RENDERING_ATTACHMENT_INPUT_ATTACHMENT_FEEDBACK_BIT_KHR, VK_RENDERING_ATTACHMENT_RESOLVE_SKIP_TRANSFER_FUNCTION_BIT_KHR, VK_RENDERING_ATTACHMENT_RESOLVE_ENABLE_TRANSFER_FUNCTION_BIT_KHR });

/// `VkRenderingAttachmentInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkRenderingAttachmentInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub imageView: VkImageView,
    pub imageLayout: VkImageLayout,
    pub resolveMode: VkResolveModeFlags,
    pub resolveImageView: VkImageView,
    pub resolveImageLayout: VkImageLayout,
    pub loadOp: VkAttachmentLoadOp,
    pub storeOp: VkAttachmentStoreOp,
    pub clearValue: VkClearValue,
}
impl_default_zeroed_with_s_type!(VkRenderingAttachmentInfo : VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO);

/// `VkRenderingAttachmentInfo`
pub type VkRenderingAttachmentInfoKHR = VkRenderingAttachmentInfo;

/// `VkRenderingAttachmentLocationInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkRenderingAttachmentLocationInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub colorAttachmentCount: uint32_t,
    pub pColorAttachmentLocations: *const uint32_t,
}
impl_default_zeroed_with_s_type!(VkRenderingAttachmentLocationInfo : VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO);
impl_extends!(VkRenderingAttachmentLocationInfo : VkGraphicsPipelineCreateInfo, VkCommandBufferInheritanceInfo);

/// `VkRenderingAttachmentLocationInfo`
pub type VkRenderingAttachmentLocationInfoKHR = VkRenderingAttachmentLocationInfo;

/// `VkRenderingEndInfoKHR`
pub type VkRenderingEndInfoEXT = VkRenderingEndInfoKHR;

/// `VkRenderingEndInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkRenderingEndInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
}
impl_default_zeroed_with_s_type!(VkRenderingEndInfoKHR : VK_STRUCTURE_TYPE_RENDERING_END_INFO_KHR);

flags!(VkRenderingFlags);
from_into_transparent!(VkRenderingFlags: i32);
/// `VkRenderingFlags`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkRenderingFlags(pub i32);

/// `1 << 0`  
pub const VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT: VkRenderingFlags = VkRenderingFlags(1 << 0);
/// `1 << 1`  
pub const VK_RENDERING_SUSPENDING_BIT: VkRenderingFlags = VkRenderingFlags(1 << 1);
/// `1 << 2`  
pub const VK_RENDERING_RESUMING_BIT: VkRenderingFlags = VkRenderingFlags(1 << 2);
/// `VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT`  
pub const VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT_KHR: VkRenderingFlags = VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT;
/// `VK_RENDERING_SUSPENDING_BIT`  
pub const VK_RENDERING_SUSPENDING_BIT_KHR: VkRenderingFlags = VK_RENDERING_SUSPENDING_BIT;
/// `VK_RENDERING_RESUMING_BIT`  
pub const VK_RENDERING_RESUMING_BIT_KHR: VkRenderingFlags = VK_RENDERING_RESUMING_BIT;
/// `1 << 9`  
pub const VK_RENDERING_RESERVED_9_BIT_IMG: VkRenderingFlags = VkRenderingFlags(1 << 9);
/// `VK_RENDERING_CONTENTS_INLINE_BIT_KHR`  
pub const VK_RENDERING_CONTENTS_INLINE_BIT_EXT: VkRenderingFlags = VK_RENDERING_CONTENTS_INLINE_BIT_KHR;
/// `1 << 3`  
pub const VK_RENDERING_ENABLE_LEGACY_DITHERING_BIT_EXT: VkRenderingFlags = VkRenderingFlags(1 << 3);
/// `1 << 4`  
/// 
/// Promoted from extension 452
pub const VK_RENDERING_CONTENTS_INLINE_BIT_KHR: VkRenderingFlags = VkRenderingFlags(1 << 4);
/// `1 << 5`  
pub const VK_RENDERING_PER_LAYER_FRAGMENT_DENSITY_BIT_VALVE: VkRenderingFlags = VkRenderingFlags(1 << 5);
/// `1 << 6`  
pub const VK_RENDERING_FRAGMENT_REGION_BIT_EXT: VkRenderingFlags = VkRenderingFlags(1 << 6);
/// `1 << 7`  
pub const VK_RENDERING_CUSTOM_RESOLVE_BIT_EXT: VkRenderingFlags = VkRenderingFlags(1 << 7);
/// `1 << 8`  
pub const VK_RENDERING_LOCAL_READ_CONCURRENT_ACCESS_CONTROL_BIT_KHR: VkRenderingFlags = VkRenderingFlags(1 << 8);

impl_flags_display!(VkRenderingFlags { VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT, VK_RENDERING_SUSPENDING_BIT, VK_RENDERING_RESUMING_BIT, VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT_KHR, VK_RENDERING_SUSPENDING_BIT_KHR, VK_RENDERING_RESUMING_BIT_KHR, VK_RENDERING_RESERVED_9_BIT_IMG, VK_RENDERING_CONTENTS_INLINE_BIT_EXT, VK_RENDERING_ENABLE_LEGACY_DITHERING_BIT_EXT, VK_RENDERING_CONTENTS_INLINE_BIT_KHR, VK_RENDERING_PER_LAYER_FRAGMENT_DENSITY_BIT_VALVE, VK_RENDERING_FRAGMENT_REGION_BIT_EXT, VK_RENDERING_CUSTOM_RESOLVE_BIT_EXT, VK_RENDERING_LOCAL_READ_CONCURRENT_ACCESS_CONTROL_BIT_KHR });

/// `VkRenderingFlags`
pub type VkRenderingFlagsKHR = VkRenderingFlags;

/// `VkRenderingFragmentDensityMapAttachmentInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkRenderingFragmentDensityMapAttachmentInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub imageView: VkImageView,
    pub imageLayout: VkImageLayout,
}
impl_default_zeroed_with_s_type!(VkRenderingFragmentDensityMapAttachmentInfoEXT : VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT);
impl_extends!(VkRenderingFragmentDensityMapAttachmentInfoEXT : VkRenderingInfo);

/// `VkRenderingFragmentShadingRateAttachmentInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkRenderingFragmentShadingRateAttachmentInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub imageView: VkImageView,
    pub imageLayout: VkImageLayout,
    pub shadingRateAttachmentTexelSize: VkExtent2D,
}
impl_default_zeroed_with_s_type!(VkRenderingFragmentShadingRateAttachmentInfoKHR : VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR);
impl_extends!(VkRenderingFragmentShadingRateAttachmentInfoKHR : VkRenderingInfo);

/// `VkRenderingInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkRenderingInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub flags: VkRenderingFlags,
    pub renderArea: VkRect2D,
    pub layerCount: uint32_t,
    pub viewMask: uint32_t,
    pub colorAttachmentCount: uint32_t,
    pub pColorAttachments: *const VkRenderingAttachmentInfo,
    pub pDepthAttachment: *const VkRenderingAttachmentInfo,
    pub pStencilAttachment: *const VkRenderingAttachmentInfo,
}
impl_default_zeroed_with_s_type!(VkRenderingInfo : VK_STRUCTURE_TYPE_RENDERING_INFO);

/// `VkRenderingInfo`
pub type VkRenderingInfoKHR = VkRenderingInfo;

/// `VkRenderingInputAttachmentIndexInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkRenderingInputAttachmentIndexInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub colorAttachmentCount: uint32_t,
    pub pColorAttachmentInputIndices: *const uint32_t,
    pub pDepthInputAttachmentIndex: *const uint32_t,
    pub pStencilInputAttachmentIndex: *const uint32_t,
}
impl_default_zeroed_with_s_type!(VkRenderingInputAttachmentIndexInfo : VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO);
impl_extends!(VkRenderingInputAttachmentIndexInfo : VkGraphicsPipelineCreateInfo, VkCommandBufferInheritanceInfo);

/// `VkRenderingInputAttachmentIndexInfo`
pub type VkRenderingInputAttachmentIndexInfoKHR = VkRenderingInputAttachmentIndexInfo;

flags!(VkResolveImageFlagsKHR);
from_into_transparent!(VkResolveImageFlagsKHR: i32);
/// `VkResolveImageFlagsKHR`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkResolveImageFlagsKHR(pub i32);

/// `1 << 0`  
pub const VK_RESOLVE_IMAGE_SKIP_TRANSFER_FUNCTION_BIT_KHR: VkResolveImageFlagsKHR = VkResolveImageFlagsKHR(1 << 0);
/// `1 << 1`  
pub const VK_RESOLVE_IMAGE_ENABLE_TRANSFER_FUNCTION_BIT_KHR: VkResolveImageFlagsKHR = VkResolveImageFlagsKHR(1 << 1);

impl_flags_display!(VkResolveImageFlagsKHR { VK_RESOLVE_IMAGE_SKIP_TRANSFER_FUNCTION_BIT_KHR, VK_RESOLVE_IMAGE_ENABLE_TRANSFER_FUNCTION_BIT_KHR });

/// `VkResolveImageInfo2`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkResolveImageInfo2 {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub srcImage: VkImage,
    pub srcImageLayout: VkImageLayout,
    pub dstImage: VkImage,
    pub dstImageLayout: VkImageLayout,
    pub regionCount: uint32_t,
    pub pRegions: *const VkImageResolve2,
}
impl_default_zeroed_with_s_type!(VkResolveImageInfo2 : VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2);

/// `VkResolveImageInfo2`
pub type VkResolveImageInfo2KHR = VkResolveImageInfo2;

/// `VkResolveImageModeInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkResolveImageModeInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub flags: VkResolveImageFlagsKHR,
    pub resolveMode: VkResolveModeFlags,
    pub stencilResolveMode: VkResolveModeFlags,
}
impl_default_zeroed_with_s_type!(VkResolveImageModeInfoKHR : VK_STRUCTURE_TYPE_RESOLVE_IMAGE_MODE_INFO_KHR);
impl_extends!(VkResolveImageModeInfoKHR : VkResolveImageInfo2);

flags!(VkResolveModeFlags);
from_into_transparent!(VkResolveModeFlags: i32);
/// `VkResolveModeFlags`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkResolveModeFlags(pub i32);

/// `0`  
pub const VK_RESOLVE_MODE_NONE: VkResolveModeFlags = VkResolveModeFlags(0);
/// `1 << 0`  
pub const VK_RESOLVE_MODE_SAMPLE_ZERO_BIT: VkResolveModeFlags = VkResolveModeFlags(1 << 0);
/// `1 << 1`  
pub const VK_RESOLVE_MODE_AVERAGE_BIT: VkResolveModeFlags = VkResolveModeFlags(1 << 1);
/// `1 << 2`  
pub const VK_RESOLVE_MODE_MIN_BIT: VkResolveModeFlags = VkResolveModeFlags(1 << 2);
/// `1 << 3`  
pub const VK_RESOLVE_MODE_MAX_BIT: VkResolveModeFlags = VkResolveModeFlags(1 << 3);
/// `VK_RESOLVE_MODE_NONE`  
pub const VK_RESOLVE_MODE_NONE_KHR: VkResolveModeFlags = VK_RESOLVE_MODE_NONE;
/// `VK_RESOLVE_MODE_SAMPLE_ZERO_BIT`  
pub const VK_RESOLVE_MODE_SAMPLE_ZERO_BIT_KHR: VkResolveModeFlags = VK_RESOLVE_MODE_SAMPLE_ZERO_BIT;
/// `VK_RESOLVE_MODE_AVERAGE_BIT`  
pub const VK_RESOLVE_MODE_AVERAGE_BIT_KHR: VkResolveModeFlags = VK_RESOLVE_MODE_AVERAGE_BIT;
/// `VK_RESOLVE_MODE_MIN_BIT`  
pub const VK_RESOLVE_MODE_MIN_BIT_KHR: VkResolveModeFlags = VK_RESOLVE_MODE_MIN_BIT;
/// `VK_RESOLVE_MODE_MAX_BIT`  
pub const VK_RESOLVE_MODE_MAX_BIT_KHR: VkResolveModeFlags = VK_RESOLVE_MODE_MAX_BIT;
/// `1 << 4`  
pub const VK_RESOLVE_MODE_EXTERNAL_FORMAT_DOWNSAMPLE_BIT_ANDROID: VkResolveModeFlags = VkResolveModeFlags(1 << 4);
/// `VK_RESOLVE_MODE_EXTERNAL_FORMAT_DOWNSAMPLE_BIT_ANDROID`  
pub const VK_RESOLVE_MODE_EXTERNAL_FORMAT_DOWNSAMPLE_ANDROID: VkResolveModeFlags = VK_RESOLVE_MODE_EXTERNAL_FORMAT_DOWNSAMPLE_BIT_ANDROID;
/// `1 << 5`  
pub const VK_RESOLVE_MODE_CUSTOM_BIT_EXT: VkResolveModeFlags = VkResolveModeFlags(1 << 5);

impl_flags_display!(VkResolveModeFlags { VK_RESOLVE_MODE_NONE, VK_RESOLVE_MODE_SAMPLE_ZERO_BIT, VK_RESOLVE_MODE_AVERAGE_BIT, VK_RESOLVE_MODE_MIN_BIT, VK_RESOLVE_MODE_MAX_BIT, VK_RESOLVE_MODE_NONE_KHR, VK_RESOLVE_MODE_SAMPLE_ZERO_BIT_KHR, VK_RESOLVE_MODE_AVERAGE_BIT_KHR, VK_RESOLVE_MODE_MIN_BIT_KHR, VK_RESOLVE_MODE_MAX_BIT_KHR, VK_RESOLVE_MODE_EXTERNAL_FORMAT_DOWNSAMPLE_BIT_ANDROID, VK_RESOLVE_MODE_EXTERNAL_FORMAT_DOWNSAMPLE_ANDROID, VK_RESOLVE_MODE_CUSTOM_BIT_EXT });

/// `VkResolveModeFlags`
pub type VkResolveModeFlagsKHR = VkResolveModeFlags;

/// `VkResourceDescriptorDataEXT`
#[repr(C)]
#[derive(Clone, Copy)]
pub union VkResourceDescriptorDataEXT {
    pub pImage: *const VkImageDescriptorInfoEXT,
    pub pTexelBuffer: *const VkTexelBufferDescriptorInfoEXT,
    pub pAddressRange: *const VkDeviceAddressRangeEXT,
    pub pTensorARM: *const VkTensorViewCreateInfoARM,
}
impl_debug_for_union!(VkResourceDescriptorDataEXT);
impl_default_zeroed!(VkResourceDescriptorDataEXT);

/// `VkResourceDescriptorInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkResourceDescriptorInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub r#type: VkDescriptorType,
    pub data: VkResourceDescriptorDataEXT,
}
impl_default_zeroed_with_s_type!(VkResourceDescriptorInfoEXT : VK_STRUCTURE_TYPE_RESOURCE_DESCRIPTOR_INFO_EXT);

from_into_transparent!(VkResult: i32);
/// `VkResult`
/// 
/// API result codes
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkResult(pub i32);

/// `0`  
/// 
/// Command completed successfully
pub const VK_SUCCESS: VkResult = VkResult(0);
/// `1`  
/// 
/// A fence or query has not yet completed
pub const VK_NOT_READY: VkResult = VkResult(1);
/// `2`  
/// 
/// A wait operation has not completed in the specified time
pub const VK_TIMEOUT: VkResult = VkResult(2);
/// `3`  
/// 
/// An event is signaled
pub const VK_EVENT_SET: VkResult = VkResult(3);
/// `4`  
/// 
/// An event is unsignaled
pub const VK_EVENT_RESET: VkResult = VkResult(4);
/// `5`  
/// 
/// A return array was too small for the result
pub const VK_INCOMPLETE: VkResult = VkResult(5);
/// `-1`  
/// 
/// A host memory allocation has failed
pub const VK_ERROR_OUT_OF_HOST_MEMORY: VkResult = VkResult(-1);
/// `-2`  
/// 
/// A device memory allocation has failed
pub const VK_ERROR_OUT_OF_DEVICE_MEMORY: VkResult = VkResult(-2);
/// `-3`  
/// 
/// Initialization of an object has failed
pub const VK_ERROR_INITIALIZATION_FAILED: VkResult = VkResult(-3);
/// `-4`  
/// 
/// The logical device has been lost. See devsandqueues-lost-device
pub const VK_ERROR_DEVICE_LOST: VkResult = VkResult(-4);
/// `-5`  
/// 
/// Mapping of a memory object has failed
pub const VK_ERROR_MEMORY_MAP_FAILED: VkResult = VkResult(-5);
/// `-6`  
/// 
/// Layer specified does not exist
pub const VK_ERROR_LAYER_NOT_PRESENT: VkResult = VkResult(-6);
/// `-7`  
/// 
/// Extension specified does not exist
pub const VK_ERROR_EXTENSION_NOT_PRESENT: VkResult = VkResult(-7);
/// `-8`  
/// 
/// Requested feature is not available on this device
pub const VK_ERROR_FEATURE_NOT_PRESENT: VkResult = VkResult(-8);
/// `-9`  
/// 
/// Unable to find a Vulkan driver
pub const VK_ERROR_INCOMPATIBLE_DRIVER: VkResult = VkResult(-9);
/// `-10`  
/// 
/// Too many objects of the type have already been created
pub const VK_ERROR_TOO_MANY_OBJECTS: VkResult = VkResult(-10);
/// `-11`  
/// 
/// Requested format is not supported on this device
pub const VK_ERROR_FORMAT_NOT_SUPPORTED: VkResult = VkResult(-11);
/// `-12`  
/// 
/// A requested pool allocation has failed due to fragmentation of the pool's memory
pub const VK_ERROR_FRAGMENTED_POOL: VkResult = VkResult(-12);
/// `-13`  
/// 
/// An unknown error has occurred, due to an implementation or application bug
pub const VK_ERROR_UNKNOWN: VkResult = VkResult(-13);
/// `-1000011001`  
pub const VK_ERROR_VALIDATION_FAILED: VkResult = VkResult(-1000011001);
/// `-1000069000`  
pub const VK_ERROR_OUT_OF_POOL_MEMORY: VkResult = VkResult(-1000069000);
/// `-1000072003`  
pub const VK_ERROR_INVALID_EXTERNAL_HANDLE: VkResult = VkResult(-1000072003);
/// `-1000257000`  
pub const VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS: VkResult = VkResult(-1000257000);
/// `-1000161000`  
pub const VK_ERROR_FRAGMENTATION: VkResult = VkResult(-1000161000);
/// `1000297000`  
pub const VK_PIPELINE_COMPILE_REQUIRED: VkResult = VkResult(1000297000);
/// `-1000174001`  
pub const VK_ERROR_NOT_PERMITTED: VkResult = VkResult(-1000174001);
/// `-1000298000`  
pub const VK_ERROR_INVALID_PIPELINE_CACHE_DATA: VkResult = VkResult(-1000298000);
/// `-1000298001`  
pub const VK_ERROR_NO_PIPELINE_MATCH: VkResult = VkResult(-1000298001);
/// `-1000000000`  
pub const VK_ERROR_SURFACE_LOST_KHR: VkResult = VkResult(-1000000000);
/// `-1000000001`  
pub const VK_ERROR_NATIVE_WINDOW_IN_USE_KHR: VkResult = VkResult(-1000000001);
/// `1000001003`  
pub const VK_SUBOPTIMAL_KHR: VkResult = VkResult(1000001003);
/// `-1000001004`  
pub const VK_ERROR_OUT_OF_DATE_KHR: VkResult = VkResult(-1000001004);
/// `-1000003001`  
pub const VK_ERROR_INCOMPATIBLE_DISPLAY_KHR: VkResult = VkResult(-1000003001);
/// `VK_ERROR_VALIDATION_FAILED`  
pub const VK_ERROR_VALIDATION_FAILED_EXT: VkResult = VK_ERROR_VALIDATION_FAILED;
/// `-1000012000`  
pub const VK_ERROR_INVALID_SHADER_NV: VkResult = VkResult(-1000012000);
/// `-1000023000`  
pub const VK_ERROR_IMAGE_USAGE_NOT_SUPPORTED_KHR: VkResult = VkResult(-1000023000);
/// `-1000023001`  
pub const VK_ERROR_VIDEO_PICTURE_LAYOUT_NOT_SUPPORTED_KHR: VkResult = VkResult(-1000023001);
/// `-1000023002`  
pub const VK_ERROR_VIDEO_PROFILE_OPERATION_NOT_SUPPORTED_KHR: VkResult = VkResult(-1000023002);
/// `-1000023003`  
pub const VK_ERROR_VIDEO_PROFILE_FORMAT_NOT_SUPPORTED_KHR: VkResult = VkResult(-1000023003);
/// `-1000023004`  
pub const VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR: VkResult = VkResult(-1000023004);
/// `-1000023005`  
pub const VK_ERROR_VIDEO_STD_VERSION_NOT_SUPPORTED_KHR: VkResult = VkResult(-1000023005);
/// `VK_ERROR_OUT_OF_POOL_MEMORY`  
pub const VK_ERROR_OUT_OF_POOL_MEMORY_KHR: VkResult = VK_ERROR_OUT_OF_POOL_MEMORY;
/// `VK_ERROR_INVALID_EXTERNAL_HANDLE`  
pub const VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR: VkResult = VK_ERROR_INVALID_EXTERNAL_HANDLE;
/// `-1000158000`  
pub const VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT: VkResult = VkResult(-1000158000);
/// `VK_ERROR_FRAGMENTATION`  
pub const VK_ERROR_FRAGMENTATION_EXT: VkResult = VK_ERROR_FRAGMENTATION;
/// `VK_ERROR_NOT_PERMITTED`  
pub const VK_ERROR_NOT_PERMITTED_EXT: VkResult = VK_ERROR_NOT_PERMITTED;
/// `VK_ERROR_NOT_PERMITTED`  
pub const VK_ERROR_NOT_PERMITTED_KHR: VkResult = VK_ERROR_NOT_PERMITTED;
/// `-1000208000`  
pub const VK_ERROR_PRESENT_TIMING_QUEUE_FULL_EXT: VkResult = VkResult(-1000208000);
/// `VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS`  
pub const VK_ERROR_INVALID_DEVICE_ADDRESS_EXT: VkResult = VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS;
/// `-1000255000`  
pub const VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT: VkResult = VkResult(-1000255000);
/// `VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS`  
pub const VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS_KHR: VkResult = VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS;
/// `1000268000`  
pub const VK_THREAD_IDLE_KHR: VkResult = VkResult(1000268000);
/// `1000268001`  
pub const VK_THREAD_DONE_KHR: VkResult = VkResult(1000268001);
/// `1000268002`  
pub const VK_OPERATION_DEFERRED_KHR: VkResult = VkResult(1000268002);
/// `1000268003`  
pub const VK_OPERATION_NOT_DEFERRED_KHR: VkResult = VkResult(1000268003);
/// `VK_PIPELINE_COMPILE_REQUIRED`  
pub const VK_PIPELINE_COMPILE_REQUIRED_EXT: VkResult = VK_PIPELINE_COMPILE_REQUIRED;
/// `VK_PIPELINE_COMPILE_REQUIRED`  
pub const VK_ERROR_PIPELINE_COMPILE_REQUIRED_EXT: VkResult = VK_PIPELINE_COMPILE_REQUIRED;
/// `-1000299000`  
pub const VK_ERROR_INVALID_VIDEO_STD_PARAMETERS_KHR: VkResult = VkResult(-1000299000);
/// `-1000338000`  
pub const VK_ERROR_COMPRESSION_EXHAUSTED_EXT: VkResult = VkResult(-1000338000);
/// `1000482000`  
pub const VK_INCOMPATIBLE_SHADER_BINARY_EXT: VkResult = VkResult(1000482000);
/// `VK_INCOMPATIBLE_SHADER_BINARY_EXT`  
pub const VK_ERROR_INCOMPATIBLE_SHADER_BINARY_EXT: VkResult = VK_INCOMPATIBLE_SHADER_BINARY_EXT;
/// `1000483000`  
pub const VK_PIPELINE_BINARY_MISSING_KHR: VkResult = VkResult(1000483000);
/// `-1000483000`  
pub const VK_ERROR_NOT_ENOUGH_SPACE_KHR: VkResult = VkResult(-1000483000);

impl_enum_display!(VkResult { VK_SUCCESS, VK_NOT_READY, VK_TIMEOUT, VK_EVENT_SET, VK_EVENT_RESET, VK_INCOMPLETE, VK_ERROR_OUT_OF_HOST_MEMORY, VK_ERROR_OUT_OF_DEVICE_MEMORY, VK_ERROR_INITIALIZATION_FAILED, VK_ERROR_DEVICE_LOST, VK_ERROR_MEMORY_MAP_FAILED, VK_ERROR_LAYER_NOT_PRESENT, VK_ERROR_EXTENSION_NOT_PRESENT, VK_ERROR_FEATURE_NOT_PRESENT, VK_ERROR_INCOMPATIBLE_DRIVER, VK_ERROR_TOO_MANY_OBJECTS, VK_ERROR_FORMAT_NOT_SUPPORTED, VK_ERROR_FRAGMENTED_POOL, VK_ERROR_UNKNOWN, VK_ERROR_VALIDATION_FAILED, VK_ERROR_OUT_OF_POOL_MEMORY, VK_ERROR_INVALID_EXTERNAL_HANDLE, VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS, VK_ERROR_FRAGMENTATION, VK_PIPELINE_COMPILE_REQUIRED, VK_ERROR_NOT_PERMITTED, VK_ERROR_INVALID_PIPELINE_CACHE_DATA, VK_ERROR_NO_PIPELINE_MATCH, VK_ERROR_SURFACE_LOST_KHR, VK_ERROR_NATIVE_WINDOW_IN_USE_KHR, VK_SUBOPTIMAL_KHR, VK_ERROR_OUT_OF_DATE_KHR, VK_ERROR_INCOMPATIBLE_DISPLAY_KHR, VK_ERROR_VALIDATION_FAILED_EXT, VK_ERROR_INVALID_SHADER_NV, VK_ERROR_IMAGE_USAGE_NOT_SUPPORTED_KHR, VK_ERROR_VIDEO_PICTURE_LAYOUT_NOT_SUPPORTED_KHR, VK_ERROR_VIDEO_PROFILE_OPERATION_NOT_SUPPORTED_KHR, VK_ERROR_VIDEO_PROFILE_FORMAT_NOT_SUPPORTED_KHR, VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR, VK_ERROR_VIDEO_STD_VERSION_NOT_SUPPORTED_KHR, VK_ERROR_OUT_OF_POOL_MEMORY_KHR, VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR, VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT, VK_ERROR_FRAGMENTATION_EXT, VK_ERROR_NOT_PERMITTED_EXT, VK_ERROR_NOT_PERMITTED_KHR, VK_ERROR_PRESENT_TIMING_QUEUE_FULL_EXT, VK_ERROR_INVALID_DEVICE_ADDRESS_EXT, VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT, VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS_KHR, VK_THREAD_IDLE_KHR, VK_THREAD_DONE_KHR, VK_OPERATION_DEFERRED_KHR, VK_OPERATION_NOT_DEFERRED_KHR, VK_PIPELINE_COMPILE_REQUIRED_EXT, VK_ERROR_PIPELINE_COMPILE_REQUIRED_EXT, VK_ERROR_INVALID_VIDEO_STD_PARAMETERS_KHR, VK_ERROR_COMPRESSION_EXHAUSTED_EXT, VK_INCOMPATIBLE_SHADER_BINARY_EXT, VK_ERROR_INCOMPATIBLE_SHADER_BINARY_EXT, VK_PIPELINE_BINARY_MISSING_KHR, VK_ERROR_NOT_ENOUGH_SPACE_KHR });

/// `VkSRTDataNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkSRTDataNV {
    pub sx: float,
    pub a: float,
    pub b: float,
    pub pvx: float,
    pub sy: float,
    pub c: float,
    pub pvy: float,
    pub sz: float,
    pub pvz: float,
    pub qx: float,
    pub qy: float,
    pub qz: float,
    pub qw: float,
    pub tx: float,
    pub ty: float,
    pub tz: float,
}
impl_default_zeroed!(VkSRTDataNV);

flags!(VkSampleCountFlags);
from_into_transparent!(VkSampleCountFlags: i32);
/// `VkSampleCountFlags`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkSampleCountFlags(pub i32);

/// `1 << 0`  
/// 
/// Sample count 1 supported
pub const VK_SAMPLE_COUNT_1_BIT: VkSampleCountFlags = VkSampleCountFlags(1 << 0);
/// `1 << 1`  
/// 
/// Sample count 2 supported
pub const VK_SAMPLE_COUNT_2_BIT: VkSampleCountFlags = VkSampleCountFlags(1 << 1);
/// `1 << 2`  
/// 
/// Sample count 4 supported
pub const VK_SAMPLE_COUNT_4_BIT: VkSampleCountFlags = VkSampleCountFlags(1 << 2);
/// `1 << 3`  
/// 
/// Sample count 8 supported
pub const VK_SAMPLE_COUNT_8_BIT: VkSampleCountFlags = VkSampleCountFlags(1 << 3);
/// `1 << 4`  
/// 
/// Sample count 16 supported
pub const VK_SAMPLE_COUNT_16_BIT: VkSampleCountFlags = VkSampleCountFlags(1 << 4);
/// `1 << 5`  
/// 
/// Sample count 32 supported
pub const VK_SAMPLE_COUNT_32_BIT: VkSampleCountFlags = VkSampleCountFlags(1 << 5);
/// `1 << 6`  
/// 
/// Sample count 64 supported
pub const VK_SAMPLE_COUNT_64_BIT: VkSampleCountFlags = VkSampleCountFlags(1 << 6);

impl_flags_display!(VkSampleCountFlags { VK_SAMPLE_COUNT_1_BIT, VK_SAMPLE_COUNT_2_BIT, VK_SAMPLE_COUNT_4_BIT, VK_SAMPLE_COUNT_8_BIT, VK_SAMPLE_COUNT_16_BIT, VK_SAMPLE_COUNT_32_BIT, VK_SAMPLE_COUNT_64_BIT });

/// `VkSampleLocationEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkSampleLocationEXT {
    pub x: float,
    pub y: float,
}
impl_default_zeroed!(VkSampleLocationEXT);

/// `VkSampleLocationsInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkSampleLocationsInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub sampleLocationsPerPixel: VkSampleCountFlags,
    pub sampleLocationGridSize: VkExtent2D,
    pub sampleLocationsCount: uint32_t,
    pub pSampleLocations: *const VkSampleLocationEXT,
}
impl_default_zeroed_with_s_type!(VkSampleLocationsInfoEXT : VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT);
impl_extends!(VkSampleLocationsInfoEXT : VkImageMemoryBarrier, VkImageMemoryBarrier2);

/// `VkSampler` : `VkDevice`
#[repr(transparent)]
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkSampler(pub u64);
from_into_transparent!(VkSampler: u64);
impl_handle!(VkSampler: VK_OBJECT_TYPE_SAMPLER; SubHandle = VkDevice);

from_into_transparent!(VkSamplerAddressMode: i32);
/// `VkSamplerAddressMode`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkSamplerAddressMode(pub i32);

/// `0`  
pub const VK_SAMPLER_ADDRESS_MODE_REPEAT: VkSamplerAddressMode = VkSamplerAddressMode(0);
/// `1`  
pub const VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT: VkSamplerAddressMode = VkSamplerAddressMode(1);
/// `2`  
pub const VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE: VkSamplerAddressMode = VkSamplerAddressMode(2);
/// `3`  
pub const VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER: VkSamplerAddressMode = VkSamplerAddressMode(3);
/// `4`  
/// 
/// No need to add an extnumber attribute, since this uses a core enum value
pub const VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE: VkSamplerAddressMode = VkSamplerAddressMode(4);
/// `VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE`  
/// 
/// Introduced for consistency with extension suffixing rules
pub const VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE_KHR: VkSamplerAddressMode = VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE;

impl_enum_display!(VkSamplerAddressMode { VK_SAMPLER_ADDRESS_MODE_REPEAT, VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT, VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER, VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE, VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE_KHR });

/// `VkSamplerBlockMatchWindowCreateInfoQCOM`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkSamplerBlockMatchWindowCreateInfoQCOM {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub windowExtent: VkExtent2D,
    pub windowCompareMode: VkBlockMatchWindowCompareModeQCOM,
}
impl_default_zeroed_with_s_type!(VkSamplerBlockMatchWindowCreateInfoQCOM : VK_STRUCTURE_TYPE_SAMPLER_BLOCK_MATCH_WINDOW_CREATE_INFO_QCOM);
impl_extends!(VkSamplerBlockMatchWindowCreateInfoQCOM : VkSamplerCreateInfo);

/// `VkSamplerBorderColorComponentMappingCreateInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkSamplerBorderColorComponentMappingCreateInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub components: VkComponentMapping,
    pub srgb: VkBool32,
}
impl_default_zeroed_with_s_type!(VkSamplerBorderColorComponentMappingCreateInfoEXT : VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT);
impl_extends!(VkSamplerBorderColorComponentMappingCreateInfoEXT : VkSamplerCreateInfo);

/// `VkSamplerCaptureDescriptorDataInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkSamplerCaptureDescriptorDataInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub sampler: VkSampler,
}
impl_default_zeroed_with_s_type!(VkSamplerCaptureDescriptorDataInfoEXT : VK_STRUCTURE_TYPE_SAMPLER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT);

flags!(VkSamplerCreateFlags);
from_into_transparent!(VkSamplerCreateFlags: i32);
/// `VkSamplerCreateFlags`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkSamplerCreateFlags(pub i32);

/// `1 << 0`  
pub const VK_SAMPLER_CREATE_SUBSAMPLED_BIT_EXT: VkSamplerCreateFlags = VkSamplerCreateFlags(1 << 0);
/// `1 << 1`  
pub const VK_SAMPLER_CREATE_SUBSAMPLED_COARSE_RECONSTRUCTION_BIT_EXT: VkSamplerCreateFlags = VkSamplerCreateFlags(1 << 1);
/// `1 << 3`  
pub const VK_SAMPLER_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT: VkSamplerCreateFlags = VkSamplerCreateFlags(1 << 3);
/// `1 << 2`  
pub const VK_SAMPLER_CREATE_NON_SEAMLESS_CUBE_MAP_BIT_EXT: VkSamplerCreateFlags = VkSamplerCreateFlags(1 << 2);
/// `1 << 4`  
pub const VK_SAMPLER_CREATE_IMAGE_PROCESSING_BIT_QCOM: VkSamplerCreateFlags = VkSamplerCreateFlags(1 << 4);

impl_flags_display!(VkSamplerCreateFlags { VK_SAMPLER_CREATE_SUBSAMPLED_BIT_EXT, VK_SAMPLER_CREATE_SUBSAMPLED_COARSE_RECONSTRUCTION_BIT_EXT, VK_SAMPLER_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT, VK_SAMPLER_CREATE_NON_SEAMLESS_CUBE_MAP_BIT_EXT, VK_SAMPLER_CREATE_IMAGE_PROCESSING_BIT_QCOM });

/// `VkSamplerCreateInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkSamplerCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub flags: VkSamplerCreateFlags,
    /// Filter mode for magnification
    pub magFilter: VkFilter,
    /// Filter mode for minifiation
    pub minFilter: VkFilter,
    /// Mipmap selection mode
    pub mipmapMode: VkSamplerMipmapMode,
    pub addressModeU: VkSamplerAddressMode,
    pub addressModeV: VkSamplerAddressMode,
    pub addressModeW: VkSamplerAddressMode,
    pub mipLodBias: float,
    pub anisotropyEnable: VkBool32,
    pub maxAnisotropy: float,
    pub compareEnable: VkBool32,
    pub compareOp: VkCompareOp,
    pub minLod: float,
    pub maxLod: float,
    pub borderColor: VkBorderColor,
    pub unnormalizedCoordinates: VkBool32,
}
impl_default_zeroed_with_s_type!(VkSamplerCreateInfo : VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO);

/// `VkSamplerCubicWeightsCreateInfoQCOM`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkSamplerCubicWeightsCreateInfoQCOM {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub cubicWeights: VkCubicFilterWeightsQCOM,
}
impl_default_zeroed_with_s_type!(VkSamplerCubicWeightsCreateInfoQCOM : VK_STRUCTURE_TYPE_SAMPLER_CUBIC_WEIGHTS_CREATE_INFO_QCOM);
impl_extends!(VkSamplerCubicWeightsCreateInfoQCOM : VkSamplerCreateInfo);

/// `VkSamplerCustomBorderColorCreateInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkSamplerCustomBorderColorCreateInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub customBorderColor: VkClearColorValue,
    pub format: VkFormat,
}
impl_default_zeroed_with_s_type!(VkSamplerCustomBorderColorCreateInfoEXT : VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT);
impl_extends!(VkSamplerCustomBorderColorCreateInfoEXT : VkSamplerCreateInfo);

/// `VkSamplerCustomBorderColorIndexCreateInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkSamplerCustomBorderColorIndexCreateInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub index: uint32_t,
}
impl_default_zeroed_with_s_type!(VkSamplerCustomBorderColorIndexCreateInfoEXT : VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_INDEX_CREATE_INFO_EXT);
impl_extends!(VkSamplerCustomBorderColorIndexCreateInfoEXT : VkSamplerCreateInfo);

from_into_transparent!(VkSamplerMipmapMode: i32);
/// `VkSamplerMipmapMode`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkSamplerMipmapMode(pub i32);

/// `0`  
/// 
/// Choose nearest mip level
pub const VK_SAMPLER_MIPMAP_MODE_NEAREST: VkSamplerMipmapMode = VkSamplerMipmapMode(0);
/// `1`  
/// 
/// Linear filter between mip levels
pub const VK_SAMPLER_MIPMAP_MODE_LINEAR: VkSamplerMipmapMode = VkSamplerMipmapMode(1);

impl_enum_display!(VkSamplerMipmapMode { VK_SAMPLER_MIPMAP_MODE_NEAREST, VK_SAMPLER_MIPMAP_MODE_LINEAR });

from_into_transparent!(VkSamplerReductionMode: i32);
/// `VkSamplerReductionMode`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkSamplerReductionMode(pub i32);

/// `0`  
pub const VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE: VkSamplerReductionMode = VkSamplerReductionMode(0);
/// `1`  
pub const VK_SAMPLER_REDUCTION_MODE_MIN: VkSamplerReductionMode = VkSamplerReductionMode(1);
/// `2`  
pub const VK_SAMPLER_REDUCTION_MODE_MAX: VkSamplerReductionMode = VkSamplerReductionMode(2);
/// `VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE`  
pub const VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT: VkSamplerReductionMode = VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE;
/// `VK_SAMPLER_REDUCTION_MODE_MIN`  
pub const VK_SAMPLER_REDUCTION_MODE_MIN_EXT: VkSamplerReductionMode = VK_SAMPLER_REDUCTION_MODE_MIN;
/// `VK_SAMPLER_REDUCTION_MODE_MAX`  
pub const VK_SAMPLER_REDUCTION_MODE_MAX_EXT: VkSamplerReductionMode = VK_SAMPLER_REDUCTION_MODE_MAX;
/// `1000521000`  
pub const VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_RANGECLAMP_QCOM: VkSamplerReductionMode = VkSamplerReductionMode(1000521000);

impl_enum_display!(VkSamplerReductionMode { VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE, VK_SAMPLER_REDUCTION_MODE_MIN, VK_SAMPLER_REDUCTION_MODE_MAX, VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT, VK_SAMPLER_REDUCTION_MODE_MIN_EXT, VK_SAMPLER_REDUCTION_MODE_MAX_EXT, VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_RANGECLAMP_QCOM });

/// `VkSamplerReductionModeCreateInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkSamplerReductionModeCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub reductionMode: VkSamplerReductionMode,
}
impl_default_zeroed_with_s_type!(VkSamplerReductionModeCreateInfo : VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO);
impl_extends!(VkSamplerReductionModeCreateInfo : VkSamplerCreateInfo);

/// `VkSamplerReductionModeCreateInfo`
pub type VkSamplerReductionModeCreateInfoEXT = VkSamplerReductionModeCreateInfo;

/// `VkSamplerReductionMode`
pub type VkSamplerReductionModeEXT = VkSamplerReductionMode;

/// `VkSamplerYcbcrConversion` : `VkDevice`
#[repr(transparent)]
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkSamplerYcbcrConversion(pub u64);
from_into_transparent!(VkSamplerYcbcrConversion: u64);
impl_handle!(VkSamplerYcbcrConversion: VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION; SubHandle = VkDevice);

/// `VkSamplerYcbcrConversionCreateInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkSamplerYcbcrConversionCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub format: VkFormat,
    pub ycbcrModel: VkSamplerYcbcrModelConversion,
    pub ycbcrRange: VkSamplerYcbcrRange,
    pub components: VkComponentMapping,
    pub xChromaOffset: VkChromaLocation,
    pub yChromaOffset: VkChromaLocation,
    pub chromaFilter: VkFilter,
    pub forceExplicitReconstruction: VkBool32,
}
impl_default_zeroed_with_s_type!(VkSamplerYcbcrConversionCreateInfo : VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO);

/// `VkSamplerYcbcrConversionCreateInfo`
pub type VkSamplerYcbcrConversionCreateInfoKHR = VkSamplerYcbcrConversionCreateInfo;

/// `VkSamplerYcbcrConversionImageFormatProperties`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkSamplerYcbcrConversionImageFormatProperties {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub combinedImageSamplerDescriptorCount: uint32_t,
}
impl_default_zeroed_with_s_type!(VkSamplerYcbcrConversionImageFormatProperties : VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES);
impl_extends!(VkSamplerYcbcrConversionImageFormatProperties : VkImageFormatProperties2);

/// `VkSamplerYcbcrConversionImageFormatProperties`
pub type VkSamplerYcbcrConversionImageFormatPropertiesKHR = VkSamplerYcbcrConversionImageFormatProperties;

/// `VkSamplerYcbcrConversionInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkSamplerYcbcrConversionInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub conversion: VkSamplerYcbcrConversion,
}
impl_default_zeroed_with_s_type!(VkSamplerYcbcrConversionInfo : VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO);
impl_extends!(VkSamplerYcbcrConversionInfo : VkSamplerCreateInfo, VkImageViewCreateInfo);

/// `VkSamplerYcbcrConversionInfo`
pub type VkSamplerYcbcrConversionInfoKHR = VkSamplerYcbcrConversionInfo;

/// `VkSamplerYcbcrConversion`
pub type VkSamplerYcbcrConversionKHR = VkSamplerYcbcrConversion;

/// `VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub enableYDegamma: VkBool32,
    pub enableCbCrDegamma: VkBool32,
}
impl_default_zeroed_with_s_type!(VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM : VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_YCBCR_DEGAMMA_CREATE_INFO_QCOM);
impl_extends!(VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM : VkSamplerYcbcrConversionCreateInfo);

from_into_transparent!(VkSamplerYcbcrModelConversion: i32);
/// `VkSamplerYcbcrModelConversion`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkSamplerYcbcrModelConversion(pub i32);

/// `0`  
pub const VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY: VkSamplerYcbcrModelConversion = VkSamplerYcbcrModelConversion(0);
/// `1`  
/// 
/// just range expansion
pub const VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY: VkSamplerYcbcrModelConversion = VkSamplerYcbcrModelConversion(1);
/// `2`  
/// 
/// aka HD YUV
pub const VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709: VkSamplerYcbcrModelConversion = VkSamplerYcbcrModelConversion(2);
/// `3`  
/// 
/// aka SD YUV
pub const VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601: VkSamplerYcbcrModelConversion = VkSamplerYcbcrModelConversion(3);
/// `4`  
/// 
/// aka UHD YUV
pub const VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020: VkSamplerYcbcrModelConversion = VkSamplerYcbcrModelConversion(4);
/// `VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY`  
pub const VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY_KHR: VkSamplerYcbcrModelConversion = VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY;
/// `VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY`  
pub const VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY_KHR: VkSamplerYcbcrModelConversion = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY;
/// `VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709`  
pub const VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709_KHR: VkSamplerYcbcrModelConversion = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709;
/// `VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601`  
pub const VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601_KHR: VkSamplerYcbcrModelConversion = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601;
/// `VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020`  
pub const VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020_KHR: VkSamplerYcbcrModelConversion = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020;

impl_enum_display!(VkSamplerYcbcrModelConversion { VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY, VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY, VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709, VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601, VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020, VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY_KHR, VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY_KHR, VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709_KHR, VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601_KHR, VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020_KHR });

/// `VkSamplerYcbcrModelConversion`
pub type VkSamplerYcbcrModelConversionKHR = VkSamplerYcbcrModelConversion;

from_into_transparent!(VkSamplerYcbcrRange: i32);
/// `VkSamplerYcbcrRange`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkSamplerYcbcrRange(pub i32);

/// `0`  
/// 
/// Luma 0..1 maps to 0..255, chroma -0.5..0.5 to 1..255 (clamped)
pub const VK_SAMPLER_YCBCR_RANGE_ITU_FULL: VkSamplerYcbcrRange = VkSamplerYcbcrRange(0);
/// `1`  
/// 
/// Luma 0..1 maps to 16..235, chroma -0.5..0.5 to 16..240
pub const VK_SAMPLER_YCBCR_RANGE_ITU_NARROW: VkSamplerYcbcrRange = VkSamplerYcbcrRange(1);
/// `VK_SAMPLER_YCBCR_RANGE_ITU_FULL`  
pub const VK_SAMPLER_YCBCR_RANGE_ITU_FULL_KHR: VkSamplerYcbcrRange = VK_SAMPLER_YCBCR_RANGE_ITU_FULL;
/// `VK_SAMPLER_YCBCR_RANGE_ITU_NARROW`  
pub const VK_SAMPLER_YCBCR_RANGE_ITU_NARROW_KHR: VkSamplerYcbcrRange = VK_SAMPLER_YCBCR_RANGE_ITU_NARROW;

impl_enum_display!(VkSamplerYcbcrRange { VK_SAMPLER_YCBCR_RANGE_ITU_FULL, VK_SAMPLER_YCBCR_RANGE_ITU_NARROW, VK_SAMPLER_YCBCR_RANGE_ITU_FULL_KHR, VK_SAMPLER_YCBCR_RANGE_ITU_NARROW_KHR });

/// `VkSamplerYcbcrRange`
pub type VkSamplerYcbcrRangeKHR = VkSamplerYcbcrRange;

/// `VkSciSyncAttributesInfoNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkSciSyncAttributesInfoNV {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub clientType: VkSciSyncClientTypeNV,
    pub primitiveType: VkSciSyncPrimitiveTypeNV,
}
impl_default_zeroed_with_s_type!(VkSciSyncAttributesInfoNV : VK_STRUCTURE_TYPE_SCI_SYNC_ATTRIBUTES_INFO_NV);

from_into_transparent!(VkSciSyncClientTypeNV: i32);
/// `VkSciSyncClientTypeNV`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkSciSyncClientTypeNV(pub i32);

/// `0`  
pub const VK_SCI_SYNC_CLIENT_TYPE_SIGNALER_NV: VkSciSyncClientTypeNV = VkSciSyncClientTypeNV(0);
/// `1`  
pub const VK_SCI_SYNC_CLIENT_TYPE_WAITER_NV: VkSciSyncClientTypeNV = VkSciSyncClientTypeNV(1);
/// `2`  
pub const VK_SCI_SYNC_CLIENT_TYPE_SIGNALER_WAITER_NV: VkSciSyncClientTypeNV = VkSciSyncClientTypeNV(2);

impl_enum_display!(VkSciSyncClientTypeNV { VK_SCI_SYNC_CLIENT_TYPE_SIGNALER_NV, VK_SCI_SYNC_CLIENT_TYPE_WAITER_NV, VK_SCI_SYNC_CLIENT_TYPE_SIGNALER_WAITER_NV });

from_into_transparent!(VkSciSyncPrimitiveTypeNV: i32);
/// `VkSciSyncPrimitiveTypeNV`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkSciSyncPrimitiveTypeNV(pub i32);

/// `0`  
pub const VK_SCI_SYNC_PRIMITIVE_TYPE_FENCE_NV: VkSciSyncPrimitiveTypeNV = VkSciSyncPrimitiveTypeNV(0);
/// `1`  
pub const VK_SCI_SYNC_PRIMITIVE_TYPE_SEMAPHORE_NV: VkSciSyncPrimitiveTypeNV = VkSciSyncPrimitiveTypeNV(1);

impl_enum_display!(VkSciSyncPrimitiveTypeNV { VK_SCI_SYNC_PRIMITIVE_TYPE_FENCE_NV, VK_SCI_SYNC_PRIMITIVE_TYPE_SEMAPHORE_NV });

from_into_transparent!(VkScopeKHR: i32);
/// `VkScopeKHR`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkScopeKHR(pub i32);

/// `1`  
pub const VK_SCOPE_DEVICE_KHR: VkScopeKHR = VkScopeKHR(1);
/// `2`  
pub const VK_SCOPE_WORKGROUP_KHR: VkScopeKHR = VkScopeKHR(2);
/// `3`  
pub const VK_SCOPE_SUBGROUP_KHR: VkScopeKHR = VkScopeKHR(3);
/// `5`  
pub const VK_SCOPE_QUEUE_FAMILY_KHR: VkScopeKHR = VkScopeKHR(5);
/// `VK_SCOPE_DEVICE_KHR`  
pub const VK_SCOPE_DEVICE_NV: VkScopeKHR = VK_SCOPE_DEVICE_KHR;
/// `VK_SCOPE_WORKGROUP_KHR`  
pub const VK_SCOPE_WORKGROUP_NV: VkScopeKHR = VK_SCOPE_WORKGROUP_KHR;
/// `VK_SCOPE_SUBGROUP_KHR`  
pub const VK_SCOPE_SUBGROUP_NV: VkScopeKHR = VK_SCOPE_SUBGROUP_KHR;
/// `VK_SCOPE_QUEUE_FAMILY_KHR`  
pub const VK_SCOPE_QUEUE_FAMILY_NV: VkScopeKHR = VK_SCOPE_QUEUE_FAMILY_KHR;

impl_enum_display!(VkScopeKHR { VK_SCOPE_DEVICE_KHR, VK_SCOPE_WORKGROUP_KHR, VK_SCOPE_SUBGROUP_KHR, VK_SCOPE_QUEUE_FAMILY_KHR, VK_SCOPE_DEVICE_NV, VK_SCOPE_WORKGROUP_NV, VK_SCOPE_SUBGROUP_NV, VK_SCOPE_QUEUE_FAMILY_NV });

/// `VkScopeKHR`
pub type VkScopeNV = VkScopeKHR;

/// `VkScreenBufferFormatPropertiesQNX`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkScreenBufferFormatPropertiesQNX {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub format: VkFormat,
    pub externalFormat: uint64_t,
    pub screenUsage: uint64_t,
    pub formatFeatures: VkFormatFeatureFlags,
    pub samplerYcbcrConversionComponents: VkComponentMapping,
    pub suggestedYcbcrModel: VkSamplerYcbcrModelConversion,
    pub suggestedYcbcrRange: VkSamplerYcbcrRange,
    pub suggestedXChromaOffset: VkChromaLocation,
    pub suggestedYChromaOffset: VkChromaLocation,
}
impl_default_zeroed_with_s_type!(VkScreenBufferFormatPropertiesQNX : VK_STRUCTURE_TYPE_SCREEN_BUFFER_FORMAT_PROPERTIES_QNX);
impl_extends!(VkScreenBufferFormatPropertiesQNX : VkScreenBufferPropertiesQNX);

/// `VkScreenBufferPropertiesQNX`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkScreenBufferPropertiesQNX {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub allocationSize: VkDeviceSize,
    pub memoryTypeBits: uint32_t,
}
impl_default_zeroed_with_s_type!(VkScreenBufferPropertiesQNX : VK_STRUCTURE_TYPE_SCREEN_BUFFER_PROPERTIES_QNX);

flags!(VkScreenSurfaceCreateFlagsQNX);
from_into_transparent!(VkScreenSurfaceCreateFlagsQNX: i32);
/// `VkScreenSurfaceCreateFlagsQNX`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkScreenSurfaceCreateFlagsQNX(pub i32);

impl_flags_display!(VkScreenSurfaceCreateFlagsQNX {  });

/// `VkScreenSurfaceCreateInfoQNX`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkScreenSurfaceCreateInfoQNX {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub flags: VkScreenSurfaceCreateFlagsQNX,
    pub context: *mut _screen_context,
    pub window: *mut _screen_window,
}
impl_default_zeroed_with_s_type!(VkScreenSurfaceCreateInfoQNX : VK_STRUCTURE_TYPE_SCREEN_SURFACE_CREATE_INFO_QNX);

/// `VkSemaphore` : `VkDevice`
#[repr(transparent)]
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkSemaphore(pub u64);
from_into_transparent!(VkSemaphore: u64);
impl_handle!(VkSemaphore: VK_OBJECT_TYPE_SEMAPHORE; SubHandle = VkDevice);

flags!(VkSemaphoreCreateFlags);
from_into_transparent!(VkSemaphoreCreateFlags: i32);
/// `VkSemaphoreCreateFlags`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkSemaphoreCreateFlags(pub i32);

impl_flags_display!(VkSemaphoreCreateFlags {  });

/// `VkSemaphoreCreateInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkSemaphoreCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    /// Semaphore creation flags
    pub flags: VkSemaphoreCreateFlags,
}
impl_default_zeroed_with_s_type!(VkSemaphoreCreateInfo : VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO);

/// `VkSemaphoreGetFdInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkSemaphoreGetFdInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub semaphore: VkSemaphore,
    pub handleType: VkExternalSemaphoreHandleTypeFlags,
}
impl_default_zeroed_with_s_type!(VkSemaphoreGetFdInfoKHR : VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR);

/// `VkSemaphoreGetSciSyncInfoNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkSemaphoreGetSciSyncInfoNV {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub semaphore: VkSemaphore,
    pub handleType: VkExternalSemaphoreHandleTypeFlags,
}
impl_default_zeroed_with_s_type!(VkSemaphoreGetSciSyncInfoNV : VK_STRUCTURE_TYPE_SEMAPHORE_GET_SCI_SYNC_INFO_NV);

/// `VkSemaphoreGetWin32HandleInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkSemaphoreGetWin32HandleInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub semaphore: VkSemaphore,
    pub handleType: VkExternalSemaphoreHandleTypeFlags,
}
impl_default_zeroed_with_s_type!(VkSemaphoreGetWin32HandleInfoKHR : VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR);

/// `VkSemaphoreGetZirconHandleInfoFUCHSIA`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkSemaphoreGetZirconHandleInfoFUCHSIA {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub semaphore: VkSemaphore,
    pub handleType: VkExternalSemaphoreHandleTypeFlags,
}
impl_default_zeroed_with_s_type!(VkSemaphoreGetZirconHandleInfoFUCHSIA : VK_STRUCTURE_TYPE_SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA);

flags!(VkSemaphoreImportFlags);
from_into_transparent!(VkSemaphoreImportFlags: i32);
/// `VkSemaphoreImportFlags`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkSemaphoreImportFlags(pub i32);

/// `1 << 0`  
pub const VK_SEMAPHORE_IMPORT_TEMPORARY_BIT: VkSemaphoreImportFlags = VkSemaphoreImportFlags(1 << 0);
/// `VK_SEMAPHORE_IMPORT_TEMPORARY_BIT`  
pub const VK_SEMAPHORE_IMPORT_TEMPORARY_BIT_KHR: VkSemaphoreImportFlags = VK_SEMAPHORE_IMPORT_TEMPORARY_BIT;

impl_flags_display!(VkSemaphoreImportFlags { VK_SEMAPHORE_IMPORT_TEMPORARY_BIT, VK_SEMAPHORE_IMPORT_TEMPORARY_BIT_KHR });

/// `VkSemaphoreImportFlags`
pub type VkSemaphoreImportFlagsKHR = VkSemaphoreImportFlags;

/// `VkSemaphoreSciSyncCreateInfoNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkSemaphoreSciSyncCreateInfoNV {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub semaphorePool: VkSemaphoreSciSyncPoolNV,
    pub pFence: *const NvSciSyncFence,
}
impl_default_zeroed_with_s_type!(VkSemaphoreSciSyncCreateInfoNV : VK_STRUCTURE_TYPE_SEMAPHORE_SCI_SYNC_CREATE_INFO_NV);
impl_extends!(VkSemaphoreSciSyncCreateInfoNV : VkSemaphoreCreateInfo);

/// `VkSemaphoreSciSyncPoolCreateInfoNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkSemaphoreSciSyncPoolCreateInfoNV {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub handle: NvSciSyncObj,
}
impl_default_zeroed_with_s_type!(VkSemaphoreSciSyncPoolCreateInfoNV : VK_STRUCTURE_TYPE_SEMAPHORE_SCI_SYNC_POOL_CREATE_INFO_NV);

/// `VkSemaphoreSciSyncPoolNV` : `VkDevice`
#[repr(transparent)]
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkSemaphoreSciSyncPoolNV(pub u64);
from_into_transparent!(VkSemaphoreSciSyncPoolNV: u64);
impl_handle!(VkSemaphoreSciSyncPoolNV: VK_OBJECT_TYPE_SEMAPHORE_SCI_SYNC_POOL_NV; SubHandle = VkDevice);

/// `VkSemaphoreSignalInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkSemaphoreSignalInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub semaphore: VkSemaphore,
    pub value: uint64_t,
}
impl_default_zeroed_with_s_type!(VkSemaphoreSignalInfo : VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO);

/// `VkSemaphoreSignalInfo`
pub type VkSemaphoreSignalInfoKHR = VkSemaphoreSignalInfo;

/// `VkSemaphoreSubmitInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkSemaphoreSubmitInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub semaphore: VkSemaphore,
    pub value: uint64_t,
    pub stageMask: VkPipelineStageFlags2,
    pub deviceIndex: uint32_t,
}
impl_default_zeroed_with_s_type!(VkSemaphoreSubmitInfo : VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO);

/// `VkSemaphoreSubmitInfo`
pub type VkSemaphoreSubmitInfoKHR = VkSemaphoreSubmitInfo;

from_into_transparent!(VkSemaphoreType: i32);
/// `VkSemaphoreType`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkSemaphoreType(pub i32);

/// `0`  
pub const VK_SEMAPHORE_TYPE_BINARY: VkSemaphoreType = VkSemaphoreType(0);
/// `1`  
pub const VK_SEMAPHORE_TYPE_TIMELINE: VkSemaphoreType = VkSemaphoreType(1);
/// `VK_SEMAPHORE_TYPE_BINARY`  
pub const VK_SEMAPHORE_TYPE_BINARY_KHR: VkSemaphoreType = VK_SEMAPHORE_TYPE_BINARY;
/// `VK_SEMAPHORE_TYPE_TIMELINE`  
pub const VK_SEMAPHORE_TYPE_TIMELINE_KHR: VkSemaphoreType = VK_SEMAPHORE_TYPE_TIMELINE;

impl_enum_display!(VkSemaphoreType { VK_SEMAPHORE_TYPE_BINARY, VK_SEMAPHORE_TYPE_TIMELINE, VK_SEMAPHORE_TYPE_BINARY_KHR, VK_SEMAPHORE_TYPE_TIMELINE_KHR });

/// `VkSemaphoreTypeCreateInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkSemaphoreTypeCreateInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub semaphoreType: VkSemaphoreType,
    pub initialValue: uint64_t,
}
impl_default_zeroed_with_s_type!(VkSemaphoreTypeCreateInfo : VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO);
impl_extends!(VkSemaphoreTypeCreateInfo : VkSemaphoreCreateInfo, VkPhysicalDeviceExternalSemaphoreInfo);

/// `VkSemaphoreTypeCreateInfo`
pub type VkSemaphoreTypeCreateInfoKHR = VkSemaphoreTypeCreateInfo;

/// `VkSemaphoreType`
pub type VkSemaphoreTypeKHR = VkSemaphoreType;

flags!(VkSemaphoreWaitFlags);
from_into_transparent!(VkSemaphoreWaitFlags: i32);
/// `VkSemaphoreWaitFlags`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkSemaphoreWaitFlags(pub i32);

/// `1 << 0`  
pub const VK_SEMAPHORE_WAIT_ANY_BIT: VkSemaphoreWaitFlags = VkSemaphoreWaitFlags(1 << 0);
/// `VK_SEMAPHORE_WAIT_ANY_BIT`  
pub const VK_SEMAPHORE_WAIT_ANY_BIT_KHR: VkSemaphoreWaitFlags = VK_SEMAPHORE_WAIT_ANY_BIT;

impl_flags_display!(VkSemaphoreWaitFlags { VK_SEMAPHORE_WAIT_ANY_BIT, VK_SEMAPHORE_WAIT_ANY_BIT_KHR });

/// `VkSemaphoreWaitFlags`
pub type VkSemaphoreWaitFlagsKHR = VkSemaphoreWaitFlags;

/// `VkSemaphoreWaitInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkSemaphoreWaitInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub flags: VkSemaphoreWaitFlags,
    pub semaphoreCount: uint32_t,
    pub pSemaphores: *const VkSemaphore,
    pub pValues: *const uint64_t,
}
impl_default_zeroed_with_s_type!(VkSemaphoreWaitInfo : VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO);

/// `VkSemaphoreWaitInfo`
pub type VkSemaphoreWaitInfoKHR = VkSemaphoreWaitInfo;

/// `VkSetDescriptorBufferOffsetsInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkSetDescriptorBufferOffsetsInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub stageFlags: VkShaderStageFlags,
    pub layout: VkPipelineLayout,
    pub firstSet: uint32_t,
    pub setCount: uint32_t,
    pub pBufferIndices: *const uint32_t,
    pub pOffsets: *const VkDeviceSize,
}
impl_default_zeroed_with_s_type!(VkSetDescriptorBufferOffsetsInfoEXT : VK_STRUCTURE_TYPE_SET_DESCRIPTOR_BUFFER_OFFSETS_INFO_EXT);

/// `VkSetLatencyMarkerInfoNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkSetLatencyMarkerInfoNV {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub presentID: uint64_t,
    pub marker: VkLatencyMarkerNV,
}
impl_default_zeroed_with_s_type!(VkSetLatencyMarkerInfoNV : VK_STRUCTURE_TYPE_SET_LATENCY_MARKER_INFO_NV);

/// `VkSetPresentConfigNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkSetPresentConfigNV {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub numFramesPerBatch: uint32_t,
    pub presentConfigFeedback: uint32_t,
}
impl_default_zeroed_with_s_type!(VkSetPresentConfigNV : VK_STRUCTURE_TYPE_SET_PRESENT_CONFIG_NV);
impl_extends!(VkSetPresentConfigNV : VkPresentInfoKHR);

/// `VkSetStateFlagsIndirectCommandNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkSetStateFlagsIndirectCommandNV {
    pub data: uint32_t,
}
impl_default_zeroed!(VkSetStateFlagsIndirectCommandNV);

from_into_transparent!(VkShaderCodeTypeEXT: i32);
/// `VkShaderCodeTypeEXT`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkShaderCodeTypeEXT(pub i32);

/// `0`  
pub const VK_SHADER_CODE_TYPE_BINARY_EXT: VkShaderCodeTypeEXT = VkShaderCodeTypeEXT(0);
/// `1`  
pub const VK_SHADER_CODE_TYPE_SPIRV_EXT: VkShaderCodeTypeEXT = VkShaderCodeTypeEXT(1);

impl_enum_display!(VkShaderCodeTypeEXT { VK_SHADER_CODE_TYPE_BINARY_EXT, VK_SHADER_CODE_TYPE_SPIRV_EXT });

flags!(VkShaderCorePropertiesFlagsAMD);
from_into_transparent!(VkShaderCorePropertiesFlagsAMD: i32);
/// `VkShaderCorePropertiesFlagsAMD`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkShaderCorePropertiesFlagsAMD(pub i32);

impl_flags_display!(VkShaderCorePropertiesFlagsAMD {  });

flags!(VkShaderCreateFlagsEXT);
from_into_transparent!(VkShaderCreateFlagsEXT: i32);
/// `VkShaderCreateFlagsEXT`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkShaderCreateFlagsEXT(pub i32);

/// `1 << 0`  
pub const VK_SHADER_CREATE_LINK_STAGE_BIT_EXT: VkShaderCreateFlagsEXT = VkShaderCreateFlagsEXT(1 << 0);
/// `1 << 17`  
pub const VK_SHADER_CREATE_RESERVED_17_BIT_IMG: VkShaderCreateFlagsEXT = VkShaderCreateFlagsEXT(1 << 17);
/// `1 << 10`  
pub const VK_SHADER_CREATE_DESCRIPTOR_HEAP_BIT_EXT: VkShaderCreateFlagsEXT = VkShaderCreateFlagsEXT(1 << 10);
/// `1 << 11`  
pub const VK_SHADER_CREATE_INSTRUMENT_SHADER_BIT_ARM: VkShaderCreateFlagsEXT = VkShaderCreateFlagsEXT(1 << 11);
/// `1 << 1`  
pub const VK_SHADER_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT: VkShaderCreateFlagsEXT = VkShaderCreateFlagsEXT(1 << 1);
/// `1 << 2`  
pub const VK_SHADER_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT: VkShaderCreateFlagsEXT = VkShaderCreateFlagsEXT(1 << 2);
/// `1 << 3`  
pub const VK_SHADER_CREATE_NO_TASK_SHADER_BIT_EXT: VkShaderCreateFlagsEXT = VkShaderCreateFlagsEXT(1 << 3);
/// `1 << 4`  
pub const VK_SHADER_CREATE_DISPATCH_BASE_BIT_EXT: VkShaderCreateFlagsEXT = VkShaderCreateFlagsEXT(1 << 4);
/// `1 << 5`  
pub const VK_SHADER_CREATE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_EXT: VkShaderCreateFlagsEXT = VkShaderCreateFlagsEXT(1 << 5);
/// `1 << 6`  
pub const VK_SHADER_CREATE_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT: VkShaderCreateFlagsEXT = VkShaderCreateFlagsEXT(1 << 6);
/// `1 << 7`  
pub const VK_SHADER_CREATE_INDIRECT_BINDABLE_BIT_EXT: VkShaderCreateFlagsEXT = VkShaderCreateFlagsEXT(1 << 7);
/// `1 << 8`  
pub const VK_SHADER_CREATE_RESERVED_8_BIT_EXT: VkShaderCreateFlagsEXT = VkShaderCreateFlagsEXT(1 << 8);
/// `1 << 9`  
pub const VK_SHADER_CREATE_RESERVED_9_BIT_EXT: VkShaderCreateFlagsEXT = VkShaderCreateFlagsEXT(1 << 9);
/// `1 << 15`  
pub const VK_SHADER_CREATE_64_BIT_INDEXING_BIT_EXT: VkShaderCreateFlagsEXT = VkShaderCreateFlagsEXT(1 << 15);

impl_flags_display!(VkShaderCreateFlagsEXT { VK_SHADER_CREATE_LINK_STAGE_BIT_EXT, VK_SHADER_CREATE_RESERVED_17_BIT_IMG, VK_SHADER_CREATE_DESCRIPTOR_HEAP_BIT_EXT, VK_SHADER_CREATE_INSTRUMENT_SHADER_BIT_ARM, VK_SHADER_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT, VK_SHADER_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT, VK_SHADER_CREATE_NO_TASK_SHADER_BIT_EXT, VK_SHADER_CREATE_DISPATCH_BASE_BIT_EXT, VK_SHADER_CREATE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_EXT, VK_SHADER_CREATE_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT, VK_SHADER_CREATE_INDIRECT_BINDABLE_BIT_EXT, VK_SHADER_CREATE_RESERVED_8_BIT_EXT, VK_SHADER_CREATE_RESERVED_9_BIT_EXT, VK_SHADER_CREATE_64_BIT_INDEXING_BIT_EXT });

/// `VkShaderCreateInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkShaderCreateInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub flags: VkShaderCreateFlagsEXT,
    pub stage: VkShaderStageFlags,
    pub nextStage: VkShaderStageFlags,
    pub codeType: VkShaderCodeTypeEXT,
    pub codeSize: size_t,
    pub pCode: *const void,
    pub pName: *const c_char,
    pub setLayoutCount: uint32_t,
    pub pSetLayouts: *const VkDescriptorSetLayout,
    pub pushConstantRangeCount: uint32_t,
    pub pPushConstantRanges: *const VkPushConstantRange,
    pub pSpecializationInfo: *const VkSpecializationInfo,
}
impl_default_zeroed_with_s_type!(VkShaderCreateInfoEXT : VK_STRUCTURE_TYPE_SHADER_CREATE_INFO_EXT);

/// `VkShaderDescriptorSetAndBindingMappingInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkShaderDescriptorSetAndBindingMappingInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub mappingCount: uint32_t,
    pub pMappings: *const VkDescriptorSetAndBindingMappingEXT,
}
impl_default_zeroed_with_s_type!(VkShaderDescriptorSetAndBindingMappingInfoEXT : VK_STRUCTURE_TYPE_SHADER_DESCRIPTOR_SET_AND_BINDING_MAPPING_INFO_EXT);
impl_extends!(VkShaderDescriptorSetAndBindingMappingInfoEXT : VkPipelineShaderStageCreateInfo, VkShaderCreateInfoEXT);

/// `VkShaderEXT` : `VkDevice`
#[repr(transparent)]
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkShaderEXT(pub u64);
from_into_transparent!(VkShaderEXT: u64);
impl_handle!(VkShaderEXT: VK_OBJECT_TYPE_SHADER_EXT; SubHandle = VkDevice);

from_into_transparent!(VkShaderFloatControlsIndependence: i32);
/// `VkShaderFloatControlsIndependence`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkShaderFloatControlsIndependence(pub i32);

/// `0`  
pub const VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY: VkShaderFloatControlsIndependence = VkShaderFloatControlsIndependence(0);
/// `1`  
pub const VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL: VkShaderFloatControlsIndependence = VkShaderFloatControlsIndependence(1);
/// `2`  
pub const VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE: VkShaderFloatControlsIndependence = VkShaderFloatControlsIndependence(2);
/// `VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY`  
pub const VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY_KHR: VkShaderFloatControlsIndependence = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY;
/// `VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL`  
pub const VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL_KHR: VkShaderFloatControlsIndependence = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL;
/// `VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE`  
pub const VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE_KHR: VkShaderFloatControlsIndependence = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE;

impl_enum_display!(VkShaderFloatControlsIndependence { VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY, VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL, VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE, VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY_KHR, VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL_KHR, VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE_KHR });

/// `VkShaderFloatControlsIndependence`
pub type VkShaderFloatControlsIndependenceKHR = VkShaderFloatControlsIndependence;

from_into_transparent!(VkShaderGroupShaderKHR: i32);
/// `VkShaderGroupShaderKHR`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkShaderGroupShaderKHR(pub i32);

/// `0`  
pub const VK_SHADER_GROUP_SHADER_GENERAL_KHR: VkShaderGroupShaderKHR = VkShaderGroupShaderKHR(0);
/// `1`  
pub const VK_SHADER_GROUP_SHADER_CLOSEST_HIT_KHR: VkShaderGroupShaderKHR = VkShaderGroupShaderKHR(1);
/// `2`  
pub const VK_SHADER_GROUP_SHADER_ANY_HIT_KHR: VkShaderGroupShaderKHR = VkShaderGroupShaderKHR(2);
/// `3`  
pub const VK_SHADER_GROUP_SHADER_INTERSECTION_KHR: VkShaderGroupShaderKHR = VkShaderGroupShaderKHR(3);

impl_enum_display!(VkShaderGroupShaderKHR { VK_SHADER_GROUP_SHADER_GENERAL_KHR, VK_SHADER_GROUP_SHADER_CLOSEST_HIT_KHR, VK_SHADER_GROUP_SHADER_ANY_HIT_KHR, VK_SHADER_GROUP_SHADER_INTERSECTION_KHR });

from_into_transparent!(VkShaderInfoTypeAMD: i32);
/// `VkShaderInfoTypeAMD`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkShaderInfoTypeAMD(pub i32);

/// `0`  
pub const VK_SHADER_INFO_TYPE_STATISTICS_AMD: VkShaderInfoTypeAMD = VkShaderInfoTypeAMD(0);
/// `1`  
pub const VK_SHADER_INFO_TYPE_BINARY_AMD: VkShaderInfoTypeAMD = VkShaderInfoTypeAMD(1);
/// `2`  
pub const VK_SHADER_INFO_TYPE_DISASSEMBLY_AMD: VkShaderInfoTypeAMD = VkShaderInfoTypeAMD(2);

impl_enum_display!(VkShaderInfoTypeAMD { VK_SHADER_INFO_TYPE_STATISTICS_AMD, VK_SHADER_INFO_TYPE_BINARY_AMD, VK_SHADER_INFO_TYPE_DISASSEMBLY_AMD });

/// `VkShaderInstrumentationARM` : `VkDevice`
#[repr(transparent)]
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkShaderInstrumentationARM(pub u64);
from_into_transparent!(VkShaderInstrumentationARM: u64);
impl_handle!(VkShaderInstrumentationARM: VK_OBJECT_TYPE_SHADER_INSTRUMENTATION_ARM; SubHandle = VkDevice);

/// `VkShaderInstrumentationCreateInfoARM`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkShaderInstrumentationCreateInfoARM {
    pub sType: VkStructureType,
    pub pNext: *mut void,
}
impl_default_zeroed_with_s_type!(VkShaderInstrumentationCreateInfoARM : VK_STRUCTURE_TYPE_SHADER_INSTRUMENTATION_CREATE_INFO_ARM);

/// `VkShaderInstrumentationMetricDataHeaderARM`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkShaderInstrumentationMetricDataHeaderARM {
    pub resultIndex: uint32_t,
    pub resultSubIndex: uint32_t,
    pub stages: VkShaderStageFlags,
    pub basicBlockIndex: uint32_t,
}
impl_default_zeroed!(VkShaderInstrumentationMetricDataHeaderARM);

/// `VkShaderInstrumentationMetricDescriptionARM`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkShaderInstrumentationMetricDescriptionARM {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub name: [c_char; VK_MAX_DESCRIPTION_SIZE as usize],
    pub description: [c_char; VK_MAX_DESCRIPTION_SIZE as usize],
}
impl_default_zeroed_with_s_type!(VkShaderInstrumentationMetricDescriptionARM : VK_STRUCTURE_TYPE_SHADER_INSTRUMENTATION_METRIC_DESCRIPTION_ARM);

flags!(VkShaderInstrumentationValuesFlagsARM);
from_into_transparent!(VkShaderInstrumentationValuesFlagsARM: i32);
/// `VkShaderInstrumentationValuesFlagsARM`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkShaderInstrumentationValuesFlagsARM(pub i32);

impl_flags_display!(VkShaderInstrumentationValuesFlagsARM {  });

/// `VkShaderModule` : `VkDevice`
#[repr(transparent)]
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkShaderModule(pub u64);
from_into_transparent!(VkShaderModule: u64);
impl_handle!(VkShaderModule: VK_OBJECT_TYPE_SHADER_MODULE; SubHandle = VkDevice);

flags!(VkShaderModuleCreateFlags);
from_into_transparent!(VkShaderModuleCreateFlags: i32);
/// `VkShaderModuleCreateFlags`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkShaderModuleCreateFlags(pub i32);

impl_flags_display!(VkShaderModuleCreateFlags {  });

/// `VkShaderModuleCreateInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkShaderModuleCreateInfo {
    pub sType: VkStructureType,
    /// noautovalidity because this structure can be either an explicit parameter, or passed in a pNext chain
    pub pNext: *const void,
    pub flags: VkShaderModuleCreateFlags,
    /// Specified in bytes
    pub codeSize: size_t,
    /// Binary code of size codeSize
    pub pCode: *const uint32_t,
}
impl_default_zeroed_with_s_type!(VkShaderModuleCreateInfo : VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO);
impl_extends!(VkShaderModuleCreateInfo : VkPipelineShaderStageCreateInfo, VkDataGraphPipelineCreateInfoARM);

/// `VkShaderModuleIdentifierEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkShaderModuleIdentifierEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub identifierSize: uint32_t,
    pub identifier: [uint8_t; VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT as usize],
}
impl_default_zeroed_with_s_type!(VkShaderModuleIdentifierEXT : VK_STRUCTURE_TYPE_SHADER_MODULE_IDENTIFIER_EXT);

/// `VkShaderModuleValidationCacheCreateInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkShaderModuleValidationCacheCreateInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub validationCache: VkValidationCacheEXT,
}
impl_default_zeroed_with_s_type!(VkShaderModuleValidationCacheCreateInfoEXT : VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT);
impl_extends!(VkShaderModuleValidationCacheCreateInfoEXT : VkShaderModuleCreateInfo, VkPipelineShaderStageCreateInfo);

/// `VkPipelineShaderStageRequiredSubgroupSizeCreateInfo`
pub type VkShaderRequiredSubgroupSizeCreateInfoEXT = VkPipelineShaderStageRequiredSubgroupSizeCreateInfo;

/// `VkShaderResourceUsageAMD`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkShaderResourceUsageAMD {
    pub numUsedVgprs: uint32_t,
    pub numUsedSgprs: uint32_t,
    pub ldsSizePerLocalWorkGroup: uint32_t,
    pub ldsUsageSizeInBytes: size_t,
    pub scratchMemUsageInBytes: size_t,
}
impl_default_zeroed!(VkShaderResourceUsageAMD);

flags!(VkShaderStageFlags);
from_into_transparent!(VkShaderStageFlags: i32);
/// `VkShaderStageFlags`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkShaderStageFlags(pub i32);

/// `1 << 0`  
pub const VK_SHADER_STAGE_VERTEX_BIT: VkShaderStageFlags = VkShaderStageFlags(1 << 0);
/// `1 << 1`  
pub const VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT: VkShaderStageFlags = VkShaderStageFlags(1 << 1);
/// `1 << 2`  
pub const VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT: VkShaderStageFlags = VkShaderStageFlags(1 << 2);
/// `1 << 3`  
pub const VK_SHADER_STAGE_GEOMETRY_BIT: VkShaderStageFlags = VkShaderStageFlags(1 << 3);
/// `1 << 4`  
pub const VK_SHADER_STAGE_FRAGMENT_BIT: VkShaderStageFlags = VkShaderStageFlags(1 << 4);
/// `1 << 5`  
pub const VK_SHADER_STAGE_COMPUTE_BIT: VkShaderStageFlags = VkShaderStageFlags(1 << 5);
/// `0x0000001F`  
pub const VK_SHADER_STAGE_ALL_GRAPHICS: VkShaderStageFlags = VkShaderStageFlags(0x0000001F);
/// `0x7FFFFFFF`  
pub const VK_SHADER_STAGE_ALL: VkShaderStageFlags = VkShaderStageFlags(0x7FFFFFFF);
/// `1 << 8`  
pub const VK_SHADER_STAGE_RAYGEN_BIT_KHR: VkShaderStageFlags = VkShaderStageFlags(1 << 8);
/// `1 << 9`  
pub const VK_SHADER_STAGE_ANY_HIT_BIT_KHR: VkShaderStageFlags = VkShaderStageFlags(1 << 9);
/// `1 << 10`  
pub const VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR: VkShaderStageFlags = VkShaderStageFlags(1 << 10);
/// `1 << 11`  
pub const VK_SHADER_STAGE_MISS_BIT_KHR: VkShaderStageFlags = VkShaderStageFlags(1 << 11);
/// `1 << 12`  
pub const VK_SHADER_STAGE_INTERSECTION_BIT_KHR: VkShaderStageFlags = VkShaderStageFlags(1 << 12);
/// `1 << 13`  
pub const VK_SHADER_STAGE_CALLABLE_BIT_KHR: VkShaderStageFlags = VkShaderStageFlags(1 << 13);
/// `VK_SHADER_STAGE_RAYGEN_BIT_KHR`  
pub const VK_SHADER_STAGE_RAYGEN_BIT_NV: VkShaderStageFlags = VK_SHADER_STAGE_RAYGEN_BIT_KHR;
/// `VK_SHADER_STAGE_ANY_HIT_BIT_KHR`  
pub const VK_SHADER_STAGE_ANY_HIT_BIT_NV: VkShaderStageFlags = VK_SHADER_STAGE_ANY_HIT_BIT_KHR;
/// `VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR`  
pub const VK_SHADER_STAGE_CLOSEST_HIT_BIT_NV: VkShaderStageFlags = VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR;
/// `VK_SHADER_STAGE_MISS_BIT_KHR`  
pub const VK_SHADER_STAGE_MISS_BIT_NV: VkShaderStageFlags = VK_SHADER_STAGE_MISS_BIT_KHR;
/// `VK_SHADER_STAGE_INTERSECTION_BIT_KHR`  
pub const VK_SHADER_STAGE_INTERSECTION_BIT_NV: VkShaderStageFlags = VK_SHADER_STAGE_INTERSECTION_BIT_KHR;
/// `VK_SHADER_STAGE_CALLABLE_BIT_KHR`  
pub const VK_SHADER_STAGE_CALLABLE_BIT_NV: VkShaderStageFlags = VK_SHADER_STAGE_CALLABLE_BIT_KHR;
/// `VK_SHADER_STAGE_TASK_BIT_EXT`  
pub const VK_SHADER_STAGE_TASK_BIT_NV: VkShaderStageFlags = VK_SHADER_STAGE_TASK_BIT_EXT;
/// `VK_SHADER_STAGE_MESH_BIT_EXT`  
pub const VK_SHADER_STAGE_MESH_BIT_NV: VkShaderStageFlags = VK_SHADER_STAGE_MESH_BIT_EXT;
/// `1 << 6`  
pub const VK_SHADER_STAGE_TASK_BIT_EXT: VkShaderStageFlags = VkShaderStageFlags(1 << 6);
/// `1 << 7`  
pub const VK_SHADER_STAGE_MESH_BIT_EXT: VkShaderStageFlags = VkShaderStageFlags(1 << 7);
/// `1 << 14`  
pub const VK_SHADER_STAGE_SUBPASS_SHADING_BIT_HUAWEI: VkShaderStageFlags = VkShaderStageFlags(1 << 14);
/// `1 << 19`  
pub const VK_SHADER_STAGE_CLUSTER_CULLING_BIT_HUAWEI: VkShaderStageFlags = VkShaderStageFlags(1 << 19);
/// `1 << 15`  
pub const VK_SHADER_STAGE_RESERVED_15_BIT_NV: VkShaderStageFlags = VkShaderStageFlags(1 << 15);
/// `1 << 16`  
pub const VK_SHADER_STAGE_RESERVED_16_BIT_HUAWEI: VkShaderStageFlags = VkShaderStageFlags(1 << 16);

impl_flags_display!(VkShaderStageFlags { VK_SHADER_STAGE_VERTEX_BIT, VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT, VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT, VK_SHADER_STAGE_GEOMETRY_BIT, VK_SHADER_STAGE_FRAGMENT_BIT, VK_SHADER_STAGE_COMPUTE_BIT, VK_SHADER_STAGE_ALL_GRAPHICS, VK_SHADER_STAGE_ALL, VK_SHADER_STAGE_RAYGEN_BIT_KHR, VK_SHADER_STAGE_ANY_HIT_BIT_KHR, VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR, VK_SHADER_STAGE_MISS_BIT_KHR, VK_SHADER_STAGE_INTERSECTION_BIT_KHR, VK_SHADER_STAGE_CALLABLE_BIT_KHR, VK_SHADER_STAGE_RAYGEN_BIT_NV, VK_SHADER_STAGE_ANY_HIT_BIT_NV, VK_SHADER_STAGE_CLOSEST_HIT_BIT_NV, VK_SHADER_STAGE_MISS_BIT_NV, VK_SHADER_STAGE_INTERSECTION_BIT_NV, VK_SHADER_STAGE_CALLABLE_BIT_NV, VK_SHADER_STAGE_TASK_BIT_NV, VK_SHADER_STAGE_MESH_BIT_NV, VK_SHADER_STAGE_TASK_BIT_EXT, VK_SHADER_STAGE_MESH_BIT_EXT, VK_SHADER_STAGE_SUBPASS_SHADING_BIT_HUAWEI, VK_SHADER_STAGE_CLUSTER_CULLING_BIT_HUAWEI, VK_SHADER_STAGE_RESERVED_15_BIT_NV, VK_SHADER_STAGE_RESERVED_16_BIT_HUAWEI });

/// `VkShaderStatisticsInfoAMD`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkShaderStatisticsInfoAMD {
    pub shaderStageMask: VkShaderStageFlags,
    pub resourceUsage: VkShaderResourceUsageAMD,
    pub numPhysicalVgprs: uint32_t,
    pub numPhysicalSgprs: uint32_t,
    pub numAvailableVgprs: uint32_t,
    pub numAvailableSgprs: uint32_t,
    pub computeWorkGroupSize: [uint32_t; 3 as usize],
}
impl_default_zeroed!(VkShaderStatisticsInfoAMD);

from_into_transparent!(VkShadingRatePaletteEntryNV: i32);
/// `VkShadingRatePaletteEntryNV`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkShadingRatePaletteEntryNV(pub i32);

/// `0`  
pub const VK_SHADING_RATE_PALETTE_ENTRY_NO_INVOCATIONS_NV: VkShadingRatePaletteEntryNV = VkShadingRatePaletteEntryNV(0);
/// `1`  
pub const VK_SHADING_RATE_PALETTE_ENTRY_16_INVOCATIONS_PER_PIXEL_NV: VkShadingRatePaletteEntryNV = VkShadingRatePaletteEntryNV(1);
/// `2`  
pub const VK_SHADING_RATE_PALETTE_ENTRY_8_INVOCATIONS_PER_PIXEL_NV: VkShadingRatePaletteEntryNV = VkShadingRatePaletteEntryNV(2);
/// `3`  
pub const VK_SHADING_RATE_PALETTE_ENTRY_4_INVOCATIONS_PER_PIXEL_NV: VkShadingRatePaletteEntryNV = VkShadingRatePaletteEntryNV(3);
/// `4`  
pub const VK_SHADING_RATE_PALETTE_ENTRY_2_INVOCATIONS_PER_PIXEL_NV: VkShadingRatePaletteEntryNV = VkShadingRatePaletteEntryNV(4);
/// `5`  
pub const VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_PIXEL_NV: VkShadingRatePaletteEntryNV = VkShadingRatePaletteEntryNV(5);
/// `6`  
pub const VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X1_PIXELS_NV: VkShadingRatePaletteEntryNV = VkShadingRatePaletteEntryNV(6);
/// `7`  
pub const VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_1X2_PIXELS_NV: VkShadingRatePaletteEntryNV = VkShadingRatePaletteEntryNV(7);
/// `8`  
pub const VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X2_PIXELS_NV: VkShadingRatePaletteEntryNV = VkShadingRatePaletteEntryNV(8);
/// `9`  
pub const VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X2_PIXELS_NV: VkShadingRatePaletteEntryNV = VkShadingRatePaletteEntryNV(9);
/// `10`  
pub const VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X4_PIXELS_NV: VkShadingRatePaletteEntryNV = VkShadingRatePaletteEntryNV(10);
/// `11`  
pub const VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X4_PIXELS_NV: VkShadingRatePaletteEntryNV = VkShadingRatePaletteEntryNV(11);

impl_enum_display!(VkShadingRatePaletteEntryNV { VK_SHADING_RATE_PALETTE_ENTRY_NO_INVOCATIONS_NV, VK_SHADING_RATE_PALETTE_ENTRY_16_INVOCATIONS_PER_PIXEL_NV, VK_SHADING_RATE_PALETTE_ENTRY_8_INVOCATIONS_PER_PIXEL_NV, VK_SHADING_RATE_PALETTE_ENTRY_4_INVOCATIONS_PER_PIXEL_NV, VK_SHADING_RATE_PALETTE_ENTRY_2_INVOCATIONS_PER_PIXEL_NV, VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_PIXEL_NV, VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X1_PIXELS_NV, VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_1X2_PIXELS_NV, VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X2_PIXELS_NV, VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X2_PIXELS_NV, VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X4_PIXELS_NV, VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X4_PIXELS_NV });

/// `VkShadingRatePaletteNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkShadingRatePaletteNV {
    pub shadingRatePaletteEntryCount: uint32_t,
    pub pShadingRatePaletteEntries: *const VkShadingRatePaletteEntryNV,
}
impl_default_zeroed!(VkShadingRatePaletteNV);

/// `VkSharedPresentSurfaceCapabilitiesKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkSharedPresentSurfaceCapabilitiesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    /// Supported image usage flags if swapchain created using a shared present mode
    pub sharedPresentSupportedUsageFlags: VkImageUsageFlags,
}
impl_default_zeroed_with_s_type!(VkSharedPresentSurfaceCapabilitiesKHR : VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR);
impl_extends!(VkSharedPresentSurfaceCapabilitiesKHR : VkSurfaceCapabilities2KHR);

from_into_transparent!(VkSharingMode: i32);
/// `VkSharingMode`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkSharingMode(pub i32);

/// `0`  
pub const VK_SHARING_MODE_EXCLUSIVE: VkSharingMode = VkSharingMode(0);
/// `1`  
pub const VK_SHARING_MODE_CONCURRENT: VkSharingMode = VkSharingMode(1);

impl_enum_display!(VkSharingMode { VK_SHARING_MODE_EXCLUSIVE, VK_SHARING_MODE_CONCURRENT });

/// `VkSparseBufferMemoryBindInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkSparseBufferMemoryBindInfo {
    pub buffer: VkBuffer,
    pub bindCount: uint32_t,
    pub pBinds: *const VkSparseMemoryBind,
}
impl_default_zeroed!(VkSparseBufferMemoryBindInfo);

flags!(VkSparseImageFormatFlags);
from_into_transparent!(VkSparseImageFormatFlags: i32);
/// `VkSparseImageFormatFlags`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkSparseImageFormatFlags(pub i32);

/// `1 << 0`  
/// 
/// Image uses a single mip tail region for all array layers
pub const VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT: VkSparseImageFormatFlags = VkSparseImageFormatFlags(1 << 0);
/// `1 << 1`  
/// 
/// Image requires mip level dimensions to be an integer multiple of the sparse image block dimensions for non-tail mip levels.
pub const VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT: VkSparseImageFormatFlags = VkSparseImageFormatFlags(1 << 1);
/// `1 << 2`  
/// 
/// Image uses a non-standard sparse image block dimensions
pub const VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT: VkSparseImageFormatFlags = VkSparseImageFormatFlags(1 << 2);

impl_flags_display!(VkSparseImageFormatFlags { VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT, VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT, VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT });

/// `VkSparseImageFormatProperties`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkSparseImageFormatProperties {
    pub aspectMask: VkImageAspectFlags,
    pub imageGranularity: VkExtent3D,
    pub flags: VkSparseImageFormatFlags,
}
impl_default_zeroed!(VkSparseImageFormatProperties);

/// `VkSparseImageFormatProperties2`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkSparseImageFormatProperties2 {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub properties: VkSparseImageFormatProperties,
}
impl_default_zeroed_with_s_type!(VkSparseImageFormatProperties2 : VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2);

/// `VkSparseImageFormatProperties2`
pub type VkSparseImageFormatProperties2KHR = VkSparseImageFormatProperties2;

/// `VkSparseImageMemoryBind`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkSparseImageMemoryBind {
    pub subresource: VkImageSubresource,
    pub offset: VkOffset3D,
    pub extent: VkExtent3D,
    pub memory: VkDeviceMemory,
    /// Specified in bytes
    pub memoryOffset: VkDeviceSize,
    pub flags: VkSparseMemoryBindFlags,
}
impl_default_zeroed!(VkSparseImageMemoryBind);

/// `VkSparseImageMemoryBindInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkSparseImageMemoryBindInfo {
    pub image: VkImage,
    pub bindCount: uint32_t,
    pub pBinds: *const VkSparseImageMemoryBind,
}
impl_default_zeroed!(VkSparseImageMemoryBindInfo);

/// `VkSparseImageMemoryRequirements`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkSparseImageMemoryRequirements {
    pub formatProperties: VkSparseImageFormatProperties,
    pub imageMipTailFirstLod: uint32_t,
    /// Specified in bytes, must be a multiple of sparse block size in bytes / alignment
    pub imageMipTailSize: VkDeviceSize,
    /// Specified in bytes, must be a multiple of sparse block size in bytes / alignment
    pub imageMipTailOffset: VkDeviceSize,
    /// Specified in bytes, must be a multiple of sparse block size in bytes / alignment
    pub imageMipTailStride: VkDeviceSize,
}
impl_default_zeroed!(VkSparseImageMemoryRequirements);

/// `VkSparseImageMemoryRequirements2`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkSparseImageMemoryRequirements2 {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub memoryRequirements: VkSparseImageMemoryRequirements,
}
impl_default_zeroed_with_s_type!(VkSparseImageMemoryRequirements2 : VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2);

/// `VkSparseImageMemoryRequirements2`
pub type VkSparseImageMemoryRequirements2KHR = VkSparseImageMemoryRequirements2;

/// `VkSparseImageOpaqueMemoryBindInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkSparseImageOpaqueMemoryBindInfo {
    pub image: VkImage,
    pub bindCount: uint32_t,
    pub pBinds: *const VkSparseMemoryBind,
}
impl_default_zeroed!(VkSparseImageOpaqueMemoryBindInfo);

/// `VkSparseMemoryBind`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkSparseMemoryBind {
    /// Specified in bytes
    pub resourceOffset: VkDeviceSize,
    /// Specified in bytes
    pub size: VkDeviceSize,
    pub memory: VkDeviceMemory,
    /// Specified in bytes
    pub memoryOffset: VkDeviceSize,
    pub flags: VkSparseMemoryBindFlags,
}
impl_default_zeroed!(VkSparseMemoryBind);

flags!(VkSparseMemoryBindFlags);
from_into_transparent!(VkSparseMemoryBindFlags: i32);
/// `VkSparseMemoryBindFlags`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkSparseMemoryBindFlags(pub i32);

/// `1 << 0`  
/// 
/// Operation binds resource metadata to memory
pub const VK_SPARSE_MEMORY_BIND_METADATA_BIT: VkSparseMemoryBindFlags = VkSparseMemoryBindFlags(1 << 0);

impl_flags_display!(VkSparseMemoryBindFlags { VK_SPARSE_MEMORY_BIND_METADATA_BIT });

/// `VkSpecializationInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkSpecializationInfo {
    /// Number of entries in the map
    pub mapEntryCount: uint32_t,
    /// Array of map entries
    pub pMapEntries: *const VkSpecializationMapEntry,
    /// Size in bytes of pData
    pub dataSize: size_t,
    /// Pointer to SpecConstant data
    pub pData: *const void,
}
impl_default_zeroed!(VkSpecializationInfo);

/// `VkSpecializationMapEntry`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkSpecializationMapEntry {
    /// The SpecConstant ID specified in the BIL
    pub constantID: uint32_t,
    /// Offset of the value in the data block
    pub offset: uint32_t,
    /// Size in bytes of the SpecConstant
    pub size: size_t,
}
impl_default_zeroed!(VkSpecializationMapEntry);

flags!(VkSpirvResourceTypeFlagsEXT);
from_into_transparent!(VkSpirvResourceTypeFlagsEXT: i32);
/// `VkSpirvResourceTypeFlagsEXT`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkSpirvResourceTypeFlagsEXT(pub i32);

/// `0x7FFFFFFF`  
pub const VK_SPIRV_RESOURCE_TYPE_ALL_EXT: VkSpirvResourceTypeFlagsEXT = VkSpirvResourceTypeFlagsEXT(0x7FFFFFFF);
/// `1 << 0`  
pub const VK_SPIRV_RESOURCE_TYPE_SAMPLER_BIT_EXT: VkSpirvResourceTypeFlagsEXT = VkSpirvResourceTypeFlagsEXT(1 << 0);
/// `1 << 1`  
pub const VK_SPIRV_RESOURCE_TYPE_SAMPLED_IMAGE_BIT_EXT: VkSpirvResourceTypeFlagsEXT = VkSpirvResourceTypeFlagsEXT(1 << 1);
/// `1 << 2`  
pub const VK_SPIRV_RESOURCE_TYPE_READ_ONLY_IMAGE_BIT_EXT: VkSpirvResourceTypeFlagsEXT = VkSpirvResourceTypeFlagsEXT(1 << 2);
/// `1 << 3`  
pub const VK_SPIRV_RESOURCE_TYPE_READ_WRITE_IMAGE_BIT_EXT: VkSpirvResourceTypeFlagsEXT = VkSpirvResourceTypeFlagsEXT(1 << 3);
/// `1 << 4`  
pub const VK_SPIRV_RESOURCE_TYPE_COMBINED_SAMPLED_IMAGE_BIT_EXT: VkSpirvResourceTypeFlagsEXT = VkSpirvResourceTypeFlagsEXT(1 << 4);
/// `1 << 5`  
pub const VK_SPIRV_RESOURCE_TYPE_UNIFORM_BUFFER_BIT_EXT: VkSpirvResourceTypeFlagsEXT = VkSpirvResourceTypeFlagsEXT(1 << 5);
/// `1 << 6`  
pub const VK_SPIRV_RESOURCE_TYPE_READ_ONLY_STORAGE_BUFFER_BIT_EXT: VkSpirvResourceTypeFlagsEXT = VkSpirvResourceTypeFlagsEXT(1 << 6);
/// `1 << 7`  
pub const VK_SPIRV_RESOURCE_TYPE_READ_WRITE_STORAGE_BUFFER_BIT_EXT: VkSpirvResourceTypeFlagsEXT = VkSpirvResourceTypeFlagsEXT(1 << 7);
/// `1 << 8`  
pub const VK_SPIRV_RESOURCE_TYPE_ACCELERATION_STRUCTURE_BIT_EXT: VkSpirvResourceTypeFlagsEXT = VkSpirvResourceTypeFlagsEXT(1 << 8);
/// `1 << 9`  
pub const VK_SPIRV_RESOURCE_TYPE_TENSOR_BIT_ARM: VkSpirvResourceTypeFlagsEXT = VkSpirvResourceTypeFlagsEXT(1 << 9);

impl_flags_display!(VkSpirvResourceTypeFlagsEXT { VK_SPIRV_RESOURCE_TYPE_ALL_EXT, VK_SPIRV_RESOURCE_TYPE_SAMPLER_BIT_EXT, VK_SPIRV_RESOURCE_TYPE_SAMPLED_IMAGE_BIT_EXT, VK_SPIRV_RESOURCE_TYPE_READ_ONLY_IMAGE_BIT_EXT, VK_SPIRV_RESOURCE_TYPE_READ_WRITE_IMAGE_BIT_EXT, VK_SPIRV_RESOURCE_TYPE_COMBINED_SAMPLED_IMAGE_BIT_EXT, VK_SPIRV_RESOURCE_TYPE_UNIFORM_BUFFER_BIT_EXT, VK_SPIRV_RESOURCE_TYPE_READ_ONLY_STORAGE_BUFFER_BIT_EXT, VK_SPIRV_RESOURCE_TYPE_READ_WRITE_STORAGE_BUFFER_BIT_EXT, VK_SPIRV_RESOURCE_TYPE_ACCELERATION_STRUCTURE_BIT_EXT, VK_SPIRV_RESOURCE_TYPE_TENSOR_BIT_ARM });

flags!(VkStencilFaceFlags);
from_into_transparent!(VkStencilFaceFlags: i32);
/// `VkStencilFaceFlags`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkStencilFaceFlags(pub i32);

/// `1 << 0`  
/// 
/// Front face
pub const VK_STENCIL_FACE_FRONT_BIT: VkStencilFaceFlags = VkStencilFaceFlags(1 << 0);
/// `1 << 1`  
/// 
/// Back face
pub const VK_STENCIL_FACE_BACK_BIT: VkStencilFaceFlags = VkStencilFaceFlags(1 << 1);
/// `0x00000003`  
/// 
/// Front and back faces
pub const VK_STENCIL_FACE_FRONT_AND_BACK: VkStencilFaceFlags = VkStencilFaceFlags(0x00000003);
/// `VK_STENCIL_FACE_FRONT_AND_BACK`  
pub const VK_STENCIL_FRONT_AND_BACK: VkStencilFaceFlags = VK_STENCIL_FACE_FRONT_AND_BACK;

impl_flags_display!(VkStencilFaceFlags { VK_STENCIL_FACE_FRONT_BIT, VK_STENCIL_FACE_BACK_BIT, VK_STENCIL_FACE_FRONT_AND_BACK, VK_STENCIL_FRONT_AND_BACK });

from_into_transparent!(VkStencilOp: i32);
/// `VkStencilOp`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkStencilOp(pub i32);

/// `0`  
pub const VK_STENCIL_OP_KEEP: VkStencilOp = VkStencilOp(0);
/// `1`  
pub const VK_STENCIL_OP_ZERO: VkStencilOp = VkStencilOp(1);
/// `2`  
pub const VK_STENCIL_OP_REPLACE: VkStencilOp = VkStencilOp(2);
/// `3`  
pub const VK_STENCIL_OP_INCREMENT_AND_CLAMP: VkStencilOp = VkStencilOp(3);
/// `4`  
pub const VK_STENCIL_OP_DECREMENT_AND_CLAMP: VkStencilOp = VkStencilOp(4);
/// `5`  
pub const VK_STENCIL_OP_INVERT: VkStencilOp = VkStencilOp(5);
/// `6`  
pub const VK_STENCIL_OP_INCREMENT_AND_WRAP: VkStencilOp = VkStencilOp(6);
/// `7`  
pub const VK_STENCIL_OP_DECREMENT_AND_WRAP: VkStencilOp = VkStencilOp(7);

impl_enum_display!(VkStencilOp { VK_STENCIL_OP_KEEP, VK_STENCIL_OP_ZERO, VK_STENCIL_OP_REPLACE, VK_STENCIL_OP_INCREMENT_AND_CLAMP, VK_STENCIL_OP_DECREMENT_AND_CLAMP, VK_STENCIL_OP_INVERT, VK_STENCIL_OP_INCREMENT_AND_WRAP, VK_STENCIL_OP_DECREMENT_AND_WRAP });

/// `VkStencilOpState`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkStencilOpState {
    pub failOp: VkStencilOp,
    pub passOp: VkStencilOp,
    pub depthFailOp: VkStencilOp,
    pub compareOp: VkCompareOp,
    pub compareMask: uint32_t,
    pub writeMask: uint32_t,
    pub reference: uint32_t,
}
impl_default_zeroed!(VkStencilOpState);

flags!(VkStreamDescriptorSurfaceCreateFlagsGGP);
from_into_transparent!(VkStreamDescriptorSurfaceCreateFlagsGGP: i32);
/// `VkStreamDescriptorSurfaceCreateFlagsGGP`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkStreamDescriptorSurfaceCreateFlagsGGP(pub i32);

impl_flags_display!(VkStreamDescriptorSurfaceCreateFlagsGGP {  });

/// `VkStreamDescriptorSurfaceCreateInfoGGP`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkStreamDescriptorSurfaceCreateInfoGGP {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub flags: VkStreamDescriptorSurfaceCreateFlagsGGP,
    pub streamDescriptor: GgpStreamDescriptor,
}
impl_default_zeroed_with_s_type!(VkStreamDescriptorSurfaceCreateInfoGGP : VK_STRUCTURE_TYPE_STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP);

/// `VkStridedDeviceAddressNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkStridedDeviceAddressNV {
    pub startAddress: VkDeviceAddress,
    /// Specified in bytes
    pub strideInBytes: VkDeviceSize,
}
impl_default_zeroed!(VkStridedDeviceAddressNV);

/// `VkStridedDeviceAddressRangeKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkStridedDeviceAddressRangeKHR {
    pub address: VkDeviceAddress,
    pub size: VkDeviceSize,
    pub stride: VkDeviceSize,
}
impl_default_zeroed!(VkStridedDeviceAddressRangeKHR);

/// `VkStridedDeviceAddressRegionKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkStridedDeviceAddressRegionKHR {
    pub deviceAddress: VkDeviceAddress,
    pub stride: VkDeviceSize,
    pub size: VkDeviceSize,
}
impl_default_zeroed!(VkStridedDeviceAddressRegionKHR);

from_into_transparent!(VkStructureType: i32);
/// `VkStructureType`
/// 
/// Structure type enumerant
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkStructureType(pub i32);

/// `0`  
pub const VK_STRUCTURE_TYPE_APPLICATION_INFO: VkStructureType = VkStructureType(0);
/// `1`  
pub const VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO: VkStructureType = VkStructureType(1);
/// `2`  
pub const VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO: VkStructureType = VkStructureType(2);
/// `3`  
pub const VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO: VkStructureType = VkStructureType(3);
/// `4`  
pub const VK_STRUCTURE_TYPE_SUBMIT_INFO: VkStructureType = VkStructureType(4);
/// `5`  
pub const VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO: VkStructureType = VkStructureType(5);
/// `6`  
pub const VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE: VkStructureType = VkStructureType(6);
/// `7`  
pub const VK_STRUCTURE_TYPE_BIND_SPARSE_INFO: VkStructureType = VkStructureType(7);
/// `8`  
pub const VK_STRUCTURE_TYPE_FENCE_CREATE_INFO: VkStructureType = VkStructureType(8);
/// `9`  
pub const VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO: VkStructureType = VkStructureType(9);
/// `10`  
pub const VK_STRUCTURE_TYPE_EVENT_CREATE_INFO: VkStructureType = VkStructureType(10);
/// `11`  
pub const VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO: VkStructureType = VkStructureType(11);
/// `12`  
pub const VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO: VkStructureType = VkStructureType(12);
/// `13`  
pub const VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO: VkStructureType = VkStructureType(13);
/// `14`  
pub const VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO: VkStructureType = VkStructureType(14);
/// `15`  
pub const VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO: VkStructureType = VkStructureType(15);
/// `16`  
pub const VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO: VkStructureType = VkStructureType(16);
/// `17`  
pub const VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO: VkStructureType = VkStructureType(17);
/// `18`  
pub const VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO: VkStructureType = VkStructureType(18);
/// `19`  
pub const VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO: VkStructureType = VkStructureType(19);
/// `20`  
pub const VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO: VkStructureType = VkStructureType(20);
/// `21`  
pub const VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO: VkStructureType = VkStructureType(21);
/// `22`  
pub const VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO: VkStructureType = VkStructureType(22);
/// `23`  
pub const VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO: VkStructureType = VkStructureType(23);
/// `24`  
pub const VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO: VkStructureType = VkStructureType(24);
/// `25`  
pub const VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO: VkStructureType = VkStructureType(25);
/// `26`  
pub const VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO: VkStructureType = VkStructureType(26);
/// `27`  
pub const VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO: VkStructureType = VkStructureType(27);
/// `28`  
pub const VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO: VkStructureType = VkStructureType(28);
/// `29`  
pub const VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO: VkStructureType = VkStructureType(29);
/// `30`  
pub const VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO: VkStructureType = VkStructureType(30);
/// `31`  
pub const VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO: VkStructureType = VkStructureType(31);
/// `32`  
pub const VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO: VkStructureType = VkStructureType(32);
/// `33`  
pub const VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO: VkStructureType = VkStructureType(33);
/// `34`  
pub const VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO: VkStructureType = VkStructureType(34);
/// `35`  
pub const VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET: VkStructureType = VkStructureType(35);
/// `36`  
pub const VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET: VkStructureType = VkStructureType(36);
/// `37`  
pub const VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO: VkStructureType = VkStructureType(37);
/// `38`  
pub const VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO: VkStructureType = VkStructureType(38);
/// `39`  
pub const VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO: VkStructureType = VkStructureType(39);
/// `40`  
pub const VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO: VkStructureType = VkStructureType(40);
/// `41`  
pub const VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO: VkStructureType = VkStructureType(41);
/// `42`  
pub const VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO: VkStructureType = VkStructureType(42);
/// `43`  
pub const VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO: VkStructureType = VkStructureType(43);
/// `44`  
pub const VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER: VkStructureType = VkStructureType(44);
/// `45`  
pub const VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER: VkStructureType = VkStructureType(45);
/// `46`  
pub const VK_STRUCTURE_TYPE_MEMORY_BARRIER: VkStructureType = VkStructureType(46);
/// `47`  
/// 
/// Reserved for internal use by the loader, layers, and ICDs
pub const VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO: VkStructureType = VkStructureType(47);
/// `48`  
/// 
/// Reserved for internal use by the loader, layers, and ICDs
pub const VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO: VkStructureType = VkStructureType(48);
/// `1000157000`  
pub const VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO: VkStructureType = VkStructureType(1000157000);
/// `1000157001`  
pub const VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO: VkStructureType = VkStructureType(1000157001);
/// `1000127000`  
pub const VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS: VkStructureType = VkStructureType(1000127000);
/// `1000127001`  
pub const VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO: VkStructureType = VkStructureType(1000127001);
/// `1000060000`  
pub const VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO: VkStructureType = VkStructureType(1000060000);
/// `1000060004`  
pub const VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO: VkStructureType = VkStructureType(1000060004);
/// `1000060005`  
pub const VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO: VkStructureType = VkStructureType(1000060005);
/// `1000060006`  
pub const VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO: VkStructureType = VkStructureType(1000060006);
/// `1000060013`  
pub const VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO: VkStructureType = VkStructureType(1000060013);
/// `1000060014`  
pub const VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO: VkStructureType = VkStructureType(1000060014);
/// `1000070000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES: VkStructureType = VkStructureType(1000070000);
/// `1000070001`  
pub const VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO: VkStructureType = VkStructureType(1000070001);
/// `1000146000`  
pub const VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2: VkStructureType = VkStructureType(1000146000);
/// `1000146001`  
pub const VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2: VkStructureType = VkStructureType(1000146001);
/// `1000146002`  
pub const VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2: VkStructureType = VkStructureType(1000146002);
/// `1000146003`  
pub const VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2: VkStructureType = VkStructureType(1000146003);
/// `1000146004`  
pub const VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2: VkStructureType = VkStructureType(1000146004);
/// `1000059000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2: VkStructureType = VkStructureType(1000059000);
/// `1000059001`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2: VkStructureType = VkStructureType(1000059001);
/// `1000059002`  
pub const VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2: VkStructureType = VkStructureType(1000059002);
/// `1000059003`  
pub const VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2: VkStructureType = VkStructureType(1000059003);
/// `1000059004`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2: VkStructureType = VkStructureType(1000059004);
/// `1000059005`  
pub const VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2: VkStructureType = VkStructureType(1000059005);
/// `1000059006`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2: VkStructureType = VkStructureType(1000059006);
/// `1000059007`  
pub const VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2: VkStructureType = VkStructureType(1000059007);
/// `1000059008`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2: VkStructureType = VkStructureType(1000059008);
/// `1000117002`  
pub const VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO: VkStructureType = VkStructureType(1000117002);
/// `1000145000`  
pub const VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO: VkStructureType = VkStructureType(1000145000);
/// `1000145001`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES: VkStructureType = VkStructureType(1000145001);
/// `1000145002`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES: VkStructureType = VkStructureType(1000145002);
/// `1000145003`  
pub const VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2: VkStructureType = VkStructureType(1000145003);
/// `1000071000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO: VkStructureType = VkStructureType(1000071000);
/// `1000071001`  
pub const VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES: VkStructureType = VkStructureType(1000071001);
/// `1000071002`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO: VkStructureType = VkStructureType(1000071002);
/// `1000071003`  
pub const VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES: VkStructureType = VkStructureType(1000071003);
/// `1000071004`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES: VkStructureType = VkStructureType(1000071004);
/// `1000072000`  
pub const VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO: VkStructureType = VkStructureType(1000072000);
/// `1000072001`  
pub const VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO: VkStructureType = VkStructureType(1000072001);
/// `1000072002`  
pub const VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO: VkStructureType = VkStructureType(1000072002);
/// `1000112000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO: VkStructureType = VkStructureType(1000112000);
/// `1000112001`  
pub const VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES: VkStructureType = VkStructureType(1000112001);
/// `1000113000`  
pub const VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO: VkStructureType = VkStructureType(1000113000);
/// `1000077000`  
pub const VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO: VkStructureType = VkStructureType(1000077000);
/// `1000076000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO: VkStructureType = VkStructureType(1000076000);
/// `1000076001`  
pub const VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES: VkStructureType = VkStructureType(1000076001);
/// `1000094000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES: VkStructureType = VkStructureType(1000094000);
/// `1000083000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES: VkStructureType = VkStructureType(1000083000);
/// `1000120000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES: VkStructureType = VkStructureType(1000120000);
/// `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES;
/// `1000085000`  
pub const VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO: VkStructureType = VkStructureType(1000085000);
/// `1000168000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES: VkStructureType = VkStructureType(1000168000);
/// `1000168001`  
pub const VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT: VkStructureType = VkStructureType(1000168001);
/// `1000156000`  
pub const VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO: VkStructureType = VkStructureType(1000156000);
/// `1000156001`  
pub const VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO: VkStructureType = VkStructureType(1000156001);
/// `1000156002`  
pub const VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO: VkStructureType = VkStructureType(1000156002);
/// `1000156003`  
pub const VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO: VkStructureType = VkStructureType(1000156003);
/// `1000156004`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES: VkStructureType = VkStructureType(1000156004);
/// `1000156005`  
pub const VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES: VkStructureType = VkStructureType(1000156005);
/// `1000060003`  
pub const VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO: VkStructureType = VkStructureType(1000060003);
/// `1000117000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES: VkStructureType = VkStructureType(1000117000);
/// `1000117001`  
pub const VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO: VkStructureType = VkStructureType(1000117001);
/// `1000117003`  
pub const VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO: VkStructureType = VkStructureType(1000117003);
/// `1000053000`  
pub const VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO: VkStructureType = VkStructureType(1000053000);
/// `1000053001`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES: VkStructureType = VkStructureType(1000053001);
/// `1000053002`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES: VkStructureType = VkStructureType(1000053002);
/// `1000063000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES: VkStructureType = VkStructureType(1000063000);
/// `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES;
/// `1000196000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES: VkStructureType = VkStructureType(1000196000);
/// `49`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: VkStructureType = VkStructureType(49);
/// `50`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES: VkStructureType = VkStructureType(50);
/// `51`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: VkStructureType = VkStructureType(51);
/// `52`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES: VkStructureType = VkStructureType(52);
/// `1000147000`  
pub const VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO: VkStructureType = VkStructureType(1000147000);
/// `1000211000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES: VkStructureType = VkStructureType(1000211000);
/// `1000261000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES: VkStructureType = VkStructureType(1000261000);
/// `1000207000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES: VkStructureType = VkStructureType(1000207000);
/// `1000207001`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES: VkStructureType = VkStructureType(1000207001);
/// `1000207002`  
pub const VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO: VkStructureType = VkStructureType(1000207002);
/// `1000207003`  
pub const VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO: VkStructureType = VkStructureType(1000207003);
/// `1000207004`  
pub const VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO: VkStructureType = VkStructureType(1000207004);
/// `1000207005`  
pub const VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO: VkStructureType = VkStructureType(1000207005);
/// `1000257000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES: VkStructureType = VkStructureType(1000257000);
/// `1000244001`  
pub const VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO: VkStructureType = VkStructureType(1000244001);
/// `1000257002`  
pub const VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO: VkStructureType = VkStructureType(1000257002);
/// `1000257003`  
pub const VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO: VkStructureType = VkStructureType(1000257003);
/// `1000257004`  
pub const VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO: VkStructureType = VkStructureType(1000257004);
/// `1000177000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES: VkStructureType = VkStructureType(1000177000);
/// `1000180000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES: VkStructureType = VkStructureType(1000180000);
/// `1000082000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES: VkStructureType = VkStructureType(1000082000);
/// `1000197000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES: VkStructureType = VkStructureType(1000197000);
/// `1000161000`  
pub const VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO: VkStructureType = VkStructureType(1000161000);
/// `1000161001`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES: VkStructureType = VkStructureType(1000161001);
/// `1000161002`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES: VkStructureType = VkStructureType(1000161002);
/// `1000161003`  
pub const VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO: VkStructureType = VkStructureType(1000161003);
/// `1000161004`  
pub const VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT: VkStructureType = VkStructureType(1000161004);
/// `1000221000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES: VkStructureType = VkStructureType(1000221000);
/// `1000130000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES: VkStructureType = VkStructureType(1000130000);
/// `1000130001`  
pub const VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO: VkStructureType = VkStructureType(1000130001);
/// `1000253000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES: VkStructureType = VkStructureType(1000253000);
/// `1000175000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES: VkStructureType = VkStructureType(1000175000);
/// `1000109000`  
pub const VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2: VkStructureType = VkStructureType(1000109000);
/// `1000109001`  
pub const VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2: VkStructureType = VkStructureType(1000109001);
/// `1000109002`  
pub const VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2: VkStructureType = VkStructureType(1000109002);
/// `1000109003`  
pub const VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2: VkStructureType = VkStructureType(1000109003);
/// `1000109004`  
pub const VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2: VkStructureType = VkStructureType(1000109004);
/// `1000109005`  
pub const VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO: VkStructureType = VkStructureType(1000109005);
/// `1000109006`  
pub const VK_STRUCTURE_TYPE_SUBPASS_END_INFO: VkStructureType = VkStructureType(1000109006);
/// `1000199000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES: VkStructureType = VkStructureType(1000199000);
/// `1000199001`  
pub const VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE: VkStructureType = VkStructureType(1000199001);
/// `1000246000`  
pub const VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO: VkStructureType = VkStructureType(1000246000);
/// `1000108000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES: VkStructureType = VkStructureType(1000108000);
/// `1000108001`  
pub const VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO: VkStructureType = VkStructureType(1000108001);
/// `1000108002`  
pub const VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO: VkStructureType = VkStructureType(1000108002);
/// `1000108003`  
pub const VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO: VkStructureType = VkStructureType(1000108003);
/// `1000241000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES: VkStructureType = VkStructureType(1000241000);
/// `1000241001`  
pub const VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT: VkStructureType = VkStructureType(1000241001);
/// `1000241002`  
pub const VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT: VkStructureType = VkStructureType(1000241002);
/// `53`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES: VkStructureType = VkStructureType(53);
/// `54`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES: VkStructureType = VkStructureType(54);
/// `1000245000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES: VkStructureType = VkStructureType(1000245000);
/// `1000295000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES: VkStructureType = VkStructureType(1000295000);
/// `1000295001`  
pub const VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO: VkStructureType = VkStructureType(1000295001);
/// `1000295002`  
pub const VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO: VkStructureType = VkStructureType(1000295002);
/// `1000314000`  
pub const VK_STRUCTURE_TYPE_MEMORY_BARRIER_2: VkStructureType = VkStructureType(1000314000);
/// `1000314001`  
pub const VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2: VkStructureType = VkStructureType(1000314001);
/// `1000314002`  
pub const VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2: VkStructureType = VkStructureType(1000314002);
/// `1000314003`  
pub const VK_STRUCTURE_TYPE_DEPENDENCY_INFO: VkStructureType = VkStructureType(1000314003);
/// `1000314004`  
pub const VK_STRUCTURE_TYPE_SUBMIT_INFO_2: VkStructureType = VkStructureType(1000314004);
/// `1000314005`  
pub const VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO: VkStructureType = VkStructureType(1000314005);
/// `1000314006`  
pub const VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO: VkStructureType = VkStructureType(1000314006);
/// `1000314007`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES: VkStructureType = VkStructureType(1000314007);
/// `1000337000`  
pub const VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2: VkStructureType = VkStructureType(1000337000);
/// `1000337001`  
pub const VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2: VkStructureType = VkStructureType(1000337001);
/// `1000337002`  
pub const VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2: VkStructureType = VkStructureType(1000337002);
/// `1000337003`  
pub const VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2: VkStructureType = VkStructureType(1000337003);
/// `1000337006`  
pub const VK_STRUCTURE_TYPE_BUFFER_COPY_2: VkStructureType = VkStructureType(1000337006);
/// `1000337007`  
pub const VK_STRUCTURE_TYPE_IMAGE_COPY_2: VkStructureType = VkStructureType(1000337007);
/// `1000337009`  
pub const VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2: VkStructureType = VkStructureType(1000337009);
/// `1000066000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES: VkStructureType = VkStructureType(1000066000);
/// `1000360000`  
pub const VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3: VkStructureType = VkStructureType(1000360000);
/// `1000413000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES: VkStructureType = VkStructureType(1000413000);
/// `1000413001`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES: VkStructureType = VkStructureType(1000413001);
/// `1000413002`  
pub const VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS: VkStructureType = VkStructureType(1000413002);
/// `1000413003`  
pub const VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS: VkStructureType = VkStructureType(1000413003);
/// `1000192000`  
pub const VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO: VkStructureType = VkStructureType(1000192000);
/// `1000215000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES: VkStructureType = VkStructureType(1000215000);
/// `1000276000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES: VkStructureType = VkStructureType(1000276000);
/// `1000297000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES: VkStructureType = VkStructureType(1000297000);
/// `1000325000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES: VkStructureType = VkStructureType(1000325000);
/// `1000335000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES: VkStructureType = VkStructureType(1000335000);
/// `1000225000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES: VkStructureType = VkStructureType(1000225000);
/// `1000225001`  
pub const VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO: VkStructureType = VkStructureType(1000225001);
/// `1000225002`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES: VkStructureType = VkStructureType(1000225002);
/// `1000138000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES: VkStructureType = VkStructureType(1000138000);
/// `1000138001`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES: VkStructureType = VkStructureType(1000138001);
/// `1000138002`  
pub const VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK: VkStructureType = VkStructureType(1000138002);
/// `1000138003`  
pub const VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO: VkStructureType = VkStructureType(1000138003);
/// `1000280000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES: VkStructureType = VkStructureType(1000280000);
/// `1000280001`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES: VkStructureType = VkStructureType(1000280001);
/// `1000281001`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES: VkStructureType = VkStructureType(1000281001);
/// `1000337004`  
pub const VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2: VkStructureType = VkStructureType(1000337004);
/// `1000337005`  
pub const VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2: VkStructureType = VkStructureType(1000337005);
/// `1000337008`  
pub const VK_STRUCTURE_TYPE_IMAGE_BLIT_2: VkStructureType = VkStructureType(1000337008);
/// `1000337010`  
pub const VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2: VkStructureType = VkStructureType(1000337010);
/// `1000044000`  
pub const VK_STRUCTURE_TYPE_RENDERING_INFO: VkStructureType = VkStructureType(1000044000);
/// `1000044001`  
pub const VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO: VkStructureType = VkStructureType(1000044001);
/// `1000044002`  
pub const VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO: VkStructureType = VkStructureType(1000044002);
/// `1000044003`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES: VkStructureType = VkStructureType(1000044003);
/// `1000044004`  
pub const VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO: VkStructureType = VkStructureType(1000044004);
/// `55`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES: VkStructureType = VkStructureType(55);
/// `56`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_PROPERTIES: VkStructureType = VkStructureType(56);
/// `1000174000`  
pub const VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO: VkStructureType = VkStructureType(1000174000);
/// `1000388000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES: VkStructureType = VkStructureType(1000388000);
/// `1000388001`  
pub const VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES: VkStructureType = VkStructureType(1000388001);
/// `1000265000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES: VkStructureType = VkStructureType(1000265000);
/// `1000271000`  
pub const VK_STRUCTURE_TYPE_MEMORY_MAP_INFO: VkStructureType = VkStructureType(1000271000);
/// `1000271001`  
pub const VK_STRUCTURE_TYPE_MEMORY_UNMAP_INFO: VkStructureType = VkStructureType(1000271001);
/// `1000470000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES: VkStructureType = VkStructureType(1000470000);
/// `1000470001`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES: VkStructureType = VkStructureType(1000470001);
/// `1000470004`  
pub const VK_STRUCTURE_TYPE_DEVICE_IMAGE_SUBRESOURCE_INFO: VkStructureType = VkStructureType(1000470004);
/// `1000338002`  
pub const VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2: VkStructureType = VkStructureType(1000338002);
/// `1000338003`  
pub const VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2: VkStructureType = VkStructureType(1000338003);
/// `1000470006`  
pub const VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO: VkStructureType = VkStructureType(1000470006);
/// `1000545000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES: VkStructureType = VkStructureType(1000545000);
/// `1000545001`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES: VkStructureType = VkStructureType(1000545001);
/// `1000545002`  
pub const VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS: VkStructureType = VkStructureType(1000545002);
/// `1000270000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES: VkStructureType = VkStructureType(1000270000);
/// `1000270001`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES: VkStructureType = VkStructureType(1000270001);
/// `1000270002`  
pub const VK_STRUCTURE_TYPE_MEMORY_TO_IMAGE_COPY: VkStructureType = VkStructureType(1000270002);
/// `1000270003`  
pub const VK_STRUCTURE_TYPE_IMAGE_TO_MEMORY_COPY: VkStructureType = VkStructureType(1000270003);
/// `1000270004`  
pub const VK_STRUCTURE_TYPE_COPY_IMAGE_TO_MEMORY_INFO: VkStructureType = VkStructureType(1000270004);
/// `1000270005`  
pub const VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INFO: VkStructureType = VkStructureType(1000270005);
/// `1000270006`  
pub const VK_STRUCTURE_TYPE_HOST_IMAGE_LAYOUT_TRANSITION_INFO: VkStructureType = VkStructureType(1000270006);
/// `1000270007`  
pub const VK_STRUCTURE_TYPE_COPY_IMAGE_TO_IMAGE_INFO: VkStructureType = VkStructureType(1000270007);
/// `1000270008`  
pub const VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE: VkStructureType = VkStructureType(1000270008);
/// `1000270009`  
pub const VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY: VkStructureType = VkStructureType(1000270009);
/// `1000416000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES: VkStructureType = VkStructureType(1000416000);
/// `1000528000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES: VkStructureType = VkStructureType(1000528000);
/// `1000544000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES: VkStructureType = VkStructureType(1000544000);
/// `1000470005`  
pub const VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO: VkStructureType = VkStructureType(1000470005);
/// `1000080000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES: VkStructureType = VkStructureType(1000080000);
/// `1000545003`  
pub const VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_SETS_INFO: VkStructureType = VkStructureType(1000545003);
/// `1000545004`  
pub const VK_STRUCTURE_TYPE_PUSH_CONSTANTS_INFO: VkStructureType = VkStructureType(1000545004);
/// `1000545005`  
pub const VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_INFO: VkStructureType = VkStructureType(1000545005);
/// `1000545006`  
pub const VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO: VkStructureType = VkStructureType(1000545006);
/// `1000466000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES: VkStructureType = VkStructureType(1000466000);
/// `1000068000`  
pub const VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO: VkStructureType = VkStructureType(1000068000);
/// `1000068001`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES: VkStructureType = VkStructureType(1000068001);
/// `1000068002`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES: VkStructureType = VkStructureType(1000068002);
/// `1000259000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES: VkStructureType = VkStructureType(1000259000);
/// `1000259001`  
pub const VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO: VkStructureType = VkStructureType(1000259001);
/// `1000259002`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES: VkStructureType = VkStructureType(1000259002);
/// `1000525000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES: VkStructureType = VkStructureType(1000525000);
/// `1000190001`  
pub const VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO: VkStructureType = VkStructureType(1000190001);
/// `1000190002`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES: VkStructureType = VkStructureType(1000190002);
/// `1000470003`  
pub const VK_STRUCTURE_TYPE_RENDERING_AREA_INFO: VkStructureType = VkStructureType(1000470003);
/// `1000232000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES: VkStructureType = VkStructureType(1000232000);
/// `1000232001`  
pub const VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO: VkStructureType = VkStructureType(1000232001);
/// `1000232002`  
pub const VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO: VkStructureType = VkStructureType(1000232002);
/// `1000298000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_SC_1_0_FEATURES: VkStructureType = VkStructureType(1000298000);
/// `1000298001`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_SC_1_0_PROPERTIES: VkStructureType = VkStructureType(1000298001);
/// `1000298002`  
pub const VK_STRUCTURE_TYPE_DEVICE_OBJECT_RESERVATION_CREATE_INFO: VkStructureType = VkStructureType(1000298002);
/// `1000298003`  
pub const VK_STRUCTURE_TYPE_COMMAND_POOL_MEMORY_RESERVATION_CREATE_INFO: VkStructureType = VkStructureType(1000298003);
/// `1000298004`  
pub const VK_STRUCTURE_TYPE_COMMAND_POOL_MEMORY_CONSUMPTION: VkStructureType = VkStructureType(1000298004);
/// `1000298005`  
pub const VK_STRUCTURE_TYPE_PIPELINE_POOL_SIZE: VkStructureType = VkStructureType(1000298005);
/// `1000298007`  
pub const VK_STRUCTURE_TYPE_FAULT_DATA: VkStructureType = VkStructureType(1000298007);
/// `1000298008`  
pub const VK_STRUCTURE_TYPE_FAULT_CALLBACK_INFO: VkStructureType = VkStructureType(1000298008);
/// `1000298010`  
pub const VK_STRUCTURE_TYPE_PIPELINE_OFFLINE_CREATE_INFO: VkStructureType = VkStructureType(1000298010);
/// `1000001000`  
pub const VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR: VkStructureType = VkStructureType(1000001000);
/// `1000001001`  
pub const VK_STRUCTURE_TYPE_PRESENT_INFO_KHR: VkStructureType = VkStructureType(1000001001);
/// `1000060007`  
pub const VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR: VkStructureType = VkStructureType(1000060007);
/// `1000060008`  
pub const VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR: VkStructureType = VkStructureType(1000060008);
/// `1000060009`  
pub const VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR: VkStructureType = VkStructureType(1000060009);
/// `1000060010`  
pub const VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR: VkStructureType = VkStructureType(1000060010);
/// `1000060011`  
pub const VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR: VkStructureType = VkStructureType(1000060011);
/// `1000060012`  
pub const VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR: VkStructureType = VkStructureType(1000060012);
/// `1000002000`  
pub const VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR: VkStructureType = VkStructureType(1000002000);
/// `1000002001`  
pub const VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR: VkStructureType = VkStructureType(1000002001);
/// `1000003000`  
pub const VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR: VkStructureType = VkStructureType(1000003000);
/// `1000004000`  
pub const VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR: VkStructureType = VkStructureType(1000004000);
/// `1000005000`  
pub const VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR: VkStructureType = VkStructureType(1000005000);
/// `1000006000`  
pub const VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR: VkStructureType = VkStructureType(1000006000);
/// `1000008000`  
pub const VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR: VkStructureType = VkStructureType(1000008000);
/// `1000009000`  
pub const VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR: VkStructureType = VkStructureType(1000009000);
/// `1000010000`  
pub const VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID: VkStructureType = VkStructureType(1000010000);
/// `1000010001`  
pub const VK_STRUCTURE_TYPE_SWAPCHAIN_IMAGE_CREATE_INFO_ANDROID: VkStructureType = VkStructureType(1000010001);
/// `1000010002`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENTATION_PROPERTIES_ANDROID: VkStructureType = VkStructureType(1000010002);
/// `1000011000`  
pub const VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT: VkStructureType = VkStructureType(1000011000);
/// `VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT`  
pub const VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT: VkStructureType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT;
/// `1000018000`  
pub const VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD: VkStructureType = VkStructureType(1000018000);
/// `1000022000`  
pub const VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT: VkStructureType = VkStructureType(1000022000);
/// `1000022001`  
pub const VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT: VkStructureType = VkStructureType(1000022001);
/// `1000022002`  
pub const VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT: VkStructureType = VkStructureType(1000022002);
/// `1000023000`  
pub const VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR: VkStructureType = VkStructureType(1000023000);
/// `1000023001`  
pub const VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR: VkStructureType = VkStructureType(1000023001);
/// `1000023002`  
pub const VK_STRUCTURE_TYPE_VIDEO_PICTURE_RESOURCE_INFO_KHR: VkStructureType = VkStructureType(1000023002);
/// `1000023003`  
pub const VK_STRUCTURE_TYPE_VIDEO_SESSION_MEMORY_REQUIREMENTS_KHR: VkStructureType = VkStructureType(1000023003);
/// `1000023004`  
pub const VK_STRUCTURE_TYPE_BIND_VIDEO_SESSION_MEMORY_INFO_KHR: VkStructureType = VkStructureType(1000023004);
/// `1000023005`  
pub const VK_STRUCTURE_TYPE_VIDEO_SESSION_CREATE_INFO_KHR: VkStructureType = VkStructureType(1000023005);
/// `1000023006`  
pub const VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR: VkStructureType = VkStructureType(1000023006);
/// `1000023007`  
pub const VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR: VkStructureType = VkStructureType(1000023007);
/// `1000023008`  
pub const VK_STRUCTURE_TYPE_VIDEO_BEGIN_CODING_INFO_KHR: VkStructureType = VkStructureType(1000023008);
/// `1000023009`  
pub const VK_STRUCTURE_TYPE_VIDEO_END_CODING_INFO_KHR: VkStructureType = VkStructureType(1000023009);
/// `1000023010`  
pub const VK_STRUCTURE_TYPE_VIDEO_CODING_CONTROL_INFO_KHR: VkStructureType = VkStructureType(1000023010);
/// `1000023011`  
pub const VK_STRUCTURE_TYPE_VIDEO_REFERENCE_SLOT_INFO_KHR: VkStructureType = VkStructureType(1000023011);
/// `1000023012`  
pub const VK_STRUCTURE_TYPE_QUEUE_FAMILY_VIDEO_PROPERTIES_KHR: VkStructureType = VkStructureType(1000023012);
/// `1000023013`  
pub const VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR: VkStructureType = VkStructureType(1000023013);
/// `1000023014`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR: VkStructureType = VkStructureType(1000023014);
/// `1000023015`  
pub const VK_STRUCTURE_TYPE_VIDEO_FORMAT_PROPERTIES_KHR: VkStructureType = VkStructureType(1000023015);
/// `1000023016`  
pub const VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR: VkStructureType = VkStructureType(1000023016);
/// `1000024000`  
pub const VK_STRUCTURE_TYPE_VIDEO_DECODE_INFO_KHR: VkStructureType = VkStructureType(1000024000);
/// `1000024001`  
pub const VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR: VkStructureType = VkStructureType(1000024001);
/// `1000024002`  
pub const VK_STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR: VkStructureType = VkStructureType(1000024002);
/// `1000026000`  
pub const VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV: VkStructureType = VkStructureType(1000026000);
/// `1000026001`  
pub const VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV: VkStructureType = VkStructureType(1000026001);
/// `1000026002`  
pub const VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV: VkStructureType = VkStructureType(1000026002);
/// `1000028000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT: VkStructureType = VkStructureType(1000028000);
/// `1000028001`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT: VkStructureType = VkStructureType(1000028001);
/// `1000028002`  
pub const VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT: VkStructureType = VkStructureType(1000028002);
/// `1000029000`  
pub const VK_STRUCTURE_TYPE_CU_MODULE_CREATE_INFO_NVX: VkStructureType = VkStructureType(1000029000);
/// `1000029001`  
pub const VK_STRUCTURE_TYPE_CU_FUNCTION_CREATE_INFO_NVX: VkStructureType = VkStructureType(1000029001);
/// `1000029002`  
pub const VK_STRUCTURE_TYPE_CU_LAUNCH_INFO_NVX: VkStructureType = VkStructureType(1000029002);
/// `1000029004`  
pub const VK_STRUCTURE_TYPE_CU_MODULE_TEXTURING_MODE_CREATE_INFO_NVX: VkStructureType = VkStructureType(1000029004);
/// `1000030000`  
pub const VK_STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX: VkStructureType = VkStructureType(1000030000);
/// `1000030001`  
pub const VK_STRUCTURE_TYPE_IMAGE_VIEW_ADDRESS_PROPERTIES_NVX: VkStructureType = VkStructureType(1000030001);
/// `1000038000`  
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_KHR: VkStructureType = VkStructureType(1000038000);
/// `1000038001`  
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR: VkStructureType = VkStructureType(1000038001);
/// `1000038002`  
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR: VkStructureType = VkStructureType(1000038002);
/// `1000038003`  
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PICTURE_INFO_KHR: VkStructureType = VkStructureType(1000038003);
/// `1000038004`  
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_KHR: VkStructureType = VkStructureType(1000038004);
/// `1000038005`  
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_NALU_SLICE_INFO_KHR: VkStructureType = VkStructureType(1000038005);
/// `1000038006`  
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_GOP_REMAINING_FRAME_INFO_KHR: VkStructureType = VkStructureType(1000038006);
/// `1000038007`  
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_KHR: VkStructureType = VkStructureType(1000038007);
/// `1000038008`  
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_KHR: VkStructureType = VkStructureType(1000038008);
/// `1000038009`  
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_KHR: VkStructureType = VkStructureType(1000038009);
/// `1000038010`  
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_KHR: VkStructureType = VkStructureType(1000038010);
/// `1000038011`  
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_KHR: VkStructureType = VkStructureType(1000038011);
/// `1000038012`  
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_GET_INFO_KHR: VkStructureType = VkStructureType(1000038012);
/// `1000038013`  
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_FEEDBACK_INFO_KHR: VkStructureType = VkStructureType(1000038013);
/// `1000039000`  
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_KHR: VkStructureType = VkStructureType(1000039000);
/// `1000039001`  
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR: VkStructureType = VkStructureType(1000039001);
/// `1000039002`  
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR: VkStructureType = VkStructureType(1000039002);
/// `1000039003`  
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PICTURE_INFO_KHR: VkStructureType = VkStructureType(1000039003);
/// `1000039004`  
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_KHR: VkStructureType = VkStructureType(1000039004);
/// `1000039005`  
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO_KHR: VkStructureType = VkStructureType(1000039005);
/// `1000039006`  
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_GOP_REMAINING_FRAME_INFO_KHR: VkStructureType = VkStructureType(1000039006);
/// `1000039007`  
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_KHR: VkStructureType = VkStructureType(1000039007);
/// `1000039009`  
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_KHR: VkStructureType = VkStructureType(1000039009);
/// `1000039010`  
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_KHR: VkStructureType = VkStructureType(1000039010);
/// `1000039011`  
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_KHR: VkStructureType = VkStructureType(1000039011);
/// `1000039012`  
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUALITY_LEVEL_PROPERTIES_KHR: VkStructureType = VkStructureType(1000039012);
/// `1000039013`  
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_GET_INFO_KHR: VkStructureType = VkStructureType(1000039013);
/// `1000039014`  
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_FEEDBACK_INFO_KHR: VkStructureType = VkStructureType(1000039014);
/// `1000040000`  
pub const VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_KHR: VkStructureType = VkStructureType(1000040000);
/// `1000040001`  
pub const VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_KHR: VkStructureType = VkStructureType(1000040001);
/// `1000040003`  
pub const VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_KHR: VkStructureType = VkStructureType(1000040003);
/// `1000040004`  
pub const VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR: VkStructureType = VkStructureType(1000040004);
/// `1000040005`  
pub const VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR: VkStructureType = VkStructureType(1000040005);
/// `1000040006`  
pub const VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR: VkStructureType = VkStructureType(1000040006);
/// `1000041000`  
pub const VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD: VkStructureType = VkStructureType(1000041000);
/// `VK_STRUCTURE_TYPE_RENDERING_INFO`  
pub const VK_STRUCTURE_TYPE_RENDERING_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_RENDERING_INFO;
/// `VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO`  
pub const VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO;
/// `VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO`  
pub const VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO;
/// `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES;
/// `VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO`  
pub const VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO;
/// `1000049000`  
pub const VK_STRUCTURE_TYPE_STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP: VkStructureType = VkStructureType(1000049000);
/// `1000050000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV: VkStructureType = VkStructureType(1000050000);
/// `1000051000`  
pub const VK_STRUCTURE_TYPE_PRIVATE_VENDOR_INFO_PLACEHOLDER_OFFSET_0_NV: VkStructureType = VkStructureType(1000051000);
/// `VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO`  
pub const VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO;
/// `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES;
/// `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES;
/// `1000056000`  
pub const VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV: VkStructureType = VkStructureType(1000056000);
/// `1000056001`  
pub const VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV: VkStructureType = VkStructureType(1000056001);
/// `1000057000`  
pub const VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV: VkStructureType = VkStructureType(1000057000);
/// `1000057001`  
pub const VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV: VkStructureType = VkStructureType(1000057001);
/// `1000058000`  
pub const VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV: VkStructureType = VkStructureType(1000058000);
/// `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
/// `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2;
/// `VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2`  
pub const VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2;
/// `VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2`  
pub const VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2;
/// `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2;
/// `VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2`  
pub const VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2;
/// `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2;
/// `VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2`  
pub const VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2;
/// `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2;
/// `VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO`  
pub const VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO;
/// `VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO`  
pub const VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO;
/// `VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO`  
pub const VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO;
/// `VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO`  
pub const VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO;
/// `VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO`  
pub const VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO;
/// `VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO`  
pub const VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO;
/// `VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO`  
pub const VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO;
/// `1000061000`  
pub const VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT: VkStructureType = VkStructureType(1000061000);
/// `1000062000`  
pub const VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN: VkStructureType = VkStructureType(1000062000);
/// `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES;
/// `1000067000`  
pub const VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT: VkStructureType = VkStructureType(1000067000);
/// `1000067001`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT: VkStructureType = VkStructureType(1000067001);
/// `VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO`  
pub const VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO;
/// `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES;
/// `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES;
/// `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES;
/// `VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO`  
pub const VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO;
/// `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO;
/// `VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES`  
pub const VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHR: VkStructureType = VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES;
/// `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO;
/// `VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES`  
pub const VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES_KHR: VkStructureType = VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES;
/// `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES;
/// `VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO`  
pub const VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO;
/// `VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO`  
pub const VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO;
/// `VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO`  
pub const VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO;
/// `1000073000`  
pub const VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR: VkStructureType = VkStructureType(1000073000);
/// `1000073001`  
pub const VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR: VkStructureType = VkStructureType(1000073001);
/// `1000073002`  
pub const VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR: VkStructureType = VkStructureType(1000073002);
/// `1000073003`  
pub const VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR: VkStructureType = VkStructureType(1000073003);
/// `1000074000`  
pub const VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR: VkStructureType = VkStructureType(1000074000);
/// `1000074001`  
pub const VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR: VkStructureType = VkStructureType(1000074001);
/// `1000074002`  
pub const VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR: VkStructureType = VkStructureType(1000074002);
/// `1000075000`  
pub const VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR: VkStructureType = VkStructureType(1000075000);
/// `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO;
/// `VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES`  
pub const VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES_KHR: VkStructureType = VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES;
/// `VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO`  
pub const VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO;
/// `1000078000`  
pub const VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR: VkStructureType = VkStructureType(1000078000);
/// `1000078001`  
pub const VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR: VkStructureType = VkStructureType(1000078001);
/// `1000078002`  
pub const VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR: VkStructureType = VkStructureType(1000078002);
/// `1000078003`  
pub const VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR: VkStructureType = VkStructureType(1000078003);
/// `1000079000`  
pub const VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR: VkStructureType = VkStructureType(1000079000);
/// `1000079001`  
pub const VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR: VkStructureType = VkStructureType(1000079001);
/// `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES;
/// `1000081000`  
pub const VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT: VkStructureType = VkStructureType(1000081000);
/// `1000081001`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT: VkStructureType = VkStructureType(1000081001);
/// `1000081002`  
pub const VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT: VkStructureType = VkStructureType(1000081002);
/// `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES;
/// `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT16_INT8_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES;
/// `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES;
/// `1000084000`  
pub const VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR: VkStructureType = VkStructureType(1000084000);
/// `VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO`  
pub const VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO;
/// `1000087000`  
pub const VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV: VkStructureType = VkStructureType(1000087000);
/// `1000090000`  
pub const VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT: VkStructureType = VkStructureType(1000090000);
/// `VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT`  
pub const VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES2_EXT: VkStructureType = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT;
/// `1000091000`  
pub const VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT: VkStructureType = VkStructureType(1000091000);
/// `1000091001`  
pub const VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT: VkStructureType = VkStructureType(1000091001);
/// `1000091002`  
pub const VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT: VkStructureType = VkStructureType(1000091002);
/// `1000091003`  
pub const VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT: VkStructureType = VkStructureType(1000091003);
/// `1000092000`  
pub const VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE: VkStructureType = VkStructureType(1000092000);
/// `1000097000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX: VkStructureType = VkStructureType(1000097000);
/// `1000044009`  
pub const VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX: VkStructureType = VkStructureType(1000044009);
/// `1000098000`  
pub const VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV: VkStructureType = VkStructureType(1000098000);
/// `1000099000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT: VkStructureType = VkStructureType(1000099000);
/// `1000099001`  
pub const VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT: VkStructureType = VkStructureType(1000099001);
/// `1000101000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT: VkStructureType = VkStructureType(1000101000);
/// `1000101001`  
pub const VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT: VkStructureType = VkStructureType(1000101001);
/// `1000102000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT: VkStructureType = VkStructureType(1000102000);
/// `1000102001`  
pub const VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT: VkStructureType = VkStructureType(1000102001);
/// `1000105000`  
pub const VK_STRUCTURE_TYPE_HDR_METADATA_EXT: VkStructureType = VkStructureType(1000105000);
/// `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES;
/// `VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO`  
pub const VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO;
/// `VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO`  
pub const VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO;
/// `VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO`  
pub const VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO;
/// `VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2`  
pub const VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2;
/// `VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2`  
pub const VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2;
/// `VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2`  
pub const VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2;
/// `VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2`  
pub const VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2;
/// `VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2`  
pub const VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2;
/// `VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO`  
pub const VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO;
/// `VK_STRUCTURE_TYPE_SUBPASS_END_INFO`  
pub const VK_STRUCTURE_TYPE_SUBPASS_END_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_SUBPASS_END_INFO;
/// `1000110000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG: VkStructureType = VkStructureType(1000110000);
/// `1000111000`  
pub const VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR: VkStructureType = VkStructureType(1000111000);
/// `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO;
/// `VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES`  
pub const VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES_KHR: VkStructureType = VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES;
/// `VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO`  
pub const VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO;
/// `1000114000`  
pub const VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR: VkStructureType = VkStructureType(1000114000);
/// `1000114001`  
pub const VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR: VkStructureType = VkStructureType(1000114001);
/// `1000114002`  
pub const VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR: VkStructureType = VkStructureType(1000114002);
/// `1000115000`  
pub const VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR: VkStructureType = VkStructureType(1000115000);
/// `1000115001`  
pub const VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR: VkStructureType = VkStructureType(1000115001);
/// `1000116000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR: VkStructureType = VkStructureType(1000116000);
/// `1000116001`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR: VkStructureType = VkStructureType(1000116001);
/// `1000116002`  
pub const VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR: VkStructureType = VkStructureType(1000116002);
/// `1000116003`  
pub const VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR: VkStructureType = VkStructureType(1000116003);
/// `1000116004`  
pub const VK_STRUCTURE_TYPE_ACQUIRE_PROFILING_LOCK_INFO_KHR: VkStructureType = VkStructureType(1000116004);
/// `1000116005`  
pub const VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_KHR: VkStructureType = VkStructureType(1000116005);
/// `1000116006`  
pub const VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_KHR: VkStructureType = VkStructureType(1000116006);
/// `1000116007`  
pub const VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_RESERVATION_INFO_KHR: VkStructureType = VkStructureType(1000116007);
/// `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES;
/// `VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO`  
pub const VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO;
/// `VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO`  
pub const VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO;
/// `VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO`  
pub const VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO;
/// `1000119000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR: VkStructureType = VkStructureType(1000119000);
/// `1000119001`  
pub const VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR: VkStructureType = VkStructureType(1000119001);
/// `1000119002`  
pub const VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR: VkStructureType = VkStructureType(1000119002);
/// `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES;
/// `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES_KHR`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES_KHR;
/// `1000121000`  
pub const VK_STRUCTURE_TYPE_DISPLAY_PROPERTIES_2_KHR: VkStructureType = VkStructureType(1000121000);
/// `1000121001`  
pub const VK_STRUCTURE_TYPE_DISPLAY_PLANE_PROPERTIES_2_KHR: VkStructureType = VkStructureType(1000121001);
/// `1000121002`  
pub const VK_STRUCTURE_TYPE_DISPLAY_MODE_PROPERTIES_2_KHR: VkStructureType = VkStructureType(1000121002);
/// `1000121003`  
pub const VK_STRUCTURE_TYPE_DISPLAY_PLANE_INFO_2_KHR: VkStructureType = VkStructureType(1000121003);
/// `1000121004`  
pub const VK_STRUCTURE_TYPE_DISPLAY_PLANE_CAPABILITIES_2_KHR: VkStructureType = VkStructureType(1000121004);
/// `1000122000`  
pub const VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK: VkStructureType = VkStructureType(1000122000);
/// `1000123000`  
pub const VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK: VkStructureType = VkStructureType(1000123000);
/// `VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS`  
pub const VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR: VkStructureType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS;
/// `VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO`  
pub const VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO;
/// `1000128000`  
pub const VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT: VkStructureType = VkStructureType(1000128000);
/// `1000128001`  
pub const VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT: VkStructureType = VkStructureType(1000128001);
/// `1000128002`  
pub const VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT: VkStructureType = VkStructureType(1000128002);
/// `1000128003`  
pub const VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT: VkStructureType = VkStructureType(1000128003);
/// `1000128004`  
pub const VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT: VkStructureType = VkStructureType(1000128004);
/// `1000129000`  
pub const VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID: VkStructureType = VkStructureType(1000129000);
/// `1000129001`  
pub const VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID: VkStructureType = VkStructureType(1000129001);
/// `1000129002`  
pub const VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID: VkStructureType = VkStructureType(1000129002);
/// `1000129003`  
pub const VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID: VkStructureType = VkStructureType(1000129003);
/// `1000129004`  
pub const VK_STRUCTURE_TYPE_MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID: VkStructureType = VkStructureType(1000129004);
/// `1000129005`  
pub const VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID: VkStructureType = VkStructureType(1000129005);
/// `1000129006`  
pub const VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID: VkStructureType = VkStructureType(1000129006);
/// `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES;
/// `VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO`  
pub const VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT: VkStructureType = VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO;
/// `1000134000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_FEATURES_AMDX: VkStructureType = VkStructureType(1000134000);
/// `1000134001`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_PROPERTIES_AMDX: VkStructureType = VkStructureType(1000134001);
/// `1000134002`  
pub const VK_STRUCTURE_TYPE_EXECUTION_GRAPH_PIPELINE_SCRATCH_SIZE_AMDX: VkStructureType = VkStructureType(1000134002);
/// `1000134003`  
pub const VK_STRUCTURE_TYPE_EXECUTION_GRAPH_PIPELINE_CREATE_INFO_AMDX: VkStructureType = VkStructureType(1000134003);
/// `1000134004`  
pub const VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_NODE_CREATE_INFO_AMDX: VkStructureType = VkStructureType(1000134004);
/// `1000135000`  
pub const VK_STRUCTURE_TYPE_TEXEL_BUFFER_DESCRIPTOR_INFO_EXT: VkStructureType = VkStructureType(1000135000);
/// `1000135001`  
pub const VK_STRUCTURE_TYPE_IMAGE_DESCRIPTOR_INFO_EXT: VkStructureType = VkStructureType(1000135001);
/// `1000135002`  
pub const VK_STRUCTURE_TYPE_RESOURCE_DESCRIPTOR_INFO_EXT: VkStructureType = VkStructureType(1000135002);
/// `1000135003`  
pub const VK_STRUCTURE_TYPE_BIND_HEAP_INFO_EXT: VkStructureType = VkStructureType(1000135003);
/// `1000135004`  
pub const VK_STRUCTURE_TYPE_PUSH_DATA_INFO_EXT: VkStructureType = VkStructureType(1000135004);
/// `1000135005`  
pub const VK_STRUCTURE_TYPE_DESCRIPTOR_SET_AND_BINDING_MAPPING_EXT: VkStructureType = VkStructureType(1000135005);
/// `1000135006`  
pub const VK_STRUCTURE_TYPE_SHADER_DESCRIPTOR_SET_AND_BINDING_MAPPING_INFO_EXT: VkStructureType = VkStructureType(1000135006);
/// `1000135007`  
pub const VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DATA_CREATE_INFO_EXT: VkStructureType = VkStructureType(1000135007);
/// `1000135008`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_PROPERTIES_EXT: VkStructureType = VkStructureType(1000135008);
/// `1000135009`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_FEATURES_EXT: VkStructureType = VkStructureType(1000135009);
/// `1000135010`  
pub const VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_DESCRIPTOR_HEAP_INFO_EXT: VkStructureType = VkStructureType(1000135010);
/// `1000135011`  
pub const VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_INDEX_CREATE_INFO_EXT: VkStructureType = VkStructureType(1000135011);
/// `1000135012`  
pub const VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_PUSH_DATA_TOKEN_NV: VkStructureType = VkStructureType(1000135012);
/// `1000135013`  
pub const VK_STRUCTURE_TYPE_SUBSAMPLED_IMAGE_FORMAT_PROPERTIES_EXT: VkStructureType = VkStructureType(1000135013);
/// `1000135014`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_TENSOR_PROPERTIES_ARM: VkStructureType = VkStructureType(1000135014);
/// `1000044008`  
pub const VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD: VkStructureType = VkStructureType(1000044008);
/// `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES;
/// `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES;
/// `VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK`  
pub const VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT: VkStructureType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK;
/// `VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO`  
pub const VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO_EXT: VkStructureType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO;
/// `1000141000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_BFLOAT16_FEATURES_KHR: VkStructureType = VkStructureType(1000141000);
/// `1000143000`  
pub const VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT: VkStructureType = VkStructureType(1000143000);
/// `1000143001`  
pub const VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT: VkStructureType = VkStructureType(1000143001);
/// `1000143002`  
pub const VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT: VkStructureType = VkStructureType(1000143002);
/// `1000143003`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT: VkStructureType = VkStructureType(1000143003);
/// `1000143004`  
pub const VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT: VkStructureType = VkStructureType(1000143004);
/// `VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2`  
pub const VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2;
/// `VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2`  
pub const VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2;
/// `VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2`  
pub const VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2;
/// `VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2`  
pub const VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2;
/// `VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2`  
pub const VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2;
/// `VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO`  
pub const VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO;
/// `1000148000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT: VkStructureType = VkStructureType(1000148000);
/// `1000148001`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT: VkStructureType = VkStructureType(1000148001);
/// `1000148002`  
pub const VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT: VkStructureType = VkStructureType(1000148002);
/// `1000149000`  
pub const VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV: VkStructureType = VkStructureType(1000149000);
/// `1000150007`  
pub const VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR: VkStructureType = VkStructureType(1000150007);
/// `1000150000`  
pub const VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR: VkStructureType = VkStructureType(1000150000);
/// `1000150002`  
pub const VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR: VkStructureType = VkStructureType(1000150002);
/// `1000150003`  
pub const VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR: VkStructureType = VkStructureType(1000150003);
/// `1000150004`  
pub const VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR: VkStructureType = VkStructureType(1000150004);
/// `1000150005`  
pub const VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR: VkStructureType = VkStructureType(1000150005);
/// `1000150006`  
pub const VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_KHR: VkStructureType = VkStructureType(1000150006);
/// `1000150009`  
pub const VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_VERSION_INFO_KHR: VkStructureType = VkStructureType(1000150009);
/// `1000150010`  
pub const VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_INFO_KHR: VkStructureType = VkStructureType(1000150010);
/// `1000150011`  
pub const VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR: VkStructureType = VkStructureType(1000150011);
/// `1000150012`  
pub const VK_STRUCTURE_TYPE_COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR: VkStructureType = VkStructureType(1000150012);
/// `1000150013`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR: VkStructureType = VkStructureType(1000150013);
/// `1000150014`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR: VkStructureType = VkStructureType(1000150014);
/// `1000150017`  
pub const VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_KHR: VkStructureType = VkStructureType(1000150017);
/// `1000150020`  
pub const VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR: VkStructureType = VkStructureType(1000150020);
/// `1000347000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR: VkStructureType = VkStructureType(1000347000);
/// `1000347001`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR: VkStructureType = VkStructureType(1000347001);
/// `1000150015`  
pub const VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_KHR: VkStructureType = VkStructureType(1000150015);
/// `1000150016`  
pub const VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR: VkStructureType = VkStructureType(1000150016);
/// `1000150018`  
pub const VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR: VkStructureType = VkStructureType(1000150018);
/// `1000348013`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR: VkStructureType = VkStructureType(1000348013);
/// `1000152000`  
pub const VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV: VkStructureType = VkStructureType(1000152000);
/// `VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD`  
pub const VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_NV: VkStructureType = VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD;
/// `1000154000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV: VkStructureType = VkStructureType(1000154000);
/// `1000154001`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV: VkStructureType = VkStructureType(1000154001);
/// `VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO`  
pub const VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO;
/// `VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO`  
pub const VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO;
/// `VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO`  
pub const VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO;
/// `VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO`  
pub const VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO;
/// `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES;
/// `VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES`  
pub const VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES_KHR: VkStructureType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES;
/// `VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO`  
pub const VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO;
/// `VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO`  
pub const VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO;
/// `1000158000`  
pub const VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT: VkStructureType = VkStructureType(1000158000);
/// `1000158002`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT: VkStructureType = VkStructureType(1000158002);
/// `1000158003`  
pub const VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT: VkStructureType = VkStructureType(1000158003);
/// `1000158004`  
pub const VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT: VkStructureType = VkStructureType(1000158004);
/// `1000158005`  
pub const VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT: VkStructureType = VkStructureType(1000158005);
/// `1000158006`  
pub const VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT: VkStructureType = VkStructureType(1000158006);
/// `1000160000`  
pub const VK_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT: VkStructureType = VkStructureType(1000160000);
/// `1000160001`  
pub const VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT: VkStructureType = VkStructureType(1000160001);
/// `VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO`  
pub const VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT: VkStructureType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO;
/// `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES;
/// `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES;
/// `VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO`  
pub const VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO_EXT: VkStructureType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO;
/// `VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT`  
pub const VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT_EXT: VkStructureType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT;
/// `1000163000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR: VkStructureType = VkStructureType(1000163000);
/// `1000163001`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR: VkStructureType = VkStructureType(1000163001);
/// `1000164000`  
pub const VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV: VkStructureType = VkStructureType(1000164000);
/// `1000164001`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV: VkStructureType = VkStructureType(1000164001);
/// `1000164002`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV: VkStructureType = VkStructureType(1000164002);
/// `1000164005`  
pub const VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV: VkStructureType = VkStructureType(1000164005);
/// `1000165000`  
pub const VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_NV: VkStructureType = VkStructureType(1000165000);
/// `1000165001`  
pub const VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_NV: VkStructureType = VkStructureType(1000165001);
/// `1000165003`  
pub const VK_STRUCTURE_TYPE_GEOMETRY_NV: VkStructureType = VkStructureType(1000165003);
/// `1000165004`  
pub const VK_STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NV: VkStructureType = VkStructureType(1000165004);
/// `1000165005`  
pub const VK_STRUCTURE_TYPE_GEOMETRY_AABB_NV: VkStructureType = VkStructureType(1000165005);
/// `1000165006`  
pub const VK_STRUCTURE_TYPE_BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV: VkStructureType = VkStructureType(1000165006);
/// `1000165007`  
pub const VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV: VkStructureType = VkStructureType(1000165007);
/// `1000165008`  
pub const VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV: VkStructureType = VkStructureType(1000165008);
/// `1000165009`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV: VkStructureType = VkStructureType(1000165009);
/// `1000165011`  
pub const VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV: VkStructureType = VkStructureType(1000165011);
/// `1000165012`  
pub const VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_INFO_NV: VkStructureType = VkStructureType(1000165012);
/// `1000166000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV: VkStructureType = VkStructureType(1000166000);
/// `1000166001`  
pub const VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV: VkStructureType = VkStructureType(1000166001);
/// `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES;
/// `VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT`  
pub const VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT_KHR: VkStructureType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT;
/// `1000170000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT: VkStructureType = VkStructureType(1000170000);
/// `1000170001`  
pub const VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT: VkStructureType = VkStructureType(1000170001);
/// `1000172000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_CONVERSION_FEATURES_QCOM: VkStructureType = VkStructureType(1000172000);
/// `VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO`  
pub const VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT: VkStructureType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO;
/// `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES;
/// `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES;
/// `1000178000`  
pub const VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT: VkStructureType = VkStructureType(1000178000);
/// `1000178001`  
pub const VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT: VkStructureType = VkStructureType(1000178001);
/// `1000178002`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT: VkStructureType = VkStructureType(1000178002);
/// `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES;
/// `1000181000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR: VkStructureType = VkStructureType(1000181000);
/// `1000183000`  
pub const VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD: VkStructureType = VkStructureType(1000183000);
/// `VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_KHR`  
pub const VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT: VkStructureType = VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_KHR;
/// `1000185000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD: VkStructureType = VkStructureType(1000185000);
/// `1000187000`  
pub const VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_KHR: VkStructureType = VkStructureType(1000187000);
/// `1000187001`  
pub const VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR: VkStructureType = VkStructureType(1000187001);
/// `1000187002`  
pub const VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR: VkStructureType = VkStructureType(1000187002);
/// `1000187003`  
pub const VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_INFO_KHR: VkStructureType = VkStructureType(1000187003);
/// `1000187004`  
pub const VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_KHR: VkStructureType = VkStructureType(1000187004);
/// `1000187005`  
pub const VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR: VkStructureType = VkStructureType(1000187005);
/// `VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO`  
pub const VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO;
/// `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES;
/// `VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES`  
pub const VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR: VkStructureType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES;
/// `1000189000`  
pub const VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD: VkStructureType = VkStructureType(1000189000);
/// `1000190000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT: VkStructureType = VkStructureType(1000190000);
/// `VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO`  
pub const VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO;
/// `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES;
/// `1000191000`  
pub const VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP: VkStructureType = VkStructureType(1000191000);
/// `VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO`  
pub const VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO;
/// `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES;
/// `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES;
/// `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES;
/// `VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE`  
pub const VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE_KHR: VkStructureType = VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE;
/// `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR;
/// `1000202000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV: VkStructureType = VkStructureType(1000202000);
/// `1000202001`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV: VkStructureType = VkStructureType(1000202001);
/// `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR;
/// `1000204000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV: VkStructureType = VkStructureType(1000204000);
/// `1000205000`  
pub const VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV: VkStructureType = VkStructureType(1000205000);
/// `1000205002`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV: VkStructureType = VkStructureType(1000205002);
/// `1000206000`  
pub const VK_STRUCTURE_TYPE_CHECKPOINT_DATA_NV: VkStructureType = VkStructureType(1000206000);
/// `1000206001`  
pub const VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV: VkStructureType = VkStructureType(1000206001);
/// `1000314008`  
pub const VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV: VkStructureType = VkStructureType(1000314008);
/// `1000314009`  
pub const VK_STRUCTURE_TYPE_CHECKPOINT_DATA_2_NV: VkStructureType = VkStructureType(1000314009);
/// `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES;
/// `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES;
/// `VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO`  
pub const VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO;
/// `VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO`  
pub const VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO;
/// `VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO`  
pub const VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO;
/// `VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO`  
pub const VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO;
/// `1000208000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_TIMING_FEATURES_EXT: VkStructureType = VkStructureType(1000208000);
/// `1000208001`  
pub const VK_STRUCTURE_TYPE_SWAPCHAIN_TIMING_PROPERTIES_EXT: VkStructureType = VkStructureType(1000208001);
/// `1000208002`  
pub const VK_STRUCTURE_TYPE_SWAPCHAIN_TIME_DOMAIN_PROPERTIES_EXT: VkStructureType = VkStructureType(1000208002);
/// `1000208003`  
pub const VK_STRUCTURE_TYPE_PRESENT_TIMINGS_INFO_EXT: VkStructureType = VkStructureType(1000208003);
/// `1000208004`  
pub const VK_STRUCTURE_TYPE_PRESENT_TIMING_INFO_EXT: VkStructureType = VkStructureType(1000208004);
/// `1000208005`  
pub const VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_INFO_EXT: VkStructureType = VkStructureType(1000208005);
/// `1000208006`  
pub const VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_PROPERTIES_EXT: VkStructureType = VkStructureType(1000208006);
/// `1000208007`  
pub const VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_EXT: VkStructureType = VkStructureType(1000208007);
/// `1000208008`  
pub const VK_STRUCTURE_TYPE_PRESENT_TIMING_SURFACE_CAPABILITIES_EXT: VkStructureType = VkStructureType(1000208008);
/// `1000208009`  
pub const VK_STRUCTURE_TYPE_SWAPCHAIN_CALIBRATED_TIMESTAMP_INFO_EXT: VkStructureType = VkStructureType(1000208009);
/// `1000209000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL: VkStructureType = VkStructureType(1000209000);
/// `1000210000`  
pub const VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL: VkStructureType = VkStructureType(1000210000);
/// `VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL`  
pub const VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO_INTEL: VkStructureType = VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL;
/// `1000210001`  
pub const VK_STRUCTURE_TYPE_INITIALIZE_PERFORMANCE_API_INFO_INTEL: VkStructureType = VkStructureType(1000210001);
/// `1000210002`  
pub const VK_STRUCTURE_TYPE_PERFORMANCE_MARKER_INFO_INTEL: VkStructureType = VkStructureType(1000210002);
/// `1000210003`  
pub const VK_STRUCTURE_TYPE_PERFORMANCE_STREAM_MARKER_INFO_INTEL: VkStructureType = VkStructureType(1000210003);
/// `1000210004`  
pub const VK_STRUCTURE_TYPE_PERFORMANCE_OVERRIDE_INFO_INTEL: VkStructureType = VkStructureType(1000210004);
/// `1000210005`  
pub const VK_STRUCTURE_TYPE_PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL: VkStructureType = VkStructureType(1000210005);
/// `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES;
/// `1000212000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT: VkStructureType = VkStructureType(1000212000);
/// `1000213000`  
pub const VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD: VkStructureType = VkStructureType(1000213000);
/// `1000213001`  
pub const VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD: VkStructureType = VkStructureType(1000213001);
/// `1000214000`  
pub const VK_STRUCTURE_TYPE_IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA: VkStructureType = VkStructureType(1000214000);
/// `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES;
/// `1000217000`  
pub const VK_STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT: VkStructureType = VkStructureType(1000217000);
/// `1000218000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT: VkStructureType = VkStructureType(1000218000);
/// `1000218001`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT: VkStructureType = VkStructureType(1000218001);
/// `1000218002`  
pub const VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT: VkStructureType = VkStructureType(1000218002);
/// `1000044007`  
pub const VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT: VkStructureType = VkStructureType(1000044007);
/// `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES;
/// `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES;
/// `VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO`  
pub const VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO;
/// `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES;
/// `1000226000`  
pub const VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR: VkStructureType = VkStructureType(1000226000);
/// `1000226001`  
pub const VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR: VkStructureType = VkStructureType(1000226001);
/// `1000226002`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR: VkStructureType = VkStructureType(1000226002);
/// `1000226003`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR: VkStructureType = VkStructureType(1000226003);
/// `1000226004`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR: VkStructureType = VkStructureType(1000226004);
/// `1000044006`  
pub const VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR: VkStructureType = VkStructureType(1000044006);
/// `1000227000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD: VkStructureType = VkStructureType(1000227000);
/// `1000229000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD: VkStructureType = VkStructureType(1000229000);
/// `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES;
/// `VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO`  
pub const VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO;
/// `VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO`  
pub const VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO;
/// `1000234000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT: VkStructureType = VkStructureType(1000234000);
/// `1000235000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR: VkStructureType = VkStructureType(1000235000);
/// `1000237000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT: VkStructureType = VkStructureType(1000237000);
/// `1000238000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT: VkStructureType = VkStructureType(1000238000);
/// `1000238001`  
pub const VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT: VkStructureType = VkStructureType(1000238001);
/// `1000239000`  
pub const VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR: VkStructureType = VkStructureType(1000239000);
/// `1000240000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV: VkStructureType = VkStructureType(1000240000);
/// `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES;
/// `VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT`  
pub const VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT_KHR: VkStructureType = VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT;
/// `VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT`  
pub const VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT_KHR: VkStructureType = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT;
/// `1000244000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT: VkStructureType = VkStructureType(1000244000);
/// `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_ADDRESS_FEATURES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT;
/// `VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO`  
pub const VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_EXT: VkStructureType = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO;
/// `1000244002`  
pub const VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT: VkStructureType = VkStructureType(1000244002);
/// `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES;
/// `VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO`  
pub const VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO_EXT: VkStructureType = VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO;
/// `1000247000`  
pub const VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT: VkStructureType = VkStructureType(1000247000);
/// `1000248000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR: VkStructureType = VkStructureType(1000248000);
/// `1000249000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV: VkStructureType = VkStructureType(1000249000);
/// `1000249001`  
pub const VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_NV: VkStructureType = VkStructureType(1000249001);
/// `1000249002`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV: VkStructureType = VkStructureType(1000249002);
/// `1000250000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV: VkStructureType = VkStructureType(1000250000);
/// `1000250001`  
pub const VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV: VkStructureType = VkStructureType(1000250001);
/// `1000250002`  
pub const VK_STRUCTURE_TYPE_FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV: VkStructureType = VkStructureType(1000250002);
/// `1000251000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT: VkStructureType = VkStructureType(1000251000);
/// `1000252000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT: VkStructureType = VkStructureType(1000252000);
/// `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES;
/// `1000254000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT: VkStructureType = VkStructureType(1000254000);
/// `1000254001`  
pub const VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT: VkStructureType = VkStructureType(1000254001);
/// `1000254002`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT: VkStructureType = VkStructureType(1000254002);
/// `1000255000`  
pub const VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT: VkStructureType = VkStructureType(1000255000);
/// `1000255002`  
pub const VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT: VkStructureType = VkStructureType(1000255002);
/// `1000255001`  
pub const VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT: VkStructureType = VkStructureType(1000255001);
/// `1000256000`  
pub const VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT: VkStructureType = VkStructureType(1000256000);
/// `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES;
/// `VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO`  
pub const VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO;
/// `VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO`  
pub const VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO;
/// `VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO`  
pub const VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO;
/// `VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO`  
pub const VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO;
/// `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES;
/// `VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO`  
pub const VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO;
/// `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES;
/// `1000260000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT: VkStructureType = VkStructureType(1000260000);
/// `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES;
/// `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES;
/// `1000267000`  
/// 
/// Not promoted to 1.3
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT: VkStructureType = VkStructureType(1000267000);
/// `1000269000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR: VkStructureType = VkStructureType(1000269000);
/// `1000269001`  
pub const VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR: VkStructureType = VkStructureType(1000269001);
/// `1000269002`  
pub const VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_PROPERTIES_KHR: VkStructureType = VkStructureType(1000269002);
/// `1000269003`  
pub const VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR: VkStructureType = VkStructureType(1000269003);
/// `1000269004`  
pub const VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR: VkStructureType = VkStructureType(1000269004);
/// `1000269005`  
pub const VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR: VkStructureType = VkStructureType(1000269005);
/// `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES;
/// `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES;
/// `VK_STRUCTURE_TYPE_MEMORY_TO_IMAGE_COPY`  
pub const VK_STRUCTURE_TYPE_MEMORY_TO_IMAGE_COPY_EXT: VkStructureType = VK_STRUCTURE_TYPE_MEMORY_TO_IMAGE_COPY;
/// `VK_STRUCTURE_TYPE_IMAGE_TO_MEMORY_COPY`  
pub const VK_STRUCTURE_TYPE_IMAGE_TO_MEMORY_COPY_EXT: VkStructureType = VK_STRUCTURE_TYPE_IMAGE_TO_MEMORY_COPY;
/// `VK_STRUCTURE_TYPE_COPY_IMAGE_TO_MEMORY_INFO`  
pub const VK_STRUCTURE_TYPE_COPY_IMAGE_TO_MEMORY_INFO_EXT: VkStructureType = VK_STRUCTURE_TYPE_COPY_IMAGE_TO_MEMORY_INFO;
/// `VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INFO`  
pub const VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INFO_EXT: VkStructureType = VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INFO;
/// `VK_STRUCTURE_TYPE_HOST_IMAGE_LAYOUT_TRANSITION_INFO`  
pub const VK_STRUCTURE_TYPE_HOST_IMAGE_LAYOUT_TRANSITION_INFO_EXT: VkStructureType = VK_STRUCTURE_TYPE_HOST_IMAGE_LAYOUT_TRANSITION_INFO;
/// `VK_STRUCTURE_TYPE_COPY_IMAGE_TO_IMAGE_INFO`  
pub const VK_STRUCTURE_TYPE_COPY_IMAGE_TO_IMAGE_INFO_EXT: VkStructureType = VK_STRUCTURE_TYPE_COPY_IMAGE_TO_IMAGE_INFO;
/// `VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE`  
pub const VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE_EXT: VkStructureType = VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE;
/// `VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY`  
pub const VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY_EXT: VkStructureType = VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY;
/// `VK_STRUCTURE_TYPE_MEMORY_MAP_INFO`  
pub const VK_STRUCTURE_TYPE_MEMORY_MAP_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_MEMORY_MAP_INFO;
/// `VK_STRUCTURE_TYPE_MEMORY_UNMAP_INFO`  
pub const VK_STRUCTURE_TYPE_MEMORY_UNMAP_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_MEMORY_UNMAP_INFO;
/// `1000272000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT: VkStructureType = VkStructureType(1000272000);
/// `1000272001`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_PROPERTIES_EXT: VkStructureType = VkStructureType(1000272001);
/// `1000272002`  
pub const VK_STRUCTURE_TYPE_MEMORY_MAP_PLACED_INFO_EXT: VkStructureType = VkStructureType(1000272002);
/// `1000273000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT: VkStructureType = VkStructureType(1000273000);
/// `VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_KHR`  
pub const VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_EXT: VkStructureType = VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_KHR;
/// `VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_KHR`  
pub const VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_EXT: VkStructureType = VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_KHR;
/// `VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_KHR`  
pub const VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_EXT: VkStructureType = VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_KHR;
/// `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR;
/// `VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_KHR`  
pub const VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_EXT: VkStructureType = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_KHR;
/// `VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_KHR`  
pub const VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_EXT: VkStructureType = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_KHR;
/// `VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_KHR`  
pub const VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_EXT: VkStructureType = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_KHR;
/// `VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_KHR`  
pub const VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_EXT: VkStructureType = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_KHR;
/// `VK_STRUCTURE_TYPE_RELEASE_SWAPCHAIN_IMAGES_INFO_KHR`  
pub const VK_STRUCTURE_TYPE_RELEASE_SWAPCHAIN_IMAGES_INFO_EXT: VkStructureType = VK_STRUCTURE_TYPE_RELEASE_SWAPCHAIN_IMAGES_INFO_KHR;
/// `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES;
/// `1000277000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV: VkStructureType = VkStructureType(1000277000);
/// `1000277001`  
pub const VK_STRUCTURE_TYPE_GRAPHICS_SHADER_GROUP_CREATE_INFO_NV: VkStructureType = VkStructureType(1000277001);
/// `1000277002`  
pub const VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV: VkStructureType = VkStructureType(1000277002);
/// `1000277003`  
pub const VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_NV: VkStructureType = VkStructureType(1000277003);
/// `1000277004`  
pub const VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NV: VkStructureType = VkStructureType(1000277004);
/// `1000277005`  
pub const VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_NV: VkStructureType = VkStructureType(1000277005);
/// `1000277006`  
pub const VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_NV: VkStructureType = VkStructureType(1000277006);
/// `1000277007`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV: VkStructureType = VkStructureType(1000277007);
/// `1000278000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV: VkStructureType = VkStructureType(1000278000);
/// `1000278001`  
pub const VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV: VkStructureType = VkStructureType(1000278001);
/// `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES;
/// `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES;
/// `1000281000`  
/// 
/// Not promoted to 1.3
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT: VkStructureType = VkStructureType(1000281000);
/// `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES;
/// `1000282000`  
pub const VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM: VkStructureType = VkStructureType(1000282000);
/// `1000282001`  
pub const VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM: VkStructureType = VkStructureType(1000282001);
/// `1000283000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT: VkStructureType = VkStructureType(1000283000);
/// `1000283001`  
pub const VK_STRUCTURE_TYPE_DEPTH_BIAS_INFO_EXT: VkStructureType = VkStructureType(1000283001);
/// `1000283002`  
pub const VK_STRUCTURE_TYPE_DEPTH_BIAS_REPRESENTATION_INFO_EXT: VkStructureType = VkStructureType(1000283002);
/// `1000284000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT: VkStructureType = VkStructureType(1000284000);
/// `1000284001`  
pub const VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT: VkStructureType = VkStructureType(1000284001);
/// `1000284002`  
pub const VK_STRUCTURE_TYPE_DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT: VkStructureType = VkStructureType(1000284002);
/// `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR;
/// `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_KHR`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_KHR;
/// `1000287000`  
pub const VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT: VkStructureType = VkStructureType(1000287000);
/// `1000287001`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT: VkStructureType = VkStructureType(1000287001);
/// `1000287002`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT: VkStructureType = VkStructureType(1000287002);
/// `1000288000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_3D_FEATURES_EXT: VkStructureType = VkStructureType(1000288000);
/// `1000290000`  
pub const VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR: VkStructureType = VkStructureType(1000290000);
/// `1000292000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV: VkStructureType = VkStructureType(1000292000);
/// `1000292001`  
pub const VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV: VkStructureType = VkStructureType(1000292001);
/// `1000292002`  
pub const VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV: VkStructureType = VkStructureType(1000292002);
/// `1000294000`  
pub const VK_STRUCTURE_TYPE_PRESENT_ID_KHR: VkStructureType = VkStructureType(1000294000);
/// `1000294001`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR: VkStructureType = VkStructureType(1000294001);
/// `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES;
/// `VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO`  
pub const VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO_EXT: VkStructureType = VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO;
/// `VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO`  
pub const VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO_EXT: VkStructureType = VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO;
/// `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES;
/// `1000299000`  
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_INFO_KHR: VkStructureType = VkStructureType(1000299000);
/// `1000299001`  
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR: VkStructureType = VkStructureType(1000299001);
/// `1000299002`  
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO_KHR: VkStructureType = VkStructureType(1000299002);
/// `1000299003`  
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR: VkStructureType = VkStructureType(1000299003);
/// `1000299004`  
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_USAGE_INFO_KHR: VkStructureType = VkStructureType(1000299004);
/// `1000299005`  
pub const VK_STRUCTURE_TYPE_QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO_KHR: VkStructureType = VkStructureType(1000299005);
/// `1000299006`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR: VkStructureType = VkStructureType(1000299006);
/// `1000299007`  
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_PROPERTIES_KHR: VkStructureType = VkStructureType(1000299007);
/// `1000299008`  
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR: VkStructureType = VkStructureType(1000299008);
/// `1000299009`  
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_PARAMETERS_GET_INFO_KHR: VkStructureType = VkStructureType(1000299009);
/// `1000299010`  
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_PARAMETERS_FEEDBACK_INFO_KHR: VkStructureType = VkStructureType(1000299010);
/// `1000300000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV: VkStructureType = VkStructureType(1000300000);
/// `1000300001`  
pub const VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV: VkStructureType = VkStructureType(1000300001);
/// `1000307000`  
pub const VK_STRUCTURE_TYPE_CUDA_MODULE_CREATE_INFO_NV: VkStructureType = VkStructureType(1000307000);
/// `1000307001`  
pub const VK_STRUCTURE_TYPE_CUDA_FUNCTION_CREATE_INFO_NV: VkStructureType = VkStructureType(1000307001);
/// `1000307002`  
pub const VK_STRUCTURE_TYPE_CUDA_LAUNCH_INFO_NV: VkStructureType = VkStructureType(1000307002);
/// `1000307003`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_FEATURES_NV: VkStructureType = VkStructureType(1000307003);
/// `1000307004`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_PROPERTIES_NV: VkStructureType = VkStructureType(1000307004);
/// `1000308000`  
pub const VK_STRUCTURE_TYPE_REFRESH_OBJECT_LIST_KHR: VkStructureType = VkStructureType(1000308000);
/// `1000309000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_FEATURES_QCOM: VkStructureType = VkStructureType(1000309000);
/// `1000309001`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_PROPERTIES_QCOM: VkStructureType = VkStructureType(1000309001);
/// `1000309002`  
pub const VK_STRUCTURE_TYPE_RENDER_PASS_TILE_SHADING_CREATE_INFO_QCOM: VkStructureType = VkStructureType(1000309002);
/// `1000309003`  
pub const VK_STRUCTURE_TYPE_PER_TILE_BEGIN_INFO_QCOM: VkStructureType = VkStructureType(1000309003);
/// `1000309004`  
pub const VK_STRUCTURE_TYPE_PER_TILE_END_INFO_QCOM: VkStructureType = VkStructureType(1000309004);
/// `1000309005`  
pub const VK_STRUCTURE_TYPE_DISPATCH_TILE_INFO_QCOM: VkStructureType = VkStructureType(1000309005);
/// `1000310000`  
pub const VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV: VkStructureType = VkStructureType(1000310000);
/// `1000311000`  
pub const VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECT_CREATE_INFO_EXT: VkStructureType = VkStructureType(1000311000);
/// `1000311001`  
pub const VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECTS_INFO_EXT: VkStructureType = VkStructureType(1000311001);
/// `1000311002`  
pub const VK_STRUCTURE_TYPE_EXPORT_METAL_DEVICE_INFO_EXT: VkStructureType = VkStructureType(1000311002);
/// `1000311003`  
pub const VK_STRUCTURE_TYPE_EXPORT_METAL_COMMAND_QUEUE_INFO_EXT: VkStructureType = VkStructureType(1000311003);
/// `1000311004`  
pub const VK_STRUCTURE_TYPE_EXPORT_METAL_BUFFER_INFO_EXT: VkStructureType = VkStructureType(1000311004);
/// `1000311005`  
pub const VK_STRUCTURE_TYPE_IMPORT_METAL_BUFFER_INFO_EXT: VkStructureType = VkStructureType(1000311005);
/// `1000311006`  
pub const VK_STRUCTURE_TYPE_EXPORT_METAL_TEXTURE_INFO_EXT: VkStructureType = VkStructureType(1000311006);
/// `1000311007`  
pub const VK_STRUCTURE_TYPE_IMPORT_METAL_TEXTURE_INFO_EXT: VkStructureType = VkStructureType(1000311007);
/// `1000311008`  
pub const VK_STRUCTURE_TYPE_EXPORT_METAL_IO_SURFACE_INFO_EXT: VkStructureType = VkStructureType(1000311008);
/// `1000311009`  
pub const VK_STRUCTURE_TYPE_IMPORT_METAL_IO_SURFACE_INFO_EXT: VkStructureType = VkStructureType(1000311009);
/// `1000311010`  
pub const VK_STRUCTURE_TYPE_EXPORT_METAL_SHARED_EVENT_INFO_EXT: VkStructureType = VkStructureType(1000311010);
/// `1000311011`  
pub const VK_STRUCTURE_TYPE_IMPORT_METAL_SHARED_EVENT_INFO_EXT: VkStructureType = VkStructureType(1000311011);
/// `VK_STRUCTURE_TYPE_MEMORY_BARRIER_2`  
pub const VK_STRUCTURE_TYPE_MEMORY_BARRIER_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_MEMORY_BARRIER_2;
/// `VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2`  
pub const VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2;
/// `VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2`  
pub const VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2;
/// `VK_STRUCTURE_TYPE_DEPENDENCY_INFO`  
pub const VK_STRUCTURE_TYPE_DEPENDENCY_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO;
/// `VK_STRUCTURE_TYPE_SUBMIT_INFO_2`  
pub const VK_STRUCTURE_TYPE_SUBMIT_INFO_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_SUBMIT_INFO_2;
/// `VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO`  
pub const VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO;
/// `VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO`  
pub const VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO;
/// `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES;
/// `1000316000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT: VkStructureType = VkStructureType(1000316000);
/// `1000316001`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT: VkStructureType = VkStructureType(1000316001);
/// `1000316002`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT: VkStructureType = VkStructureType(1000316002);
/// `1000316003`  
pub const VK_STRUCTURE_TYPE_DESCRIPTOR_ADDRESS_INFO_EXT: VkStructureType = VkStructureType(1000316003);
/// `1000316004`  
pub const VK_STRUCTURE_TYPE_DESCRIPTOR_GET_INFO_EXT: VkStructureType = VkStructureType(1000316004);
/// `1000316005`  
pub const VK_STRUCTURE_TYPE_BUFFER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT: VkStructureType = VkStructureType(1000316005);
/// `1000316006`  
pub const VK_STRUCTURE_TYPE_IMAGE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT: VkStructureType = VkStructureType(1000316006);
/// `1000316007`  
pub const VK_STRUCTURE_TYPE_IMAGE_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_EXT: VkStructureType = VkStructureType(1000316007);
/// `1000316008`  
pub const VK_STRUCTURE_TYPE_SAMPLER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT: VkStructureType = VkStructureType(1000316008);
/// `1000316010`  
pub const VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT: VkStructureType = VkStructureType(1000316010);
/// `1000316011`  
pub const VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_INFO_EXT: VkStructureType = VkStructureType(1000316011);
/// `1000316012`  
pub const VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT: VkStructureType = VkStructureType(1000316012);
/// `1000316009`  
pub const VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT: VkStructureType = VkStructureType(1000316009);
/// `1000320000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT: VkStructureType = VkStructureType(1000320000);
/// `1000320001`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT: VkStructureType = VkStructureType(1000320001);
/// `1000320002`  
pub const VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT: VkStructureType = VkStructureType(1000320002);
/// `1000321000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD: VkStructureType = VkStructureType(1000321000);
/// `1000203000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR: VkStructureType = VkStructureType(1000203000);
/// `1000322000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR: VkStructureType = VkStructureType(1000322000);
/// `1000323000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR: VkStructureType = VkStructureType(1000323000);
/// `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES;
/// `1000326000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV: VkStructureType = VkStructureType(1000326000);
/// `1000326001`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV: VkStructureType = VkStructureType(1000326001);
/// `1000326002`  
pub const VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV: VkStructureType = VkStructureType(1000326002);
/// `1000327000`  
pub const VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV: VkStructureType = VkStructureType(1000327000);
/// `1000327001`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV: VkStructureType = VkStructureType(1000327001);
/// `1000327002`  
pub const VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV: VkStructureType = VkStructureType(1000327002);
/// `1000328000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT: VkStructureType = VkStructureType(1000328000);
/// `1000328001`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT: VkStructureType = VkStructureType(1000328001);
/// `1000330000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT: VkStructureType = VkStructureType(1000330000);
/// `1000332000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT: VkStructureType = VkStructureType(1000332000);
/// `1000332001`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT: VkStructureType = VkStructureType(1000332001);
/// `1000333000`  
pub const VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM: VkStructureType = VkStructureType(1000333000);
/// `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES;
/// `1000336000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR: VkStructureType = VkStructureType(1000336000);
/// `VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2`  
pub const VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2;
/// `VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2`  
pub const VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2;
/// `VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2`  
pub const VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2;
/// `VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2`  
pub const VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2;
/// `VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2`  
pub const VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2;
/// `VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2`  
pub const VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2;
/// `VK_STRUCTURE_TYPE_BUFFER_COPY_2`  
pub const VK_STRUCTURE_TYPE_BUFFER_COPY_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_BUFFER_COPY_2;
/// `VK_STRUCTURE_TYPE_IMAGE_COPY_2`  
pub const VK_STRUCTURE_TYPE_IMAGE_COPY_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_IMAGE_COPY_2;
/// `VK_STRUCTURE_TYPE_IMAGE_BLIT_2`  
pub const VK_STRUCTURE_TYPE_IMAGE_BLIT_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_IMAGE_BLIT_2;
/// `VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2`  
pub const VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2;
/// `VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2`  
pub const VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2;
/// `1000338000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT: VkStructureType = VkStructureType(1000338000);
/// `1000338001`  
pub const VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT: VkStructureType = VkStructureType(1000338001);
/// `VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2`  
pub const VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2_EXT: VkStructureType = VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2;
/// `VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2`  
pub const VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2_EXT: VkStructureType = VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2;
/// `1000338004`  
pub const VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT: VkStructureType = VkStructureType(1000338004);
/// `1000339000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT: VkStructureType = VkStructureType(1000339000);
/// `1000340000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT: VkStructureType = VkStructureType(1000340000);
/// `1000341000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT: VkStructureType = VkStructureType(1000341000);
/// `1000341001`  
pub const VK_STRUCTURE_TYPE_DEVICE_FAULT_COUNTS_EXT: VkStructureType = VkStructureType(1000341001);
/// `1000341002`  
pub const VK_STRUCTURE_TYPE_DEVICE_FAULT_INFO_EXT: VkStructureType = VkStructureType(1000341002);
/// `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_ARM: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT;
/// `1000344000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT: VkStructureType = VkStructureType(1000344000);
/// `1000346000`  
pub const VK_STRUCTURE_TYPE_DIRECTFB_SURFACE_CREATE_INFO_EXT: VkStructureType = VkStructureType(1000346000);
/// `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT;
/// `VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT`  
pub const VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE: VkStructureType = VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT;
/// `1000352000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT: VkStructureType = VkStructureType(1000352000);
/// `1000352001`  
pub const VK_STRUCTURE_TYPE_VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT: VkStructureType = VkStructureType(1000352001);
/// `1000352002`  
pub const VK_STRUCTURE_TYPE_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT: VkStructureType = VkStructureType(1000352002);
/// `1000353000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT: VkStructureType = VkStructureType(1000353000);
/// `1000354000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT: VkStructureType = VkStructureType(1000354000);
/// `1000354001`  
pub const VK_STRUCTURE_TYPE_DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT: VkStructureType = VkStructureType(1000354001);
/// `1000355000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT: VkStructureType = VkStructureType(1000355000);
/// `1000355001`  
pub const VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT: VkStructureType = VkStructureType(1000355001);
/// `1000356000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT: VkStructureType = VkStructureType(1000356000);
/// `VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3`  
pub const VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3_KHR: VkStructureType = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3;
/// `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR;
/// `1000364000`  
pub const VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA: VkStructureType = VkStructureType(1000364000);
/// `1000364001`  
pub const VK_STRUCTURE_TYPE_MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA: VkStructureType = VkStructureType(1000364001);
/// `1000364002`  
pub const VK_STRUCTURE_TYPE_MEMORY_GET_ZIRCON_HANDLE_INFO_FUCHSIA: VkStructureType = VkStructureType(1000364002);
/// `1000365000`  
pub const VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA: VkStructureType = VkStructureType(1000365000);
/// `1000365001`  
pub const VK_STRUCTURE_TYPE_SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA: VkStructureType = VkStructureType(1000365001);
/// `1000366000`  
pub const VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CREATE_INFO_FUCHSIA: VkStructureType = VkStructureType(1000366000);
/// `1000366001`  
pub const VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA: VkStructureType = VkStructureType(1000366001);
/// `1000366002`  
pub const VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA: VkStructureType = VkStructureType(1000366002);
/// `1000366003`  
pub const VK_STRUCTURE_TYPE_BUFFER_COLLECTION_PROPERTIES_FUCHSIA: VkStructureType = VkStructureType(1000366003);
/// `1000366004`  
pub const VK_STRUCTURE_TYPE_BUFFER_CONSTRAINTS_INFO_FUCHSIA: VkStructureType = VkStructureType(1000366004);
/// `1000366005`  
pub const VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA: VkStructureType = VkStructureType(1000366005);
/// `1000366006`  
pub const VK_STRUCTURE_TYPE_IMAGE_CONSTRAINTS_INFO_FUCHSIA: VkStructureType = VkStructureType(1000366006);
/// `1000366007`  
pub const VK_STRUCTURE_TYPE_IMAGE_FORMAT_CONSTRAINTS_INFO_FUCHSIA: VkStructureType = VkStructureType(1000366007);
/// `1000366008`  
pub const VK_STRUCTURE_TYPE_SYSMEM_COLOR_SPACE_FUCHSIA: VkStructureType = VkStructureType(1000366008);
/// `1000366009`  
pub const VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CONSTRAINTS_INFO_FUCHSIA: VkStructureType = VkStructureType(1000366009);
/// `1000369000`  
pub const VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI: VkStructureType = VkStructureType(1000369000);
/// `1000369001`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI: VkStructureType = VkStructureType(1000369001);
/// `1000369002`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI: VkStructureType = VkStructureType(1000369002);
/// `1000370000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI: VkStructureType = VkStructureType(1000370000);
/// `1000371000`  
pub const VK_STRUCTURE_TYPE_MEMORY_GET_REMOTE_ADDRESS_INFO_NV: VkStructureType = VkStructureType(1000371000);
/// `1000371001`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV: VkStructureType = VkStructureType(1000371001);
/// `1000372000`  
pub const VK_STRUCTURE_TYPE_PIPELINE_PROPERTIES_IDENTIFIER_EXT: VkStructureType = VkStructureType(1000372000);
/// `1000372001`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT: VkStructureType = VkStructureType(1000372001);
/// `VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR`  
pub const VK_STRUCTURE_TYPE_PIPELINE_INFO_EXT: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR;
/// `1000373000`  
pub const VK_STRUCTURE_TYPE_IMPORT_FENCE_SCI_SYNC_INFO_NV: VkStructureType = VkStructureType(1000373000);
/// `1000373001`  
pub const VK_STRUCTURE_TYPE_EXPORT_FENCE_SCI_SYNC_INFO_NV: VkStructureType = VkStructureType(1000373001);
/// `1000373002`  
pub const VK_STRUCTURE_TYPE_FENCE_GET_SCI_SYNC_INFO_NV: VkStructureType = VkStructureType(1000373002);
/// `1000373003`  
pub const VK_STRUCTURE_TYPE_SCI_SYNC_ATTRIBUTES_INFO_NV: VkStructureType = VkStructureType(1000373003);
/// `1000373004`  
pub const VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_SCI_SYNC_INFO_NV: VkStructureType = VkStructureType(1000373004);
/// `1000373005`  
pub const VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_SCI_SYNC_INFO_NV: VkStructureType = VkStructureType(1000373005);
/// `1000373006`  
pub const VK_STRUCTURE_TYPE_SEMAPHORE_GET_SCI_SYNC_INFO_NV: VkStructureType = VkStructureType(1000373006);
/// `1000373007`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SCI_SYNC_FEATURES_NV: VkStructureType = VkStructureType(1000373007);
/// `1000374000`  
pub const VK_STRUCTURE_TYPE_IMPORT_MEMORY_SCI_BUF_INFO_NV: VkStructureType = VkStructureType(1000374000);
/// `1000374001`  
pub const VK_STRUCTURE_TYPE_EXPORT_MEMORY_SCI_BUF_INFO_NV: VkStructureType = VkStructureType(1000374001);
/// `1000374002`  
pub const VK_STRUCTURE_TYPE_MEMORY_GET_SCI_BUF_INFO_NV: VkStructureType = VkStructureType(1000374002);
/// `1000374003`  
pub const VK_STRUCTURE_TYPE_MEMORY_SCI_BUF_PROPERTIES_NV: VkStructureType = VkStructureType(1000374003);
/// `1000374004`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCI_BUF_FEATURES_NV: VkStructureType = VkStructureType(1000374004);
/// `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCI_BUF_FEATURES_NV`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SCI_BUF_FEATURES_NV: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCI_BUF_FEATURES_NV;
/// `1000375000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT: VkStructureType = VkStructureType(1000375000);
/// `1000375001`  
pub const VK_STRUCTURE_TYPE_FRAME_BOUNDARY_EXT: VkStructureType = VkStructureType(1000375001);
/// `1000376000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT: VkStructureType = VkStructureType(1000376000);
/// `1000376001`  
pub const VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT: VkStructureType = VkStructureType(1000376001);
/// `1000376002`  
pub const VK_STRUCTURE_TYPE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT: VkStructureType = VkStructureType(1000376002);
/// `1000377000`  
/// 
/// Not promoted to 1.3
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT: VkStructureType = VkStructureType(1000377000);
/// `1000378000`  
pub const VK_STRUCTURE_TYPE_SCREEN_SURFACE_CREATE_INFO_QNX: VkStructureType = VkStructureType(1000378000);
/// `1000381000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT: VkStructureType = VkStructureType(1000381000);
/// `1000381001`  
pub const VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT: VkStructureType = VkStructureType(1000381001);
/// `1000382000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT: VkStructureType = VkStructureType(1000382000);
/// `1000386000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR: VkStructureType = VkStructureType(1000386000);
/// `1000387000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES_KHR: VkStructureType = VkStructureType(1000387000);
/// `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES;
/// `VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES`  
pub const VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_EXT: VkStructureType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES;
/// `1000390000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_RGB_CONVERSION_FEATURES_VALVE: VkStructureType = VkStructureType(1000390000);
/// `1000390001`  
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_RGB_CONVERSION_CAPABILITIES_VALVE: VkStructureType = VkStructureType(1000390001);
/// `1000390002`  
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_PROFILE_RGB_CONVERSION_INFO_VALVE: VkStructureType = VkStructureType(1000390002);
/// `1000390003`  
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_RGB_CONVERSION_CREATE_INFO_VALVE: VkStructureType = VkStructureType(1000390003);
/// `1000391000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT: VkStructureType = VkStructureType(1000391000);
/// `1000391001`  
pub const VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT: VkStructureType = VkStructureType(1000391001);
/// `1000392000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT: VkStructureType = VkStructureType(1000392000);
/// `1000392001`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT: VkStructureType = VkStructureType(1000392001);
/// `1000393000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT: VkStructureType = VkStructureType(1000393000);
/// `1000395000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT: VkStructureType = VkStructureType(1000395000);
/// `1000395001`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT: VkStructureType = VkStructureType(1000395001);
/// `1000396000`  
pub const VK_STRUCTURE_TYPE_MICROMAP_BUILD_INFO_EXT: VkStructureType = VkStructureType(1000396000);
/// `1000396001`  
pub const VK_STRUCTURE_TYPE_MICROMAP_VERSION_INFO_EXT: VkStructureType = VkStructureType(1000396001);
/// `1000396002`  
pub const VK_STRUCTURE_TYPE_COPY_MICROMAP_INFO_EXT: VkStructureType = VkStructureType(1000396002);
/// `1000396003`  
pub const VK_STRUCTURE_TYPE_COPY_MICROMAP_TO_MEMORY_INFO_EXT: VkStructureType = VkStructureType(1000396003);
/// `1000396004`  
pub const VK_STRUCTURE_TYPE_COPY_MEMORY_TO_MICROMAP_INFO_EXT: VkStructureType = VkStructureType(1000396004);
/// `1000396005`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT: VkStructureType = VkStructureType(1000396005);
/// `1000396006`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT: VkStructureType = VkStructureType(1000396006);
/// `1000396007`  
pub const VK_STRUCTURE_TYPE_MICROMAP_CREATE_INFO_EXT: VkStructureType = VkStructureType(1000396007);
/// `1000396008`  
pub const VK_STRUCTURE_TYPE_MICROMAP_BUILD_SIZES_INFO_EXT: VkStructureType = VkStructureType(1000396008);
/// `1000396009`  
pub const VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT: VkStructureType = VkStructureType(1000396009);
/// `1000397000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_FEATURES_NV: VkStructureType = VkStructureType(1000397000);
/// `1000397001`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_PROPERTIES_NV: VkStructureType = VkStructureType(1000397001);
/// `1000397002`  
pub const VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_DISPLACEMENT_MICROMAP_NV: VkStructureType = VkStructureType(1000397002);
/// `1000404000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI: VkStructureType = VkStructureType(1000404000);
/// `1000404001`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI: VkStructureType = VkStructureType(1000404001);
/// `1000404002`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_VRS_FEATURES_HUAWEI: VkStructureType = VkStructureType(1000404002);
/// `1000411000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT: VkStructureType = VkStructureType(1000411000);
/// `1000411001`  
pub const VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT: VkStructureType = VkStructureType(1000411001);
/// `1000412000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT: VkStructureType = VkStructureType(1000412000);
/// `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES;
/// `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES;
/// `VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS`  
pub const VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS_KHR: VkStructureType = VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS;
/// `VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS`  
pub const VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS_KHR: VkStructureType = VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS;
/// `1000415000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM: VkStructureType = VkStructureType(1000415000);
/// `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES;
/// `1000417000`  
pub const VK_STRUCTURE_TYPE_DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM: VkStructureType = VkStructureType(1000417000);
/// `1000417001`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM: VkStructureType = VkStructureType(1000417001);
/// `1000417002`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_PROPERTIES_ARM: VkStructureType = VkStructureType(1000417002);
/// `1000418000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT: VkStructureType = VkStructureType(1000418000);
/// `1000418001`  
pub const VK_STRUCTURE_TYPE_IMAGE_VIEW_SLICED_CREATE_INFO_EXT: VkStructureType = VkStructureType(1000418001);
/// `1000420000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE: VkStructureType = VkStructureType(1000420000);
/// `1000420001`  
pub const VK_STRUCTURE_TYPE_DESCRIPTOR_SET_BINDING_REFERENCE_VALVE: VkStructureType = VkStructureType(1000420001);
/// `1000420002`  
pub const VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_HOST_MAPPING_INFO_VALVE: VkStructureType = VkStructureType(1000420002);
/// `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR;
/// `1000422000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT: VkStructureType = VkStructureType(1000422000);
/// `1000424000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM: VkStructureType = VkStructureType(1000424000);
/// `1000424001`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_PROPERTIES_ARM: VkStructureType = VkStructureType(1000424001);
/// `1000424002`  
pub const VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_BEGIN_INFO_ARM: VkStructureType = VkStructureType(1000424002);
/// `1000424003`  
pub const VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_INFO_ARM: VkStructureType = VkStructureType(1000424003);
/// `1000424004`  
pub const VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_SUBMIT_INFO_ARM: VkStructureType = VkStructureType(1000424004);
/// `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_EXT`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_EXT;
/// `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_EXT`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_EXT;
/// `VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_EXT`  
pub const VK_STRUCTURE_TYPE_SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM: VkStructureType = VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_EXT;
/// `1000426000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV: VkStructureType = VkStructureType(1000426000);
/// `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_KHR`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_KHR;
/// `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_EXT`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_EXT;
/// `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_EXT`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_EXT;
/// `1000428000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV: VkStructureType = VkStructureType(1000428000);
/// `1000428001`  
pub const VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_INDIRECT_BUFFER_INFO_NV: VkStructureType = VkStructureType(1000428001);
/// `1000428002`  
pub const VK_STRUCTURE_TYPE_PIPELINE_INDIRECT_DEVICE_ADDRESS_INFO_NV: VkStructureType = VkStructureType(1000428002);
/// `1000429008`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_LINEAR_SWEPT_SPHERES_FEATURES_NV: VkStructureType = VkStructureType(1000429008);
/// `1000429009`  
pub const VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_LINEAR_SWEPT_SPHERES_DATA_NV: VkStructureType = VkStructureType(1000429009);
/// `1000429010`  
pub const VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_SPHERES_DATA_NV: VkStructureType = VkStructureType(1000429010);
/// `1000430000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV: VkStructureType = VkStructureType(1000430000);
/// `1000434000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR: VkStructureType = VkStructureType(1000434000);
/// `1000435000`  
pub const VK_STRUCTURE_TYPE_APPLICATION_PARAMETERS_EXT: VkStructureType = VkStructureType(1000435000);
/// `1000437000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT: VkStructureType = VkStructureType(1000437000);
/// `1000440000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM: VkStructureType = VkStructureType(1000440000);
/// `1000440001`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM: VkStructureType = VkStructureType(1000440001);
/// `1000440002`  
pub const VK_STRUCTURE_TYPE_IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM: VkStructureType = VkStructureType(1000440002);
/// `1000451000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT: VkStructureType = VkStructureType(1000451000);
/// `1000451001`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_PROPERTIES_EXT: VkStructureType = VkStructureType(1000451001);
/// `1000452000`  
pub const VK_STRUCTURE_TYPE_NATIVE_BUFFER_USAGE_OHOS: VkStructureType = VkStructureType(1000452000);
/// `1000452001`  
pub const VK_STRUCTURE_TYPE_NATIVE_BUFFER_PROPERTIES_OHOS: VkStructureType = VkStructureType(1000452001);
/// `1000452002`  
pub const VK_STRUCTURE_TYPE_NATIVE_BUFFER_FORMAT_PROPERTIES_OHOS: VkStructureType = VkStructureType(1000452002);
/// `1000452003`  
pub const VK_STRUCTURE_TYPE_IMPORT_NATIVE_BUFFER_INFO_OHOS: VkStructureType = VkStructureType(1000452003);
/// `1000452004`  
pub const VK_STRUCTURE_TYPE_MEMORY_GET_NATIVE_BUFFER_INFO_OHOS: VkStructureType = VkStructureType(1000452004);
/// `1000452005`  
pub const VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_OHOS: VkStructureType = VkStructureType(1000452005);
/// `1000453000`  
pub const VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT: VkStructureType = VkStructureType(1000453000);
/// `1000455000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT: VkStructureType = VkStructureType(1000455000);
/// `1000455001`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT: VkStructureType = VkStructureType(1000455001);
/// `1000458000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT: VkStructureType = VkStructureType(1000458000);
/// `1000458001`  
pub const VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_CONTROL_EXT: VkStructureType = VkStructureType(1000458001);
/// `1000458002`  
pub const VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT: VkStructureType = VkStructureType(1000458002);
/// `1000458003`  
pub const VK_STRUCTURE_TYPE_RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT: VkStructureType = VkStructureType(1000458003);
/// `1000459000`  
pub const VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_INFO_LUNARG: VkStructureType = VkStructureType(1000459000);
/// `1000459001`  
pub const VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_LIST_LUNARG: VkStructureType = VkStructureType(1000459001);
/// `1000460000`  
pub const VK_STRUCTURE_TYPE_TENSOR_CREATE_INFO_ARM: VkStructureType = VkStructureType(1000460000);
/// `1000460001`  
pub const VK_STRUCTURE_TYPE_TENSOR_VIEW_CREATE_INFO_ARM: VkStructureType = VkStructureType(1000460001);
/// `1000460002`  
pub const VK_STRUCTURE_TYPE_BIND_TENSOR_MEMORY_INFO_ARM: VkStructureType = VkStructureType(1000460002);
/// `1000460003`  
pub const VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_TENSOR_ARM: VkStructureType = VkStructureType(1000460003);
/// `1000460004`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_PROPERTIES_ARM: VkStructureType = VkStructureType(1000460004);
/// `1000460005`  
pub const VK_STRUCTURE_TYPE_TENSOR_FORMAT_PROPERTIES_ARM: VkStructureType = VkStructureType(1000460005);
/// `1000460006`  
pub const VK_STRUCTURE_TYPE_TENSOR_DESCRIPTION_ARM: VkStructureType = VkStructureType(1000460006);
/// `1000460007`  
pub const VK_STRUCTURE_TYPE_TENSOR_MEMORY_REQUIREMENTS_INFO_ARM: VkStructureType = VkStructureType(1000460007);
/// `1000460008`  
pub const VK_STRUCTURE_TYPE_TENSOR_MEMORY_BARRIER_ARM: VkStructureType = VkStructureType(1000460008);
/// `1000460009`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_FEATURES_ARM: VkStructureType = VkStructureType(1000460009);
/// `1000460010`  
pub const VK_STRUCTURE_TYPE_DEVICE_TENSOR_MEMORY_REQUIREMENTS_ARM: VkStructureType = VkStructureType(1000460010);
/// `1000460011`  
pub const VK_STRUCTURE_TYPE_COPY_TENSOR_INFO_ARM: VkStructureType = VkStructureType(1000460011);
/// `1000460012`  
pub const VK_STRUCTURE_TYPE_TENSOR_COPY_ARM: VkStructureType = VkStructureType(1000460012);
/// `1000460013`  
pub const VK_STRUCTURE_TYPE_TENSOR_DEPENDENCY_INFO_ARM: VkStructureType = VkStructureType(1000460013);
/// `1000460014`  
pub const VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_TENSOR_ARM: VkStructureType = VkStructureType(1000460014);
/// `1000460015`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_TENSOR_INFO_ARM: VkStructureType = VkStructureType(1000460015);
/// `1000460016`  
pub const VK_STRUCTURE_TYPE_EXTERNAL_TENSOR_PROPERTIES_ARM: VkStructureType = VkStructureType(1000460016);
/// `1000460017`  
pub const VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_TENSOR_CREATE_INFO_ARM: VkStructureType = VkStructureType(1000460017);
/// `1000460018`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_FEATURES_ARM: VkStructureType = VkStructureType(1000460018);
/// `1000460019`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_PROPERTIES_ARM: VkStructureType = VkStructureType(1000460019);
/// `1000460020`  
pub const VK_STRUCTURE_TYPE_DESCRIPTOR_GET_TENSOR_INFO_ARM: VkStructureType = VkStructureType(1000460020);
/// `1000460021`  
pub const VK_STRUCTURE_TYPE_TENSOR_CAPTURE_DESCRIPTOR_DATA_INFO_ARM: VkStructureType = VkStructureType(1000460021);
/// `1000460022`  
pub const VK_STRUCTURE_TYPE_TENSOR_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_ARM: VkStructureType = VkStructureType(1000460022);
/// `1000460023`  
pub const VK_STRUCTURE_TYPE_FRAME_BOUNDARY_TENSORS_ARM: VkStructureType = VkStructureType(1000460023);
/// `1000462000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT: VkStructureType = VkStructureType(1000462000);
/// `1000462001`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT: VkStructureType = VkStructureType(1000462001);
/// `1000462002`  
pub const VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT: VkStructureType = VkStructureType(1000462002);
/// `1000462003`  
pub const VK_STRUCTURE_TYPE_SHADER_MODULE_IDENTIFIER_EXT: VkStructureType = VkStructureType(1000462003);
/// `1000342000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT: VkStructureType = VkStructureType(1000342000);
/// `1000464000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV: VkStructureType = VkStructureType(1000464000);
/// `1000464001`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV: VkStructureType = VkStructureType(1000464001);
/// `1000464002`  
pub const VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV: VkStructureType = VkStructureType(1000464002);
/// `1000464003`  
pub const VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_PROPERTIES_NV: VkStructureType = VkStructureType(1000464003);
/// `1000464004`  
pub const VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_INFO_NV: VkStructureType = VkStructureType(1000464004);
/// `1000464005`  
pub const VK_STRUCTURE_TYPE_OPTICAL_FLOW_EXECUTE_INFO_NV: VkStructureType = VkStructureType(1000464005);
/// `1000464010`  
pub const VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV: VkStructureType = VkStructureType(1000464010);
/// `1000465000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT: VkStructureType = VkStructureType(1000465000);
/// `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES;
/// `1000468000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_FEATURES_ANDROID: VkStructureType = VkStructureType(1000468000);
/// `1000468001`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_PROPERTIES_ANDROID: VkStructureType = VkStructureType(1000468001);
/// `1000468002`  
pub const VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_RESOLVE_PROPERTIES_ANDROID: VkStructureType = VkStructureType(1000468002);
/// `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES;
/// `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES;
/// `VK_STRUCTURE_TYPE_RENDERING_AREA_INFO`  
pub const VK_STRUCTURE_TYPE_RENDERING_AREA_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_RENDERING_AREA_INFO;
/// `VK_STRUCTURE_TYPE_DEVICE_IMAGE_SUBRESOURCE_INFO`  
pub const VK_STRUCTURE_TYPE_DEVICE_IMAGE_SUBRESOURCE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_DEVICE_IMAGE_SUBRESOURCE_INFO;
/// `VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2`  
pub const VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2;
/// `VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2`  
pub const VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2;
/// `VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO`  
pub const VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO;
/// `VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO`  
pub const VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO;
/// `1000476000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD: VkStructureType = VkStructureType(1000476000);
/// `1000476001`  
pub const VK_STRUCTURE_TYPE_ANTI_LAG_DATA_AMD: VkStructureType = VkStructureType(1000476001);
/// `1000476002`  
pub const VK_STRUCTURE_TYPE_ANTI_LAG_PRESENTATION_INFO_AMD: VkStructureType = VkStructureType(1000476002);
/// `1000478000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DENSE_GEOMETRY_FORMAT_FEATURES_AMDX: VkStructureType = VkStructureType(1000478000);
/// `1000478001`  
pub const VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DENSE_GEOMETRY_FORMAT_TRIANGLES_DATA_AMDX: VkStructureType = VkStructureType(1000478001);
/// `1000479000`  
pub const VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_ID_2_KHR: VkStructureType = VkStructureType(1000479000);
/// `1000479001`  
pub const VK_STRUCTURE_TYPE_PRESENT_ID_2_KHR: VkStructureType = VkStructureType(1000479001);
/// `1000479002`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR: VkStructureType = VkStructureType(1000479002);
/// `1000480000`  
pub const VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_WAIT_2_KHR: VkStructureType = VkStructureType(1000480000);
/// `1000480001`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR: VkStructureType = VkStructureType(1000480001);
/// `1000480002`  
pub const VK_STRUCTURE_TYPE_PRESENT_WAIT_2_INFO_KHR: VkStructureType = VkStructureType(1000480002);
/// `1000481000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR: VkStructureType = VkStructureType(1000481000);
/// `1000482000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT: VkStructureType = VkStructureType(1000482000);
/// `1000482001`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT: VkStructureType = VkStructureType(1000482001);
/// `1000482002`  
pub const VK_STRUCTURE_TYPE_SHADER_CREATE_INFO_EXT: VkStructureType = VkStructureType(1000482002);
/// `VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO`  
pub const VK_STRUCTURE_TYPE_SHADER_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO;
/// `1000483000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR: VkStructureType = VkStructureType(1000483000);
/// `1000483001`  
pub const VK_STRUCTURE_TYPE_PIPELINE_BINARY_CREATE_INFO_KHR: VkStructureType = VkStructureType(1000483001);
/// `1000483002`  
pub const VK_STRUCTURE_TYPE_PIPELINE_BINARY_INFO_KHR: VkStructureType = VkStructureType(1000483002);
/// `1000483003`  
pub const VK_STRUCTURE_TYPE_PIPELINE_BINARY_KEY_KHR: VkStructureType = VkStructureType(1000483003);
/// `1000483004`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_PROPERTIES_KHR: VkStructureType = VkStructureType(1000483004);
/// `1000483005`  
pub const VK_STRUCTURE_TYPE_RELEASE_CAPTURED_PIPELINE_DATA_INFO_KHR: VkStructureType = VkStructureType(1000483005);
/// `1000483006`  
pub const VK_STRUCTURE_TYPE_PIPELINE_BINARY_DATA_INFO_KHR: VkStructureType = VkStructureType(1000483006);
/// `1000483007`  
pub const VK_STRUCTURE_TYPE_PIPELINE_CREATE_INFO_KHR: VkStructureType = VkStructureType(1000483007);
/// `1000483008`  
pub const VK_STRUCTURE_TYPE_DEVICE_PIPELINE_BINARY_INTERNAL_CACHE_CONTROL_KHR: VkStructureType = VkStructureType(1000483008);
/// `1000483009`  
pub const VK_STRUCTURE_TYPE_PIPELINE_BINARY_HANDLES_INFO_KHR: VkStructureType = VkStructureType(1000483009);
/// `1000484000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM: VkStructureType = VkStructureType(1000484000);
/// `1000484001`  
pub const VK_STRUCTURE_TYPE_TILE_PROPERTIES_QCOM: VkStructureType = VkStructureType(1000484001);
/// `1000485000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC: VkStructureType = VkStructureType(1000485000);
/// `1000485001`  
pub const VK_STRUCTURE_TYPE_AMIGO_PROFILING_SUBMIT_INFO_SEC: VkStructureType = VkStructureType(1000485001);
/// `1000274000`  
pub const VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_KHR: VkStructureType = VkStructureType(1000274000);
/// `1000274001`  
pub const VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_KHR: VkStructureType = VkStructureType(1000274001);
/// `1000274002`  
pub const VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_KHR: VkStructureType = VkStructureType(1000274002);
/// `1000275000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR: VkStructureType = VkStructureType(1000275000);
/// `1000275001`  
pub const VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_KHR: VkStructureType = VkStructureType(1000275001);
/// `1000275002`  
pub const VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_KHR: VkStructureType = VkStructureType(1000275002);
/// `1000275003`  
pub const VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_KHR: VkStructureType = VkStructureType(1000275003);
/// `1000275004`  
pub const VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_KHR: VkStructureType = VkStructureType(1000275004);
/// `1000275005`  
pub const VK_STRUCTURE_TYPE_RELEASE_SWAPCHAIN_IMAGES_INFO_KHR: VkStructureType = VkStructureType(1000275005);
/// `1000488000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM: VkStructureType = VkStructureType(1000488000);
/// `1000489000`  
pub const VK_STRUCTURE_TYPE_SEMAPHORE_SCI_SYNC_POOL_CREATE_INFO_NV: VkStructureType = VkStructureType(1000489000);
/// `1000489001`  
pub const VK_STRUCTURE_TYPE_SEMAPHORE_SCI_SYNC_CREATE_INFO_NV: VkStructureType = VkStructureType(1000489001);
/// `1000489002`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SCI_SYNC_2_FEATURES_NV: VkStructureType = VkStructureType(1000489002);
/// `1000489003`  
pub const VK_STRUCTURE_TYPE_DEVICE_SEMAPHORE_SCI_SYNC_POOL_RESERVATION_CREATE_INFO_NV: VkStructureType = VkStructureType(1000489003);
/// `1000490000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV: VkStructureType = VkStructureType(1000490000);
/// `1000490001`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV: VkStructureType = VkStructureType(1000490001);
/// `1000491000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_FEATURES_NV: VkStructureType = VkStructureType(1000491000);
/// `1000491001`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_PROPERTIES_NV: VkStructureType = VkStructureType(1000491001);
/// `1000491002`  
pub const VK_STRUCTURE_TYPE_COOPERATIVE_VECTOR_PROPERTIES_NV: VkStructureType = VkStructureType(1000491002);
/// `1000491004`  
pub const VK_STRUCTURE_TYPE_CONVERT_COOPERATIVE_VECTOR_MATRIX_INFO_NV: VkStructureType = VkStructureType(1000491004);
/// `1000492000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV: VkStructureType = VkStructureType(1000492000);
/// `1000492001`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_PROPERTIES_NV: VkStructureType = VkStructureType(1000492001);
/// `1000351000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT: VkStructureType = VkStructureType(1000351000);
/// `1000351002`  
pub const VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT: VkStructureType = VkStructureType(1000351002);
/// `1000495000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_FEATURES_EXT: VkStructureType = VkStructureType(1000495000);
/// `1000495001`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_PROPERTIES_EXT: VkStructureType = VkStructureType(1000495001);
/// `1000496000`  
pub const VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT: VkStructureType = VkStructureType(1000496000);
/// `1000497000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM: VkStructureType = VkStructureType(1000497000);
/// `1000497001`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM: VkStructureType = VkStructureType(1000497001);
/// `1000498000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT: VkStructureType = VkStructureType(1000498000);
/// `1000499000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT: VkStructureType = VkStructureType(1000499000);
/// `1000504000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INTERNALLY_SYNCHRONIZED_QUEUES_FEATURES_KHR: VkStructureType = VkStructureType(1000504000);
/// `1000505000`  
pub const VK_STRUCTURE_TYPE_LATENCY_SLEEP_MODE_INFO_NV: VkStructureType = VkStructureType(1000505000);
/// `1000505001`  
pub const VK_STRUCTURE_TYPE_LATENCY_SLEEP_INFO_NV: VkStructureType = VkStructureType(1000505001);
/// `1000505002`  
pub const VK_STRUCTURE_TYPE_SET_LATENCY_MARKER_INFO_NV: VkStructureType = VkStructureType(1000505002);
/// `1000505003`  
pub const VK_STRUCTURE_TYPE_GET_LATENCY_MARKER_INFO_NV: VkStructureType = VkStructureType(1000505003);
/// `1000505004`  
pub const VK_STRUCTURE_TYPE_LATENCY_TIMINGS_FRAME_REPORT_NV: VkStructureType = VkStructureType(1000505004);
/// `1000505005`  
pub const VK_STRUCTURE_TYPE_LATENCY_SUBMISSION_PRESENT_ID_NV: VkStructureType = VkStructureType(1000505005);
/// `1000505006`  
pub const VK_STRUCTURE_TYPE_OUT_OF_BAND_QUEUE_TYPE_INFO_NV: VkStructureType = VkStructureType(1000505006);
/// `1000505007`  
pub const VK_STRUCTURE_TYPE_SWAPCHAIN_LATENCY_CREATE_INFO_NV: VkStructureType = VkStructureType(1000505007);
/// `1000505008`  
pub const VK_STRUCTURE_TYPE_LATENCY_SURFACE_CAPABILITIES_NV: VkStructureType = VkStructureType(1000505008);
/// `1000506000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR: VkStructureType = VkStructureType(1000506000);
/// `1000506001`  
pub const VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_KHR: VkStructureType = VkStructureType(1000506001);
/// `1000506002`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR: VkStructureType = VkStructureType(1000506002);
/// `1000507000`  
pub const VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CREATE_INFO_ARM: VkStructureType = VkStructureType(1000507000);
/// `1000507001`  
pub const VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_CREATE_INFO_ARM: VkStructureType = VkStructureType(1000507001);
/// `1000507002`  
pub const VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_RESOURCE_INFO_ARM: VkStructureType = VkStructureType(1000507002);
/// `1000507003`  
pub const VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CONSTANT_ARM: VkStructureType = VkStructureType(1000507003);
/// `1000507004`  
pub const VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_MEMORY_REQUIREMENTS_INFO_ARM: VkStructureType = VkStructureType(1000507004);
/// `1000507005`  
pub const VK_STRUCTURE_TYPE_BIND_DATA_GRAPH_PIPELINE_SESSION_MEMORY_INFO_ARM: VkStructureType = VkStructureType(1000507005);
/// `1000507006`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_FEATURES_ARM: VkStructureType = VkStructureType(1000507006);
/// `1000507007`  
pub const VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SHADER_MODULE_CREATE_INFO_ARM: VkStructureType = VkStructureType(1000507007);
/// `1000507008`  
pub const VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_PROPERTY_QUERY_RESULT_ARM: VkStructureType = VkStructureType(1000507008);
/// `1000507009`  
pub const VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_INFO_ARM: VkStructureType = VkStructureType(1000507009);
/// `1000507010`  
pub const VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_COMPILER_CONTROL_CREATE_INFO_ARM: VkStructureType = VkStructureType(1000507010);
/// `1000507011`  
pub const VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_REQUIREMENTS_INFO_ARM: VkStructureType = VkStructureType(1000507011);
/// `1000507012`  
pub const VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_REQUIREMENT_ARM: VkStructureType = VkStructureType(1000507012);
/// `1000507013`  
pub const VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_IDENTIFIER_CREATE_INFO_ARM: VkStructureType = VkStructureType(1000507013);
/// `1000507014`  
pub const VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_DISPATCH_INFO_ARM: VkStructureType = VkStructureType(1000507014);
/// `1000507016`  
pub const VK_STRUCTURE_TYPE_DATA_GRAPH_PROCESSING_ENGINE_CREATE_INFO_ARM: VkStructureType = VkStructureType(1000507016);
/// `1000507017`  
pub const VK_STRUCTURE_TYPE_QUEUE_FAMILY_DATA_GRAPH_PROCESSING_ENGINE_PROPERTIES_ARM: VkStructureType = VkStructureType(1000507017);
/// `1000507018`  
pub const VK_STRUCTURE_TYPE_QUEUE_FAMILY_DATA_GRAPH_PROPERTIES_ARM: VkStructureType = VkStructureType(1000507018);
/// `1000507019`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_QUEUE_FAMILY_DATA_GRAPH_PROCESSING_ENGINE_INFO_ARM: VkStructureType = VkStructureType(1000507019);
/// `1000507015`  
pub const VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CONSTANT_TENSOR_SEMI_STRUCTURED_SPARSITY_INFO_ARM: VkStructureType = VkStructureType(1000507015);
/// `1000510000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM: VkStructureType = VkStructureType(1000510000);
/// `1000510001`  
pub const VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM: VkStructureType = VkStructureType(1000510001);
/// `1000201000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR: VkStructureType = VkStructureType(1000201000);
/// `1000511000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_PROPERTIES_KHR: VkStructureType = VkStructureType(1000511000);
/// `1000512000`  
pub const VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_CAPABILITIES_KHR: VkStructureType = VkStructureType(1000512000);
/// `1000512001`  
pub const VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PICTURE_INFO_KHR: VkStructureType = VkStructureType(1000512001);
/// `1000512003`  
pub const VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PROFILE_INFO_KHR: VkStructureType = VkStructureType(1000512003);
/// `1000512004`  
pub const VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR: VkStructureType = VkStructureType(1000512004);
/// `1000512005`  
pub const VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_DPB_SLOT_INFO_KHR: VkStructureType = VkStructureType(1000512005);
/// `1000513000`  
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_CAPABILITIES_KHR: VkStructureType = VkStructureType(1000513000);
/// `1000513001`  
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR: VkStructureType = VkStructureType(1000513001);
/// `1000513002`  
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PICTURE_INFO_KHR: VkStructureType = VkStructureType(1000513002);
/// `1000513003`  
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_DPB_SLOT_INFO_KHR: VkStructureType = VkStructureType(1000513003);
/// `1000513004`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR: VkStructureType = VkStructureType(1000513004);
/// `1000513005`  
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PROFILE_INFO_KHR: VkStructureType = VkStructureType(1000513005);
/// `1000513006`  
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_INFO_KHR: VkStructureType = VkStructureType(1000513006);
/// `1000513007`  
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_LAYER_INFO_KHR: VkStructureType = VkStructureType(1000513007);
/// `1000513008`  
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUALITY_LEVEL_PROPERTIES_KHR: VkStructureType = VkStructureType(1000513008);
/// `1000513009`  
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_CREATE_INFO_KHR: VkStructureType = VkStructureType(1000513009);
/// `1000513010`  
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_GOP_REMAINING_FRAME_INFO_KHR: VkStructureType = VkStructureType(1000513010);
/// `1000514000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR: VkStructureType = VkStructureType(1000514000);
/// `1000514001`  
pub const VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_CAPABILITIES_KHR: VkStructureType = VkStructureType(1000514001);
/// `1000514002`  
pub const VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PICTURE_INFO_KHR: VkStructureType = VkStructureType(1000514002);
/// `1000514003`  
pub const VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PROFILE_INFO_KHR: VkStructureType = VkStructureType(1000514003);
/// `1000515000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR: VkStructureType = VkStructureType(1000515000);
/// `1000515001`  
pub const VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR: VkStructureType = VkStructureType(1000515001);
/// `1000516000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV: VkStructureType = VkStructureType(1000516000);
/// `1000518000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM: VkStructureType = VkStructureType(1000518000);
/// `1000518001`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_PROPERTIES_QCOM: VkStructureType = VkStructureType(1000518001);
/// `1000518002`  
pub const VK_STRUCTURE_TYPE_SAMPLER_BLOCK_MATCH_WINDOW_CREATE_INFO_QCOM: VkStructureType = VkStructureType(1000518002);
/// `1000519000`  
pub const VK_STRUCTURE_TYPE_SAMPLER_CUBIC_WEIGHTS_CREATE_INFO_QCOM: VkStructureType = VkStructureType(1000519000);
/// `1000519001`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES_QCOM: VkStructureType = VkStructureType(1000519001);
/// `1000519002`  
pub const VK_STRUCTURE_TYPE_BLIT_IMAGE_CUBIC_WEIGHTS_INFO_QCOM: VkStructureType = VkStructureType(1000519002);
/// `1000520000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM: VkStructureType = VkStructureType(1000520000);
/// `1000520001`  
pub const VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_YCBCR_DEGAMMA_CREATE_INFO_QCOM: VkStructureType = VkStructureType(1000520001);
/// `1000521000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM: VkStructureType = VkStructureType(1000521000);
/// `1000524000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT: VkStructureType = VkStructureType(1000524000);
/// `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES;
/// `VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO`  
pub const VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO;
/// `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES;
/// `1000527000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR: VkStructureType = VkStructureType(1000527000);
/// `1000527001`  
pub const VK_STRUCTURE_TYPE_ATTACHMENT_FEEDBACK_LOOP_INFO_EXT: VkStructureType = VkStructureType(1000527001);
/// `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES;
/// `1000529000`  
pub const VK_STRUCTURE_TYPE_SCREEN_BUFFER_PROPERTIES_QNX: VkStructureType = VkStructureType(1000529000);
/// `1000529001`  
pub const VK_STRUCTURE_TYPE_SCREEN_BUFFER_FORMAT_PROPERTIES_QNX: VkStructureType = VkStructureType(1000529001);
/// `1000529002`  
pub const VK_STRUCTURE_TYPE_IMPORT_SCREEN_BUFFER_INFO_QNX: VkStructureType = VkStructureType(1000529002);
/// `1000529003`  
pub const VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_QNX: VkStructureType = VkStructureType(1000529003);
/// `1000529004`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCREEN_BUFFER_FEATURES_QNX: VkStructureType = VkStructureType(1000529004);
/// `1000530000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT: VkStructureType = VkStructureType(1000530000);
/// `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES;
/// `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES;
/// `VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO`  
pub const VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO;
/// `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES;
/// `1000184000`  
pub const VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_KHR: VkStructureType = VkStructureType(1000184000);
/// `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES;
/// `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES;
/// `VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES;
/// `VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS`  
pub const VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS_KHR: VkStructureType = VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS;
/// `VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_SETS_INFO`  
pub const VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_SETS_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_SETS_INFO;
/// `VK_STRUCTURE_TYPE_PUSH_CONSTANTS_INFO`  
pub const VK_STRUCTURE_TYPE_PUSH_CONSTANTS_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_PUSH_CONSTANTS_INFO;
/// `VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_INFO`  
pub const VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_INFO;
/// `VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO`  
pub const VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO;
/// `1000545007`  
pub const VK_STRUCTURE_TYPE_SET_DESCRIPTOR_BUFFER_OFFSETS_INFO_EXT: VkStructureType = VkStructureType(1000545007);
/// `1000545008`  
pub const VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_BUFFER_EMBEDDED_SAMPLERS_INFO_EXT: VkStructureType = VkStructureType(1000545008);
/// `1000546000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV: VkStructureType = VkStructureType(1000546000);
/// `1000547000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_FEATURES_QCOM: VkStructureType = VkStructureType(1000547000);
/// `1000547001`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_PROPERTIES_QCOM: VkStructureType = VkStructureType(1000547001);
/// `1000547002`  
pub const VK_STRUCTURE_TYPE_TILE_MEMORY_REQUIREMENTS_QCOM: VkStructureType = VkStructureType(1000547002);
/// `1000547003`  
pub const VK_STRUCTURE_TYPE_TILE_MEMORY_BIND_INFO_QCOM: VkStructureType = VkStructureType(1000547003);
/// `1000547004`  
pub const VK_STRUCTURE_TYPE_TILE_MEMORY_SIZE_INFO_QCOM: VkStructureType = VkStructureType(1000547004);
/// `1000549000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_KHR: VkStructureType = VkStructureType(1000549000);
/// `1000426001`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_KHR: VkStructureType = VkStructureType(1000426001);
/// `1000549002`  
pub const VK_STRUCTURE_TYPE_COPY_MEMORY_INDIRECT_INFO_KHR: VkStructureType = VkStructureType(1000549002);
/// `1000549003`  
pub const VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INDIRECT_INFO_KHR: VkStructureType = VkStructureType(1000549003);
/// `1000427000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_EXT: VkStructureType = VkStructureType(1000427000);
/// `1000427001`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_EXT: VkStructureType = VkStructureType(1000427001);
/// `1000550002`  
pub const VK_STRUCTURE_TYPE_DECOMPRESS_MEMORY_INFO_EXT: VkStructureType = VkStructureType(1000550002);
/// `1000551000`  
pub const VK_STRUCTURE_TYPE_DISPLAY_SURFACE_STEREO_CREATE_INFO_NV: VkStructureType = VkStructureType(1000551000);
/// `1000551001`  
pub const VK_STRUCTURE_TYPE_DISPLAY_MODE_STEREO_PROPERTIES_NV: VkStructureType = VkStructureType(1000551001);
/// `1000552000`  
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_CAPABILITIES_KHR: VkStructureType = VkStructureType(1000552000);
/// `1000552001`  
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_INTRA_REFRESH_CREATE_INFO_KHR: VkStructureType = VkStructureType(1000552001);
/// `1000552002`  
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_INFO_KHR: VkStructureType = VkStructureType(1000552002);
/// `1000552003`  
pub const VK_STRUCTURE_TYPE_VIDEO_REFERENCE_INTRA_REFRESH_INFO_KHR: VkStructureType = VkStructureType(1000552003);
/// `1000552004`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_INTRA_REFRESH_FEATURES_KHR: VkStructureType = VkStructureType(1000552004);
/// `1000553000`  
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR: VkStructureType = VkStructureType(1000553000);
/// `1000553001`  
pub const VK_STRUCTURE_TYPE_VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES_KHR: VkStructureType = VkStructureType(1000553001);
/// `1000553002`  
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_INFO_KHR: VkStructureType = VkStructureType(1000553002);
/// `1000553005`  
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_SESSION_PARAMETERS_CREATE_INFO_KHR: VkStructureType = VkStructureType(1000553005);
/// `1000553009`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR: VkStructureType = VkStructureType(1000553009);
/// `1000553003`  
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUANTIZATION_MAP_CAPABILITIES_KHR: VkStructureType = VkStructureType(1000553003);
/// `1000553004`  
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUANTIZATION_MAP_CAPABILITIES_KHR: VkStructureType = VkStructureType(1000553004);
/// `1000553006`  
pub const VK_STRUCTURE_TYPE_VIDEO_FORMAT_H265_QUANTIZATION_MAP_PROPERTIES_KHR: VkStructureType = VkStructureType(1000553006);
/// `1000553007`  
pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUANTIZATION_MAP_CAPABILITIES_KHR: VkStructureType = VkStructureType(1000553007);
/// `1000553008`  
pub const VK_STRUCTURE_TYPE_VIDEO_FORMAT_AV1_QUANTIZATION_MAP_PROPERTIES_KHR: VkStructureType = VkStructureType(1000553008);
/// `1000555000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV: VkStructureType = VkStructureType(1000555000);
/// `1000556000`  
pub const VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_DEVICE_CREATE_INFO_NV: VkStructureType = VkStructureType(1000556000);
/// `1000556001`  
pub const VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_CREATE_INFO_NV: VkStructureType = VkStructureType(1000556001);
/// `1000556002`  
pub const VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_DATA_PARAMS_NV: VkStructureType = VkStructureType(1000556002);
/// `1000556003`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_COMPUTE_QUEUE_PROPERTIES_NV: VkStructureType = VkStructureType(1000556003);
/// `1000558000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR: VkStructureType = VkStructureType(1000558000);
/// `1000559000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV: VkStructureType = VkStructureType(1000559000);
/// `1000562000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_FEATURES_KHR: VkStructureType = VkStructureType(1000562000);
/// `1000562001`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_PROPERTIES_KHR: VkStructureType = VkStructureType(1000562001);
/// `1000562002`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_LIST_KHR: VkStructureType = VkStructureType(1000562002);
/// `1000562003`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_KHR: VkStructureType = VkStructureType(1000562003);
/// `1000562004`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_VULKAN_PROPERTIES_KHR: VkStructureType = VkStructureType(1000562004);
/// `1000563000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV: VkStructureType = VkStructureType(1000563000);
/// `1000564000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT: VkStructureType = VkStructureType(1000564000);
/// `1000567000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT: VkStructureType = VkStructureType(1000567000);
/// `1000568000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV: VkStructureType = VkStructureType(1000568000);
/// `1000569000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_FEATURES_NV: VkStructureType = VkStructureType(1000569000);
/// `1000569001`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_PROPERTIES_NV: VkStructureType = VkStructureType(1000569001);
/// `1000569002`  
pub const VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_CLUSTERS_BOTTOM_LEVEL_INPUT_NV: VkStructureType = VkStructureType(1000569002);
/// `1000569003`  
pub const VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_TRIANGLE_CLUSTER_INPUT_NV: VkStructureType = VkStructureType(1000569003);
/// `1000569004`  
pub const VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_MOVE_OBJECTS_INPUT_NV: VkStructureType = VkStructureType(1000569004);
/// `1000569005`  
pub const VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_INPUT_INFO_NV: VkStructureType = VkStructureType(1000569005);
/// `1000569006`  
pub const VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_COMMANDS_INFO_NV: VkStructureType = VkStructureType(1000569006);
/// `1000569007`  
pub const VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CLUSTER_ACCELERATION_STRUCTURE_CREATE_INFO_NV: VkStructureType = VkStructureType(1000569007);
/// `1000570000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_FEATURES_NV: VkStructureType = VkStructureType(1000570000);
/// `1000570001`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_PROPERTIES_NV: VkStructureType = VkStructureType(1000570001);
/// `1000570002`  
pub const VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_PARTITIONED_ACCELERATION_STRUCTURE_NV: VkStructureType = VkStructureType(1000570002);
/// `1000570003`  
pub const VK_STRUCTURE_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCES_INPUT_NV: VkStructureType = VkStructureType(1000570003);
/// `1000570004`  
pub const VK_STRUCTURE_TYPE_BUILD_PARTITIONED_ACCELERATION_STRUCTURE_INFO_NV: VkStructureType = VkStructureType(1000570004);
/// `1000570005`  
pub const VK_STRUCTURE_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_FLAGS_NV: VkStructureType = VkStructureType(1000570005);
/// `1000572000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT: VkStructureType = VkStructureType(1000572000);
/// `1000572001`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT: VkStructureType = VkStructureType(1000572001);
/// `1000572002`  
pub const VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_EXT: VkStructureType = VkStructureType(1000572002);
/// `1000572003`  
pub const VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_CREATE_INFO_EXT: VkStructureType = VkStructureType(1000572003);
/// `1000572004`  
pub const VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_EXT: VkStructureType = VkStructureType(1000572004);
/// `1000572006`  
pub const VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_EXT: VkStructureType = VkStructureType(1000572006);
/// `1000572007`  
pub const VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_EXT: VkStructureType = VkStructureType(1000572007);
/// `1000572008`  
pub const VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_PIPELINE_EXT: VkStructureType = VkStructureType(1000572008);
/// `1000572009`  
pub const VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_SHADER_EXT: VkStructureType = VkStructureType(1000572009);
/// `1000572010`  
pub const VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_PIPELINE_INFO_EXT: VkStructureType = VkStructureType(1000572010);
/// `1000572011`  
pub const VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_INFO_EXT: VkStructureType = VkStructureType(1000572011);
/// `1000572012`  
pub const VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_LAYOUT_INFO_EXT: VkStructureType = VkStructureType(1000572012);
/// `1000572013`  
pub const VK_STRUCTURE_TYPE_GENERATED_COMMANDS_PIPELINE_INFO_EXT: VkStructureType = VkStructureType(1000572013);
/// `1000572014`  
pub const VK_STRUCTURE_TYPE_GENERATED_COMMANDS_SHADER_INFO_EXT: VkStructureType = VkStructureType(1000572014);
/// `1000574000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR: VkStructureType = VkStructureType(1000574000);
/// `1000574002`  
pub const VK_STRUCTURE_TYPE_MEMORY_BARRIER_ACCESS_FLAGS_3_KHR: VkStructureType = VkStructureType(1000574002);
/// `1000575000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA: VkStructureType = VkStructureType(1000575000);
/// `1000575001`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_PROPERTIES_MESA: VkStructureType = VkStructureType(1000575001);
/// `1000575002`  
pub const VK_STRUCTURE_TYPE_IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA: VkStructureType = VkStructureType(1000575002);
/// `1000579000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FMA_FEATURES_KHR: VkStructureType = VkStructureType(1000579000);
/// `1000580000`  
pub const VK_STRUCTURE_TYPE_PUSH_CONSTANT_BANK_INFO_NV: VkStructureType = VkStructureType(1000580000);
/// `1000580001`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_CONSTANT_BANK_FEATURES_NV: VkStructureType = VkStructureType(1000580001);
/// `1000580002`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_CONSTANT_BANK_PROPERTIES_NV: VkStructureType = VkStructureType(1000580002);
/// `1000581000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_EXT: VkStructureType = VkStructureType(1000581000);
/// `1000581001`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_EXT: VkStructureType = VkStructureType(1000581001);
/// `1000582000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT: VkStructureType = VkStructureType(1000582000);
/// `1000582001`  
pub const VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT: VkStructureType = VkStructureType(1000582001);
/// `1000584000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR: VkStructureType = VkStructureType(1000584000);
/// `1000584001`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_PROPERTIES_KHR: VkStructureType = VkStructureType(1000584001);
/// `1000584002`  
pub const VK_STRUCTURE_TYPE_QUEUE_FAMILY_OWNERSHIP_TRANSFER_PROPERTIES_KHR: VkStructureType = VkStructureType(1000584002);
/// `1000586000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_2_FEATURES_KHR: VkStructureType = VkStructureType(1000586000);
/// `1000586001`  
pub const VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_INLINE_SESSION_PARAMETERS_INFO_KHR: VkStructureType = VkStructureType(1000586001);
/// `1000586002`  
pub const VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_INLINE_SESSION_PARAMETERS_INFO_KHR: VkStructureType = VkStructureType(1000586002);
/// `1000586003`  
pub const VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_INLINE_SESSION_PARAMETERS_INFO_KHR: VkStructureType = VkStructureType(1000586003);
/// `1000685000`  
pub const VK_STRUCTURE_TYPE_SURFACE_CREATE_INFO_OHOS: VkStructureType = VkStructureType(1000685000);
/// `1000453001`  
pub const VK_STRUCTURE_TYPE_NATIVE_BUFFER_OHOS: VkStructureType = VkStructureType(1000453001);
/// `1000453002`  
pub const VK_STRUCTURE_TYPE_SWAPCHAIN_IMAGE_CREATE_INFO_OHOS: VkStructureType = VkStructureType(1000453002);
/// `1000453003`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENTATION_PROPERTIES_OHOS: VkStructureType = VkStructureType(1000453003);
/// `1000590000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI: VkStructureType = VkStructureType(1000590000);
/// `1000590001`  
pub const VK_STRUCTURE_TYPE_HDR_VIVID_DYNAMIC_METADATA_HUAWEI: VkStructureType = VkStructureType(1000590001);
/// `1000593000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV: VkStructureType = VkStructureType(1000593000);
/// `1000593001`  
pub const VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_FLEXIBLE_DIMENSIONS_PROPERTIES_NV: VkStructureType = VkStructureType(1000593001);
/// `1000593002`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_PROPERTIES_NV: VkStructureType = VkStructureType(1000593002);
/// `1000596000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_OPACITY_MICROMAP_FEATURES_ARM: VkStructureType = VkStructureType(1000596000);
/// `1000602000`  
pub const VK_STRUCTURE_TYPE_IMPORT_MEMORY_METAL_HANDLE_INFO_EXT: VkStructureType = VkStructureType(1000602000);
/// `1000602001`  
pub const VK_STRUCTURE_TYPE_MEMORY_METAL_HANDLE_PROPERTIES_EXT: VkStructureType = VkStructureType(1000602001);
/// `1000602002`  
pub const VK_STRUCTURE_TYPE_MEMORY_GET_METAL_HANDLE_INFO_EXT: VkStructureType = VkStructureType(1000602002);
/// `1000421000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR: VkStructureType = VkStructureType(1000421000);
/// `1000605000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_COUNTERS_BY_REGION_FEATURES_ARM: VkStructureType = VkStructureType(1000605000);
/// `1000605001`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_COUNTERS_BY_REGION_PROPERTIES_ARM: VkStructureType = VkStructureType(1000605001);
/// `1000605002`  
pub const VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_ARM: VkStructureType = VkStructureType(1000605002);
/// `1000605003`  
pub const VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_ARM: VkStructureType = VkStructureType(1000605003);
/// `1000605004`  
pub const VK_STRUCTURE_TYPE_RENDER_PASS_PERFORMANCE_COUNTERS_BY_REGION_BEGIN_INFO_ARM: VkStructureType = VkStructureType(1000605004);
/// `1000607000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INSTRUMENTATION_FEATURES_ARM: VkStructureType = VkStructureType(1000607000);
/// `1000607001`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INSTRUMENTATION_PROPERTIES_ARM: VkStructureType = VkStructureType(1000607001);
/// `1000607002`  
pub const VK_STRUCTURE_TYPE_SHADER_INSTRUMENTATION_CREATE_INFO_ARM: VkStructureType = VkStructureType(1000607002);
/// `1000607003`  
pub const VK_STRUCTURE_TYPE_SHADER_INSTRUMENTATION_METRIC_DESCRIPTION_ARM: VkStructureType = VkStructureType(1000607003);
/// `1000608000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT: VkStructureType = VkStructureType(1000608000);
/// `1000609000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FORMAT_PACK_FEATURES_ARM: VkStructureType = VkStructureType(1000609000);
/// `1000611000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_FEATURES_VALVE: VkStructureType = VkStructureType(1000611000);
/// `1000611001`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_PROPERTIES_VALVE: VkStructureType = VkStructureType(1000611001);
/// `1000611002`  
pub const VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_DENSITY_MAP_LAYERED_CREATE_INFO_VALVE: VkStructureType = VkStructureType(1000611002);
/// `1000286000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR: VkStructureType = VkStructureType(1000286000);
/// `1000286001`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_KHR: VkStructureType = VkStructureType(1000286001);
/// `1000613000`  
pub const VK_STRUCTURE_TYPE_SET_PRESENT_CONFIG_NV: VkStructureType = VkStructureType(1000613000);
/// `1000613001`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_METERING_FEATURES_NV: VkStructureType = VkStructureType(1000613001);
/// `1000425000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_EXT: VkStructureType = VkStructureType(1000425000);
/// `1000425001`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_EXT: VkStructureType = VkStructureType(1000425001);
/// `1000425002`  
pub const VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_EXT: VkStructureType = VkStructureType(1000425002);
/// `VK_STRUCTURE_TYPE_RENDERING_END_INFO_KHR`  
pub const VK_STRUCTURE_TYPE_RENDERING_END_INFO_EXT: VkStructureType = VK_STRUCTURE_TYPE_RENDERING_END_INFO_KHR;
/// `1000620000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES_EXT: VkStructureType = VkStructureType(1000620000);
/// `1000361000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR: VkStructureType = VkStructureType(1000361000);
/// `1000627000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_64_BIT_INDEXING_FEATURES_EXT: VkStructureType = VkStructureType(1000627000);
/// `1000628000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_RESOLVE_FEATURES_EXT: VkStructureType = VkStructureType(1000628000);
/// `1000628001`  
pub const VK_STRUCTURE_TYPE_BEGIN_CUSTOM_RESOLVE_INFO_EXT: VkStructureType = VkStructureType(1000628001);
/// `1000628002`  
pub const VK_STRUCTURE_TYPE_CUSTOM_RESOLVE_CREATE_INFO_EXT: VkStructureType = VkStructureType(1000628002);
/// `1000629000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_MODEL_FEATURES_QCOM: VkStructureType = VkStructureType(1000629000);
/// `1000629001`  
pub const VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_BUILTIN_MODEL_CREATE_INFO_QCOM: VkStructureType = VkStructureType(1000629001);
/// `1000630000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_10_FEATURES_KHR: VkStructureType = VkStructureType(1000630000);
/// `1000630001`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_10_PROPERTIES_KHR: VkStructureType = VkStructureType(1000630001);
/// `1000630002`  
pub const VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_FLAGS_INFO_KHR: VkStructureType = VkStructureType(1000630002);
/// `1000619003`  
pub const VK_STRUCTURE_TYPE_RENDERING_END_INFO_KHR: VkStructureType = VkStructureType(1000619003);
/// `1000630004`  
pub const VK_STRUCTURE_TYPE_RESOLVE_IMAGE_MODE_INFO_KHR: VkStructureType = VkStructureType(1000630004);
/// `1000635000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_LONG_VECTOR_FEATURES_EXT: VkStructureType = VkStructureType(1000635000);
/// `1000635001`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_LONG_VECTOR_PROPERTIES_EXT: VkStructureType = VkStructureType(1000635001);
/// `1000637000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CACHE_INCREMENTAL_MODE_FEATURES_SEC: VkStructureType = VkStructureType(1000637000);
/// `1000642000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNIFORM_BUFFER_UNSIZED_ARRAY_FEATURES_EXT: VkStructureType = VkStructureType(1000642000);
/// `1000645000`  
pub const VK_STRUCTURE_TYPE_COMPUTE_OCCUPANCY_PRIORITY_PARAMETERS_NV: VkStructureType = VkStructureType(1000645000);
/// `1000645001`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_OCCUPANCY_PRIORITY_FEATURES_NV: VkStructureType = VkStructureType(1000645001);
/// `1000662000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_PARTITIONED_FEATURES_EXT: VkStructureType = VkStructureType(1000662000);
/// `1000664000`  
pub const VK_STRUCTURE_TYPE_UBM_SURFACE_CREATE_INFO_SEC: VkStructureType = VkStructureType(1000664000);
/// `1000673000`  
pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MIXED_FLOAT_DOT_PRODUCT_FEATURES_VALVE: VkStructureType = VkStructureType(1000673000);

impl_enum_display!(VkStructureType { VK_STRUCTURE_TYPE_APPLICATION_INFO, VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO, VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO, VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO, VK_STRUCTURE_TYPE_SUBMIT_INFO, VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO, VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE, VK_STRUCTURE_TYPE_BIND_SPARSE_INFO, VK_STRUCTURE_TYPE_FENCE_CREATE_INFO, VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO, VK_STRUCTURE_TYPE_EVENT_CREATE_INFO, VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO, VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO, VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO, VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO, VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO, VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO, VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO, VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO, VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO, VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO, VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO, VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO, VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO, VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO, VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO, VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO, VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO, VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO, VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO, VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET, VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO, VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO, VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO, VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO, VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO, VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO, VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, VK_STRUCTURE_TYPE_MEMORY_BARRIER, VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO, VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO, VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO, VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO, VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS, VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO, VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO, VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO, VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO, VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO, VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO, VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES, VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO, VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2, VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2, VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2, VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2, VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2, VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2, VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2, VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2, VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2, VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO, VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES, VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO, VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO, VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES, VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO, VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO, VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO, VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES, VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO, VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO, VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES, VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES, VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT, VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO, VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO, VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO, VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES, VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES, VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES, VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO, VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO, VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES, VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES, VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO, VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO, VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO, VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES, VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO, VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO, VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO, VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES, VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES, VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO, VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES, VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES, VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2, VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2, VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2, VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2, VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2, VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO, VK_STRUCTURE_TYPE_SUBPASS_END_INFO, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES, VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE, VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES, VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO, VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO, VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES, VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT, VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES, VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO, VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO, VK_STRUCTURE_TYPE_MEMORY_BARRIER_2, VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2, VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2, VK_STRUCTURE_TYPE_DEPENDENCY_INFO, VK_STRUCTURE_TYPE_SUBMIT_INFO_2, VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO, VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES, VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2, VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2, VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2, VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2, VK_STRUCTURE_TYPE_BUFFER_COPY_2, VK_STRUCTURE_TYPE_IMAGE_COPY_2, VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES, VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES, VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS, VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS, VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES, VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES, VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK, VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES, VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2, VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2, VK_STRUCTURE_TYPE_IMAGE_BLIT_2, VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2, VK_STRUCTURE_TYPE_RENDERING_INFO, VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO, VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES, VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_PROPERTIES, VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES, VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES, VK_STRUCTURE_TYPE_MEMORY_MAP_INFO, VK_STRUCTURE_TYPE_MEMORY_UNMAP_INFO, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES, VK_STRUCTURE_TYPE_DEVICE_IMAGE_SUBRESOURCE_INFO, VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2, VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2, VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES, VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES, VK_STRUCTURE_TYPE_MEMORY_TO_IMAGE_COPY, VK_STRUCTURE_TYPE_IMAGE_TO_MEMORY_COPY, VK_STRUCTURE_TYPE_COPY_IMAGE_TO_MEMORY_INFO, VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INFO, VK_STRUCTURE_TYPE_HOST_IMAGE_LAYOUT_TRANSITION_INFO, VK_STRUCTURE_TYPE_COPY_IMAGE_TO_IMAGE_INFO, VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE, VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES, VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES, VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_SETS_INFO, VK_STRUCTURE_TYPE_PUSH_CONSTANTS_INFO, VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_INFO, VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES, VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES, VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES, VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES, VK_STRUCTURE_TYPE_RENDERING_AREA_INFO, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES, VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO, VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_SC_1_0_FEATURES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_SC_1_0_PROPERTIES, VK_STRUCTURE_TYPE_DEVICE_OBJECT_RESERVATION_CREATE_INFO, VK_STRUCTURE_TYPE_COMMAND_POOL_MEMORY_RESERVATION_CREATE_INFO, VK_STRUCTURE_TYPE_COMMAND_POOL_MEMORY_CONSUMPTION, VK_STRUCTURE_TYPE_PIPELINE_POOL_SIZE, VK_STRUCTURE_TYPE_FAULT_DATA, VK_STRUCTURE_TYPE_FAULT_CALLBACK_INFO, VK_STRUCTURE_TYPE_PIPELINE_OFFLINE_CREATE_INFO, VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR, VK_STRUCTURE_TYPE_PRESENT_INFO_KHR, VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR, VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR, VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR, VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR, VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR, VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR, VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR, VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR, VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR, VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR, VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR, VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR, VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR, VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR, VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID, VK_STRUCTURE_TYPE_SWAPCHAIN_IMAGE_CREATE_INFO_ANDROID, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENTATION_PROPERTIES_ANDROID, VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD, VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT, VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT, VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT, VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR, VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR, VK_STRUCTURE_TYPE_VIDEO_PICTURE_RESOURCE_INFO_KHR, VK_STRUCTURE_TYPE_VIDEO_SESSION_MEMORY_REQUIREMENTS_KHR, VK_STRUCTURE_TYPE_BIND_VIDEO_SESSION_MEMORY_INFO_KHR, VK_STRUCTURE_TYPE_VIDEO_SESSION_CREATE_INFO_KHR, VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR, VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR, VK_STRUCTURE_TYPE_VIDEO_BEGIN_CODING_INFO_KHR, VK_STRUCTURE_TYPE_VIDEO_END_CODING_INFO_KHR, VK_STRUCTURE_TYPE_VIDEO_CODING_CONTROL_INFO_KHR, VK_STRUCTURE_TYPE_VIDEO_REFERENCE_SLOT_INFO_KHR, VK_STRUCTURE_TYPE_QUEUE_FAMILY_VIDEO_PROPERTIES_KHR, VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR, VK_STRUCTURE_TYPE_VIDEO_FORMAT_PROPERTIES_KHR, VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR, VK_STRUCTURE_TYPE_VIDEO_DECODE_INFO_KHR, VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR, VK_STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR, VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV, VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV, VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT, VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_CU_MODULE_CREATE_INFO_NVX, VK_STRUCTURE_TYPE_CU_FUNCTION_CREATE_INFO_NVX, VK_STRUCTURE_TYPE_CU_LAUNCH_INFO_NVX, VK_STRUCTURE_TYPE_CU_MODULE_TEXTURING_MODE_CREATE_INFO_NVX, VK_STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX, VK_STRUCTURE_TYPE_IMAGE_VIEW_ADDRESS_PROPERTIES_NVX, VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_KHR, VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR, VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR, VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PICTURE_INFO_KHR, VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_KHR, VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_NALU_SLICE_INFO_KHR, VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_GOP_REMAINING_FRAME_INFO_KHR, VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_KHR, VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_KHR, VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_KHR, VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_KHR, VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_KHR, VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_GET_INFO_KHR, VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_FEEDBACK_INFO_KHR, VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_KHR, VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR, VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR, VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PICTURE_INFO_KHR, VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_KHR, VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO_KHR, VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_GOP_REMAINING_FRAME_INFO_KHR, VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_KHR, VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_KHR, VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_KHR, VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_KHR, VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUALITY_LEVEL_PROPERTIES_KHR, VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_GET_INFO_KHR, VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_FEEDBACK_INFO_KHR, VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_KHR, VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_KHR, VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_KHR, VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR, VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR, VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR, VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD, VK_STRUCTURE_TYPE_RENDERING_INFO_KHR, VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO_KHR, VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES_KHR, VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO_KHR, VK_STRUCTURE_TYPE_STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV, VK_STRUCTURE_TYPE_PRIVATE_VENDOR_INFO_PLACEHOLDER_OFFSET_0_NV, VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHR, VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV, VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV, VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV, VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV, VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR, VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR, VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHR, VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2_KHR, VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2_KHR, VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO_KHR, VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO_KHR, VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO_KHR, VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO_KHR, VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO_KHR, VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO_KHR, VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO_KHR, VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT, VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT, VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT, VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES_KHR, VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHR, VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHR, VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHR, VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHR, VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHR, VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHR, VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR, VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR, VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR, VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR, VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR, VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR, VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR, VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHR, VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES_KHR, VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHR, VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR, VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR, VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR, VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR, VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR, VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR, VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT, VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT16_INT8_FEATURES_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR, VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR, VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR, VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV, VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT, VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES2_EXT, VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT, VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT, VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT, VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX, VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX, VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT, VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT, VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT, VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_HDR_METADATA_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES_KHR, VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO_KHR, VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO_KHR, VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO_KHR, VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2_KHR, VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2_KHR, VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2_KHR, VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2_KHR, VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2_KHR, VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO_KHR, VK_STRUCTURE_TYPE_SUBPASS_END_INFO_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG, VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO_KHR, VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES_KHR, VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO_KHR, VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR, VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR, VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR, VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR, VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR, VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR, VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR, VK_STRUCTURE_TYPE_ACQUIRE_PROFILING_LOCK_INFO_KHR, VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_KHR, VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_KHR, VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_RESERVATION_INFO_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES_KHR, VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO_KHR, VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO_KHR, VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR, VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR, VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES_KHR, VK_STRUCTURE_TYPE_DISPLAY_PROPERTIES_2_KHR, VK_STRUCTURE_TYPE_DISPLAY_PLANE_PROPERTIES_2_KHR, VK_STRUCTURE_TYPE_DISPLAY_MODE_PROPERTIES_2_KHR, VK_STRUCTURE_TYPE_DISPLAY_PLANE_INFO_2_KHR, VK_STRUCTURE_TYPE_DISPLAY_PLANE_CAPABILITIES_2_KHR, VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK, VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK, VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR, VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR, VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT, VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT, VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT, VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT, VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID, VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID, VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID, VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID, VK_STRUCTURE_TYPE_MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID, VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID, VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT, VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_FEATURES_AMDX, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_PROPERTIES_AMDX, VK_STRUCTURE_TYPE_EXECUTION_GRAPH_PIPELINE_SCRATCH_SIZE_AMDX, VK_STRUCTURE_TYPE_EXECUTION_GRAPH_PIPELINE_CREATE_INFO_AMDX, VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_NODE_CREATE_INFO_AMDX, VK_STRUCTURE_TYPE_TEXEL_BUFFER_DESCRIPTOR_INFO_EXT, VK_STRUCTURE_TYPE_IMAGE_DESCRIPTOR_INFO_EXT, VK_STRUCTURE_TYPE_RESOURCE_DESCRIPTOR_INFO_EXT, VK_STRUCTURE_TYPE_BIND_HEAP_INFO_EXT, VK_STRUCTURE_TYPE_PUSH_DATA_INFO_EXT, VK_STRUCTURE_TYPE_DESCRIPTOR_SET_AND_BINDING_MAPPING_EXT, VK_STRUCTURE_TYPE_SHADER_DESCRIPTOR_SET_AND_BINDING_MAPPING_INFO_EXT, VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DATA_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_PROPERTIES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_FEATURES_EXT, VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_DESCRIPTOR_HEAP_INFO_EXT, VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_INDEX_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_PUSH_DATA_TOKEN_NV, VK_STRUCTURE_TYPE_SUBSAMPLED_IMAGE_FORMAT_PROPERTIES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_TENSOR_PROPERTIES_ARM, VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT, VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT, VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_BFLOAT16_FEATURES_KHR, VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT, VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT, VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT, VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT, VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2_KHR, VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2_KHR, VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2_KHR, VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR, VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2_KHR, VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT, VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV, VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR, VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR, VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR, VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR, VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR, VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR, VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_KHR, VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_VERSION_INFO_KHR, VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_INFO_KHR, VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR, VK_STRUCTURE_TYPE_COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR, VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_KHR, VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR, VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_KHR, VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR, VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR, VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV, VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_NV, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV, VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO_KHR, VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO_KHR, VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO_KHR, VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES_KHR, VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES_KHR, VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO_KHR, VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO_KHR, VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT, VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT, VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT, VK_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES_EXT, VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO_EXT, VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR, VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV, VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV, VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_NV, VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_NV, VK_STRUCTURE_TYPE_GEOMETRY_NV, VK_STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NV, VK_STRUCTURE_TYPE_GEOMETRY_AABB_NV, VK_STRUCTURE_TYPE_BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV, VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV, VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV, VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV, VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_INFO_NV, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV, VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES_KHR, VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT, VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_CONVERSION_FEATURES_QCOM, VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES_KHR, VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT, VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR, VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD, VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD, VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_KHR, VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR, VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR, VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_INFO_KHR, VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_KHR, VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR, VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR, VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR, VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT, VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT, VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP, VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES_KHR, VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV, VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV, VK_STRUCTURE_TYPE_CHECKPOINT_DATA_NV, VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV, VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV, VK_STRUCTURE_TYPE_CHECKPOINT_DATA_2_NV, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES_KHR, VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO_KHR, VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO_KHR, VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO_KHR, VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_TIMING_FEATURES_EXT, VK_STRUCTURE_TYPE_SWAPCHAIN_TIMING_PROPERTIES_EXT, VK_STRUCTURE_TYPE_SWAPCHAIN_TIME_DOMAIN_PROPERTIES_EXT, VK_STRUCTURE_TYPE_PRESENT_TIMINGS_INFO_EXT, VK_STRUCTURE_TYPE_PRESENT_TIMING_INFO_EXT, VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_INFO_EXT, VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_PROPERTIES_EXT, VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_EXT, VK_STRUCTURE_TYPE_PRESENT_TIMING_SURFACE_CAPABILITIES_EXT, VK_STRUCTURE_TYPE_SWAPCHAIN_CALIBRATED_TIMESTAMP_INFO_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL, VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL, VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO_INTEL, VK_STRUCTURE_TYPE_INITIALIZE_PERFORMANCE_API_INFO_INTEL, VK_STRUCTURE_TYPE_PERFORMANCE_MARKER_INFO_INTEL, VK_STRUCTURE_TYPE_PERFORMANCE_STREAM_MARKER_INFO_INTEL, VK_STRUCTURE_TYPE_PERFORMANCE_OVERRIDE_INFO_INTEL, VK_STRUCTURE_TYPE_PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT, VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD, VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD, VK_STRUCTURE_TYPE_IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES_KHR, VK_STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT, VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT, VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT, VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR, VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR, VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES_KHR, VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO_KHR, VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT, VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT, VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES_KHR, VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT_KHR, VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_ADDRESS_FEATURES_EXT, VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_EXT, VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES_EXT, VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV, VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_NV, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV, VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV, VK_STRUCTURE_TYPE_FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT, VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT, VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT, VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT, VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT, VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_KHR, VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_KHR, VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO_KHR, VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO_KHR, VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT, VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR, VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR, VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_PROPERTIES_KHR, VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR, VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR, VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES_EXT, VK_STRUCTURE_TYPE_MEMORY_TO_IMAGE_COPY_EXT, VK_STRUCTURE_TYPE_IMAGE_TO_MEMORY_COPY_EXT, VK_STRUCTURE_TYPE_COPY_IMAGE_TO_MEMORY_INFO_EXT, VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INFO_EXT, VK_STRUCTURE_TYPE_HOST_IMAGE_LAYOUT_TRANSITION_INFO_EXT, VK_STRUCTURE_TYPE_COPY_IMAGE_TO_IMAGE_INFO_EXT, VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE_EXT, VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY_EXT, VK_STRUCTURE_TYPE_MEMORY_MAP_INFO_KHR, VK_STRUCTURE_TYPE_MEMORY_UNMAP_INFO_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_PROPERTIES_EXT, VK_STRUCTURE_TYPE_MEMORY_MAP_PLACED_INFO_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT, VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_EXT, VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_EXT, VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT, VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_EXT, VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_EXT, VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_RELEASE_SWAPCHAIN_IMAGES_INFO_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV, VK_STRUCTURE_TYPE_GRAPHICS_SHADER_GROUP_CREATE_INFO_NV, VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV, VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_NV, VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NV, VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_NV, VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_NV, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV, VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT, VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM, VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT, VK_STRUCTURE_TYPE_DEPTH_BIAS_INFO_EXT, VK_STRUCTURE_TYPE_DEPTH_BIAS_REPRESENTATION_INFO_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT, VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT, VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_3D_FEATURES_EXT, VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV, VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV, VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV, VK_STRUCTURE_TYPE_PRESENT_ID_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES_EXT, VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES_EXT, VK_STRUCTURE_TYPE_VIDEO_ENCODE_INFO_KHR, VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR, VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO_KHR, VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR, VK_STRUCTURE_TYPE_VIDEO_ENCODE_USAGE_INFO_KHR, VK_STRUCTURE_TYPE_QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR, VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_PROPERTIES_KHR, VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR, VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_PARAMETERS_GET_INFO_KHR, VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_PARAMETERS_FEEDBACK_INFO_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV, VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV, VK_STRUCTURE_TYPE_CUDA_MODULE_CREATE_INFO_NV, VK_STRUCTURE_TYPE_CUDA_FUNCTION_CREATE_INFO_NV, VK_STRUCTURE_TYPE_CUDA_LAUNCH_INFO_NV, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_FEATURES_NV, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_PROPERTIES_NV, VK_STRUCTURE_TYPE_REFRESH_OBJECT_LIST_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_FEATURES_QCOM, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_PROPERTIES_QCOM, VK_STRUCTURE_TYPE_RENDER_PASS_TILE_SHADING_CREATE_INFO_QCOM, VK_STRUCTURE_TYPE_PER_TILE_BEGIN_INFO_QCOM, VK_STRUCTURE_TYPE_PER_TILE_END_INFO_QCOM, VK_STRUCTURE_TYPE_DISPATCH_TILE_INFO_QCOM, VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV, VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECT_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECTS_INFO_EXT, VK_STRUCTURE_TYPE_EXPORT_METAL_DEVICE_INFO_EXT, VK_STRUCTURE_TYPE_EXPORT_METAL_COMMAND_QUEUE_INFO_EXT, VK_STRUCTURE_TYPE_EXPORT_METAL_BUFFER_INFO_EXT, VK_STRUCTURE_TYPE_IMPORT_METAL_BUFFER_INFO_EXT, VK_STRUCTURE_TYPE_EXPORT_METAL_TEXTURE_INFO_EXT, VK_STRUCTURE_TYPE_IMPORT_METAL_TEXTURE_INFO_EXT, VK_STRUCTURE_TYPE_EXPORT_METAL_IO_SURFACE_INFO_EXT, VK_STRUCTURE_TYPE_IMPORT_METAL_IO_SURFACE_INFO_EXT, VK_STRUCTURE_TYPE_EXPORT_METAL_SHARED_EVENT_INFO_EXT, VK_STRUCTURE_TYPE_IMPORT_METAL_SHARED_EVENT_INFO_EXT, VK_STRUCTURE_TYPE_MEMORY_BARRIER_2_KHR, VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2_KHR, VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2_KHR, VK_STRUCTURE_TYPE_DEPENDENCY_INFO_KHR, VK_STRUCTURE_TYPE_SUBMIT_INFO_2_KHR, VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO_KHR, VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT, VK_STRUCTURE_TYPE_DESCRIPTOR_ADDRESS_INFO_EXT, VK_STRUCTURE_TYPE_DESCRIPTOR_GET_INFO_EXT, VK_STRUCTURE_TYPE_BUFFER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT, VK_STRUCTURE_TYPE_IMAGE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT, VK_STRUCTURE_TYPE_IMAGE_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_EXT, VK_STRUCTURE_TYPE_SAMPLER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT, VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_INFO_EXT, VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT, VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT, VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV, VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV, VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV, VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT, VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR, VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2_KHR, VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2_KHR, VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2_KHR, VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2_KHR, VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2_KHR, VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2_KHR, VK_STRUCTURE_TYPE_BUFFER_COPY_2_KHR, VK_STRUCTURE_TYPE_IMAGE_COPY_2_KHR, VK_STRUCTURE_TYPE_IMAGE_BLIT_2_KHR, VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2_KHR, VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT, VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT, VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2_EXT, VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2_EXT, VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT, VK_STRUCTURE_TYPE_DEVICE_FAULT_COUNTS_EXT, VK_STRUCTURE_TYPE_DEVICE_FAULT_INFO_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_ARM, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT, VK_STRUCTURE_TYPE_DIRECTFB_SURFACE_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE, VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT, VK_STRUCTURE_TYPE_VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT, VK_STRUCTURE_TYPE_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT, VK_STRUCTURE_TYPE_DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT, VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT, VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_EXT, VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA, VK_STRUCTURE_TYPE_MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA, VK_STRUCTURE_TYPE_MEMORY_GET_ZIRCON_HANDLE_INFO_FUCHSIA, VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA, VK_STRUCTURE_TYPE_SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA, VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CREATE_INFO_FUCHSIA, VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA, VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA, VK_STRUCTURE_TYPE_BUFFER_COLLECTION_PROPERTIES_FUCHSIA, VK_STRUCTURE_TYPE_BUFFER_CONSTRAINTS_INFO_FUCHSIA, VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA, VK_STRUCTURE_TYPE_IMAGE_CONSTRAINTS_INFO_FUCHSIA, VK_STRUCTURE_TYPE_IMAGE_FORMAT_CONSTRAINTS_INFO_FUCHSIA, VK_STRUCTURE_TYPE_SYSMEM_COLOR_SPACE_FUCHSIA, VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CONSTRAINTS_INFO_FUCHSIA, VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI, VK_STRUCTURE_TYPE_MEMORY_GET_REMOTE_ADDRESS_INFO_NV, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV, VK_STRUCTURE_TYPE_PIPELINE_PROPERTIES_IDENTIFIER_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT, VK_STRUCTURE_TYPE_PIPELINE_INFO_EXT, VK_STRUCTURE_TYPE_IMPORT_FENCE_SCI_SYNC_INFO_NV, VK_STRUCTURE_TYPE_EXPORT_FENCE_SCI_SYNC_INFO_NV, VK_STRUCTURE_TYPE_FENCE_GET_SCI_SYNC_INFO_NV, VK_STRUCTURE_TYPE_SCI_SYNC_ATTRIBUTES_INFO_NV, VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_SCI_SYNC_INFO_NV, VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_SCI_SYNC_INFO_NV, VK_STRUCTURE_TYPE_SEMAPHORE_GET_SCI_SYNC_INFO_NV, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SCI_SYNC_FEATURES_NV, VK_STRUCTURE_TYPE_IMPORT_MEMORY_SCI_BUF_INFO_NV, VK_STRUCTURE_TYPE_EXPORT_MEMORY_SCI_BUF_INFO_NV, VK_STRUCTURE_TYPE_MEMORY_GET_SCI_BUF_INFO_NV, VK_STRUCTURE_TYPE_MEMORY_SCI_BUF_PROPERTIES_NV, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCI_BUF_FEATURES_NV, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SCI_BUF_FEATURES_NV, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT, VK_STRUCTURE_TYPE_FRAME_BOUNDARY_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT, VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT, VK_STRUCTURE_TYPE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT, VK_STRUCTURE_TYPE_SCREEN_SURFACE_CREATE_INFO_QNX, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT, VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_EXT, VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_RGB_CONVERSION_FEATURES_VALVE, VK_STRUCTURE_TYPE_VIDEO_ENCODE_RGB_CONVERSION_CAPABILITIES_VALVE, VK_STRUCTURE_TYPE_VIDEO_ENCODE_PROFILE_RGB_CONVERSION_INFO_VALVE, VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_RGB_CONVERSION_CREATE_INFO_VALVE, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT, VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT, VK_STRUCTURE_TYPE_MICROMAP_BUILD_INFO_EXT, VK_STRUCTURE_TYPE_MICROMAP_VERSION_INFO_EXT, VK_STRUCTURE_TYPE_COPY_MICROMAP_INFO_EXT, VK_STRUCTURE_TYPE_COPY_MICROMAP_TO_MEMORY_INFO_EXT, VK_STRUCTURE_TYPE_COPY_MEMORY_TO_MICROMAP_INFO_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT, VK_STRUCTURE_TYPE_MICROMAP_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_MICROMAP_BUILD_SIZES_INFO_EXT, VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_FEATURES_NV, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_PROPERTIES_NV, VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_DISPLACEMENT_MICROMAP_NV, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_VRS_FEATURES_HUAWEI, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT, VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES_KHR, VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS_KHR, VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES_KHR, VK_STRUCTURE_TYPE_DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_PROPERTIES_ARM, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT, VK_STRUCTURE_TYPE_IMAGE_VIEW_SLICED_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE, VK_STRUCTURE_TYPE_DESCRIPTOR_SET_BINDING_REFERENCE_VALVE, VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_HOST_MAPPING_INFO_VALVE, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_PROPERTIES_ARM, VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_BEGIN_INFO_ARM, VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_INFO_ARM, VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_SUBMIT_INFO_ARM, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM, VK_STRUCTURE_TYPE_SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV, VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_INDIRECT_BUFFER_INFO_NV, VK_STRUCTURE_TYPE_PIPELINE_INDIRECT_DEVICE_ADDRESS_INFO_NV, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_LINEAR_SWEPT_SPHERES_FEATURES_NV, VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_LINEAR_SWEPT_SPHERES_DATA_NV, VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_SPHERES_DATA_NV, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR, VK_STRUCTURE_TYPE_APPLICATION_PARAMETERS_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM, VK_STRUCTURE_TYPE_IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_PROPERTIES_EXT, VK_STRUCTURE_TYPE_NATIVE_BUFFER_USAGE_OHOS, VK_STRUCTURE_TYPE_NATIVE_BUFFER_PROPERTIES_OHOS, VK_STRUCTURE_TYPE_NATIVE_BUFFER_FORMAT_PROPERTIES_OHOS, VK_STRUCTURE_TYPE_IMPORT_NATIVE_BUFFER_INFO_OHOS, VK_STRUCTURE_TYPE_MEMORY_GET_NATIVE_BUFFER_INFO_OHOS, VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_OHOS, VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT, VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_CONTROL_EXT, VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_INFO_LUNARG, VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_LIST_LUNARG, VK_STRUCTURE_TYPE_TENSOR_CREATE_INFO_ARM, VK_STRUCTURE_TYPE_TENSOR_VIEW_CREATE_INFO_ARM, VK_STRUCTURE_TYPE_BIND_TENSOR_MEMORY_INFO_ARM, VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_TENSOR_ARM, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_PROPERTIES_ARM, VK_STRUCTURE_TYPE_TENSOR_FORMAT_PROPERTIES_ARM, VK_STRUCTURE_TYPE_TENSOR_DESCRIPTION_ARM, VK_STRUCTURE_TYPE_TENSOR_MEMORY_REQUIREMENTS_INFO_ARM, VK_STRUCTURE_TYPE_TENSOR_MEMORY_BARRIER_ARM, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_FEATURES_ARM, VK_STRUCTURE_TYPE_DEVICE_TENSOR_MEMORY_REQUIREMENTS_ARM, VK_STRUCTURE_TYPE_COPY_TENSOR_INFO_ARM, VK_STRUCTURE_TYPE_TENSOR_COPY_ARM, VK_STRUCTURE_TYPE_TENSOR_DEPENDENCY_INFO_ARM, VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_TENSOR_ARM, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_TENSOR_INFO_ARM, VK_STRUCTURE_TYPE_EXTERNAL_TENSOR_PROPERTIES_ARM, VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_TENSOR_CREATE_INFO_ARM, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_FEATURES_ARM, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_PROPERTIES_ARM, VK_STRUCTURE_TYPE_DESCRIPTOR_GET_TENSOR_INFO_ARM, VK_STRUCTURE_TYPE_TENSOR_CAPTURE_DESCRIPTOR_DATA_INFO_ARM, VK_STRUCTURE_TYPE_TENSOR_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_ARM, VK_STRUCTURE_TYPE_FRAME_BOUNDARY_TENSORS_ARM, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT, VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_SHADER_MODULE_IDENTIFIER_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV, VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV, VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_PROPERTIES_NV, VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_INFO_NV, VK_STRUCTURE_TYPE_OPTICAL_FLOW_EXECUTE_INFO_NV, VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_FEATURES_ANDROID, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_PROPERTIES_ANDROID, VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_RESOLVE_PROPERTIES_ANDROID, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR, VK_STRUCTURE_TYPE_RENDERING_AREA_INFO_KHR, VK_STRUCTURE_TYPE_DEVICE_IMAGE_SUBRESOURCE_INFO_KHR, VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2_KHR, VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2_KHR, VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO_KHR, VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD, VK_STRUCTURE_TYPE_ANTI_LAG_DATA_AMD, VK_STRUCTURE_TYPE_ANTI_LAG_PRESENTATION_INFO_AMD, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DENSE_GEOMETRY_FORMAT_FEATURES_AMDX, VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DENSE_GEOMETRY_FORMAT_TRIANGLES_DATA_AMDX, VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_ID_2_KHR, VK_STRUCTURE_TYPE_PRESENT_ID_2_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR, VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_WAIT_2_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR, VK_STRUCTURE_TYPE_PRESENT_WAIT_2_INFO_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT, VK_STRUCTURE_TYPE_SHADER_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_SHADER_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR, VK_STRUCTURE_TYPE_PIPELINE_BINARY_CREATE_INFO_KHR, VK_STRUCTURE_TYPE_PIPELINE_BINARY_INFO_KHR, VK_STRUCTURE_TYPE_PIPELINE_BINARY_KEY_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_PROPERTIES_KHR, VK_STRUCTURE_TYPE_RELEASE_CAPTURED_PIPELINE_DATA_INFO_KHR, VK_STRUCTURE_TYPE_PIPELINE_BINARY_DATA_INFO_KHR, VK_STRUCTURE_TYPE_PIPELINE_CREATE_INFO_KHR, VK_STRUCTURE_TYPE_DEVICE_PIPELINE_BINARY_INTERNAL_CACHE_CONTROL_KHR, VK_STRUCTURE_TYPE_PIPELINE_BINARY_HANDLES_INFO_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM, VK_STRUCTURE_TYPE_TILE_PROPERTIES_QCOM, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC, VK_STRUCTURE_TYPE_AMIGO_PROFILING_SUBMIT_INFO_SEC, VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_KHR, VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_KHR, VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR, VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_KHR, VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_KHR, VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_KHR, VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_KHR, VK_STRUCTURE_TYPE_RELEASE_SWAPCHAIN_IMAGES_INFO_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM, VK_STRUCTURE_TYPE_SEMAPHORE_SCI_SYNC_POOL_CREATE_INFO_NV, VK_STRUCTURE_TYPE_SEMAPHORE_SCI_SYNC_CREATE_INFO_NV, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SCI_SYNC_2_FEATURES_NV, VK_STRUCTURE_TYPE_DEVICE_SEMAPHORE_SCI_SYNC_POOL_RESERVATION_CREATE_INFO_NV, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_FEATURES_NV, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_PROPERTIES_NV, VK_STRUCTURE_TYPE_COOPERATIVE_VECTOR_PROPERTIES_NV, VK_STRUCTURE_TYPE_CONVERT_COOPERATIVE_VECTOR_MATRIX_INFO_NV, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_PROPERTIES_NV, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT, VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_FEATURES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_PROPERTIES_EXT, VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INTERNALLY_SYNCHRONIZED_QUEUES_FEATURES_KHR, VK_STRUCTURE_TYPE_LATENCY_SLEEP_MODE_INFO_NV, VK_STRUCTURE_TYPE_LATENCY_SLEEP_INFO_NV, VK_STRUCTURE_TYPE_SET_LATENCY_MARKER_INFO_NV, VK_STRUCTURE_TYPE_GET_LATENCY_MARKER_INFO_NV, VK_STRUCTURE_TYPE_LATENCY_TIMINGS_FRAME_REPORT_NV, VK_STRUCTURE_TYPE_LATENCY_SUBMISSION_PRESENT_ID_NV, VK_STRUCTURE_TYPE_OUT_OF_BAND_QUEUE_TYPE_INFO_NV, VK_STRUCTURE_TYPE_SWAPCHAIN_LATENCY_CREATE_INFO_NV, VK_STRUCTURE_TYPE_LATENCY_SURFACE_CAPABILITIES_NV, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR, VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR, VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CREATE_INFO_ARM, VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_CREATE_INFO_ARM, VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_RESOURCE_INFO_ARM, VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CONSTANT_ARM, VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_MEMORY_REQUIREMENTS_INFO_ARM, VK_STRUCTURE_TYPE_BIND_DATA_GRAPH_PIPELINE_SESSION_MEMORY_INFO_ARM, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_FEATURES_ARM, VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SHADER_MODULE_CREATE_INFO_ARM, VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_PROPERTY_QUERY_RESULT_ARM, VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_INFO_ARM, VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_COMPILER_CONTROL_CREATE_INFO_ARM, VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_REQUIREMENTS_INFO_ARM, VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_REQUIREMENT_ARM, VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_IDENTIFIER_CREATE_INFO_ARM, VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_DISPATCH_INFO_ARM, VK_STRUCTURE_TYPE_DATA_GRAPH_PROCESSING_ENGINE_CREATE_INFO_ARM, VK_STRUCTURE_TYPE_QUEUE_FAMILY_DATA_GRAPH_PROCESSING_ENGINE_PROPERTIES_ARM, VK_STRUCTURE_TYPE_QUEUE_FAMILY_DATA_GRAPH_PROPERTIES_ARM, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_QUEUE_FAMILY_DATA_GRAPH_PROCESSING_ENGINE_INFO_ARM, VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CONSTANT_TENSOR_SEMI_STRUCTURED_SPARSITY_INFO_ARM, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM, VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_PROPERTIES_KHR, VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_CAPABILITIES_KHR, VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PICTURE_INFO_KHR, VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PROFILE_INFO_KHR, VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR, VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_DPB_SLOT_INFO_KHR, VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_CAPABILITIES_KHR, VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR, VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PICTURE_INFO_KHR, VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_DPB_SLOT_INFO_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR, VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PROFILE_INFO_KHR, VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_INFO_KHR, VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_LAYER_INFO_KHR, VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUALITY_LEVEL_PROPERTIES_KHR, VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_CREATE_INFO_KHR, VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_GOP_REMAINING_FRAME_INFO_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR, VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_CAPABILITIES_KHR, VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PICTURE_INFO_KHR, VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PROFILE_INFO_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR, VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_PROPERTIES_QCOM, VK_STRUCTURE_TYPE_SAMPLER_BLOCK_MATCH_WINDOW_CREATE_INFO_QCOM, VK_STRUCTURE_TYPE_SAMPLER_CUBIC_WEIGHTS_CREATE_INFO_QCOM, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES_QCOM, VK_STRUCTURE_TYPE_BLIT_IMAGE_CUBIC_WEIGHTS_INFO_QCOM, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM, VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_YCBCR_DEGAMMA_CREATE_INFO_QCOM, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_KHR, VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR, VK_STRUCTURE_TYPE_ATTACHMENT_FEEDBACK_LOOP_INFO_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES_KHR, VK_STRUCTURE_TYPE_SCREEN_BUFFER_PROPERTIES_QNX, VK_STRUCTURE_TYPE_SCREEN_BUFFER_FORMAT_PROPERTIES_QNX, VK_STRUCTURE_TYPE_IMPORT_SCREEN_BUFFER_INFO_QNX, VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_QNX, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCREEN_BUFFER_FEATURES_QNX, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_KHR, VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_KHR, VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES_KHR, VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS_KHR, VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_SETS_INFO_KHR, VK_STRUCTURE_TYPE_PUSH_CONSTANTS_INFO_KHR, VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_INFO_KHR, VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO_KHR, VK_STRUCTURE_TYPE_SET_DESCRIPTOR_BUFFER_OFFSETS_INFO_EXT, VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_BUFFER_EMBEDDED_SAMPLERS_INFO_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_FEATURES_QCOM, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_PROPERTIES_QCOM, VK_STRUCTURE_TYPE_TILE_MEMORY_REQUIREMENTS_QCOM, VK_STRUCTURE_TYPE_TILE_MEMORY_BIND_INFO_QCOM, VK_STRUCTURE_TYPE_TILE_MEMORY_SIZE_INFO_QCOM, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_KHR, VK_STRUCTURE_TYPE_COPY_MEMORY_INDIRECT_INFO_KHR, VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INDIRECT_INFO_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_EXT, VK_STRUCTURE_TYPE_DECOMPRESS_MEMORY_INFO_EXT, VK_STRUCTURE_TYPE_DISPLAY_SURFACE_STEREO_CREATE_INFO_NV, VK_STRUCTURE_TYPE_DISPLAY_MODE_STEREO_PROPERTIES_NV, VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_CAPABILITIES_KHR, VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_INTRA_REFRESH_CREATE_INFO_KHR, VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_INFO_KHR, VK_STRUCTURE_TYPE_VIDEO_REFERENCE_INTRA_REFRESH_INFO_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_INTRA_REFRESH_FEATURES_KHR, VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR, VK_STRUCTURE_TYPE_VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES_KHR, VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_INFO_KHR, VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_SESSION_PARAMETERS_CREATE_INFO_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR, VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUANTIZATION_MAP_CAPABILITIES_KHR, VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUANTIZATION_MAP_CAPABILITIES_KHR, VK_STRUCTURE_TYPE_VIDEO_FORMAT_H265_QUANTIZATION_MAP_PROPERTIES_KHR, VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUANTIZATION_MAP_CAPABILITIES_KHR, VK_STRUCTURE_TYPE_VIDEO_FORMAT_AV1_QUANTIZATION_MAP_PROPERTIES_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV, VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_DEVICE_CREATE_INFO_NV, VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_CREATE_INFO_NV, VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_DATA_PARAMS_NV, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_COMPUTE_QUEUE_PROPERTIES_NV, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_FEATURES_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_PROPERTIES_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_LIST_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_VULKAN_PROPERTIES_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_FEATURES_NV, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_PROPERTIES_NV, VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_CLUSTERS_BOTTOM_LEVEL_INPUT_NV, VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_TRIANGLE_CLUSTER_INPUT_NV, VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_MOVE_OBJECTS_INPUT_NV, VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_INPUT_INFO_NV, VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_COMMANDS_INFO_NV, VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CLUSTER_ACCELERATION_STRUCTURE_CREATE_INFO_NV, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_FEATURES_NV, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_PROPERTIES_NV, VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_PARTITIONED_ACCELERATION_STRUCTURE_NV, VK_STRUCTURE_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCES_INPUT_NV, VK_STRUCTURE_TYPE_BUILD_PARTITIONED_ACCELERATION_STRUCTURE_INFO_NV, VK_STRUCTURE_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_FLAGS_NV, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT, VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_EXT, VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_EXT, VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_EXT, VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_PIPELINE_EXT, VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_SHADER_EXT, VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_PIPELINE_INFO_EXT, VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_INFO_EXT, VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_LAYOUT_INFO_EXT, VK_STRUCTURE_TYPE_GENERATED_COMMANDS_PIPELINE_INFO_EXT, VK_STRUCTURE_TYPE_GENERATED_COMMANDS_SHADER_INFO_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR, VK_STRUCTURE_TYPE_MEMORY_BARRIER_ACCESS_FLAGS_3_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_PROPERTIES_MESA, VK_STRUCTURE_TYPE_IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FMA_FEATURES_KHR, VK_STRUCTURE_TYPE_PUSH_CONSTANT_BANK_INFO_NV, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_CONSTANT_BANK_FEATURES_NV, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_CONSTANT_BANK_PROPERTIES_NV, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT, VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_PROPERTIES_KHR, VK_STRUCTURE_TYPE_QUEUE_FAMILY_OWNERSHIP_TRANSFER_PROPERTIES_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_2_FEATURES_KHR, VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_INLINE_SESSION_PARAMETERS_INFO_KHR, VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_INLINE_SESSION_PARAMETERS_INFO_KHR, VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_INLINE_SESSION_PARAMETERS_INFO_KHR, VK_STRUCTURE_TYPE_SURFACE_CREATE_INFO_OHOS, VK_STRUCTURE_TYPE_NATIVE_BUFFER_OHOS, VK_STRUCTURE_TYPE_SWAPCHAIN_IMAGE_CREATE_INFO_OHOS, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENTATION_PROPERTIES_OHOS, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI, VK_STRUCTURE_TYPE_HDR_VIVID_DYNAMIC_METADATA_HUAWEI, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV, VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_FLEXIBLE_DIMENSIONS_PROPERTIES_NV, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_PROPERTIES_NV, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_OPACITY_MICROMAP_FEATURES_ARM, VK_STRUCTURE_TYPE_IMPORT_MEMORY_METAL_HANDLE_INFO_EXT, VK_STRUCTURE_TYPE_MEMORY_METAL_HANDLE_PROPERTIES_EXT, VK_STRUCTURE_TYPE_MEMORY_GET_METAL_HANDLE_INFO_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_COUNTERS_BY_REGION_FEATURES_ARM, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_COUNTERS_BY_REGION_PROPERTIES_ARM, VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_ARM, VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_ARM, VK_STRUCTURE_TYPE_RENDER_PASS_PERFORMANCE_COUNTERS_BY_REGION_BEGIN_INFO_ARM, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INSTRUMENTATION_FEATURES_ARM, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INSTRUMENTATION_PROPERTIES_ARM, VK_STRUCTURE_TYPE_SHADER_INSTRUMENTATION_CREATE_INFO_ARM, VK_STRUCTURE_TYPE_SHADER_INSTRUMENTATION_METRIC_DESCRIPTION_ARM, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FORMAT_PACK_FEATURES_ARM, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_FEATURES_VALVE, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_PROPERTIES_VALVE, VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_DENSITY_MAP_LAYERED_CREATE_INFO_VALVE, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_KHR, VK_STRUCTURE_TYPE_SET_PRESENT_CONFIG_NV, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_METERING_FEATURES_NV, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_EXT, VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_EXT, VK_STRUCTURE_TYPE_RENDERING_END_INFO_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_64_BIT_INDEXING_FEATURES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_RESOLVE_FEATURES_EXT, VK_STRUCTURE_TYPE_BEGIN_CUSTOM_RESOLVE_INFO_EXT, VK_STRUCTURE_TYPE_CUSTOM_RESOLVE_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_MODEL_FEATURES_QCOM, VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_BUILTIN_MODEL_CREATE_INFO_QCOM, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_10_FEATURES_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_10_PROPERTIES_KHR, VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_FLAGS_INFO_KHR, VK_STRUCTURE_TYPE_RENDERING_END_INFO_KHR, VK_STRUCTURE_TYPE_RESOLVE_IMAGE_MODE_INFO_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_LONG_VECTOR_FEATURES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_LONG_VECTOR_PROPERTIES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CACHE_INCREMENTAL_MODE_FEATURES_SEC, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNIFORM_BUFFER_UNSIZED_ARRAY_FEATURES_EXT, VK_STRUCTURE_TYPE_COMPUTE_OCCUPANCY_PRIORITY_PARAMETERS_NV, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_OCCUPANCY_PRIORITY_FEATURES_NV, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_PARTITIONED_FEATURES_EXT, VK_STRUCTURE_TYPE_UBM_SURFACE_CREATE_INFO_SEC, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MIXED_FLOAT_DOT_PRODUCT_FEATURES_VALVE });

flags!(VkSubgroupFeatureFlags);
from_into_transparent!(VkSubgroupFeatureFlags: i32);
/// `VkSubgroupFeatureFlags`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkSubgroupFeatureFlags(pub i32);

/// `1 << 0`  
/// 
/// Basic subgroup operations
pub const VK_SUBGROUP_FEATURE_BASIC_BIT: VkSubgroupFeatureFlags = VkSubgroupFeatureFlags(1 << 0);
/// `1 << 1`  
/// 
/// Vote subgroup operations
pub const VK_SUBGROUP_FEATURE_VOTE_BIT: VkSubgroupFeatureFlags = VkSubgroupFeatureFlags(1 << 1);
/// `1 << 2`  
/// 
/// Arithmetic subgroup operations
pub const VK_SUBGROUP_FEATURE_ARITHMETIC_BIT: VkSubgroupFeatureFlags = VkSubgroupFeatureFlags(1 << 2);
/// `1 << 3`  
/// 
/// Ballot subgroup operations
pub const VK_SUBGROUP_FEATURE_BALLOT_BIT: VkSubgroupFeatureFlags = VkSubgroupFeatureFlags(1 << 3);
/// `1 << 4`  
/// 
/// Shuffle subgroup operations
pub const VK_SUBGROUP_FEATURE_SHUFFLE_BIT: VkSubgroupFeatureFlags = VkSubgroupFeatureFlags(1 << 4);
/// `1 << 5`  
/// 
/// Shuffle relative subgroup operations
pub const VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT: VkSubgroupFeatureFlags = VkSubgroupFeatureFlags(1 << 5);
/// `1 << 6`  
/// 
/// Clustered subgroup operations
pub const VK_SUBGROUP_FEATURE_CLUSTERED_BIT: VkSubgroupFeatureFlags = VkSubgroupFeatureFlags(1 << 6);
/// `1 << 7`  
/// 
/// Quad subgroup operations
pub const VK_SUBGROUP_FEATURE_QUAD_BIT: VkSubgroupFeatureFlags = VkSubgroupFeatureFlags(1 << 7);
/// `1 << 9`  
pub const VK_SUBGROUP_FEATURE_ROTATE_BIT: VkSubgroupFeatureFlags = VkSubgroupFeatureFlags(1 << 9);
/// `1 << 10`  
pub const VK_SUBGROUP_FEATURE_ROTATE_CLUSTERED_BIT: VkSubgroupFeatureFlags = VkSubgroupFeatureFlags(1 << 10);
/// `VK_SUBGROUP_FEATURE_PARTITIONED_BIT_EXT`  
pub const VK_SUBGROUP_FEATURE_PARTITIONED_BIT_NV: VkSubgroupFeatureFlags = VK_SUBGROUP_FEATURE_PARTITIONED_BIT_EXT;
/// `VK_SUBGROUP_FEATURE_ROTATE_BIT`  
pub const VK_SUBGROUP_FEATURE_ROTATE_BIT_KHR: VkSubgroupFeatureFlags = VK_SUBGROUP_FEATURE_ROTATE_BIT;
/// `VK_SUBGROUP_FEATURE_ROTATE_CLUSTERED_BIT`  
pub const VK_SUBGROUP_FEATURE_ROTATE_CLUSTERED_BIT_KHR: VkSubgroupFeatureFlags = VK_SUBGROUP_FEATURE_ROTATE_CLUSTERED_BIT;
/// `1 << 8`  
pub const VK_SUBGROUP_FEATURE_PARTITIONED_BIT_EXT: VkSubgroupFeatureFlags = VkSubgroupFeatureFlags(1 << 8);

impl_flags_display!(VkSubgroupFeatureFlags { VK_SUBGROUP_FEATURE_BASIC_BIT, VK_SUBGROUP_FEATURE_VOTE_BIT, VK_SUBGROUP_FEATURE_ARITHMETIC_BIT, VK_SUBGROUP_FEATURE_BALLOT_BIT, VK_SUBGROUP_FEATURE_SHUFFLE_BIT, VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT, VK_SUBGROUP_FEATURE_CLUSTERED_BIT, VK_SUBGROUP_FEATURE_QUAD_BIT, VK_SUBGROUP_FEATURE_ROTATE_BIT, VK_SUBGROUP_FEATURE_ROTATE_CLUSTERED_BIT, VK_SUBGROUP_FEATURE_PARTITIONED_BIT_NV, VK_SUBGROUP_FEATURE_ROTATE_BIT_KHR, VK_SUBGROUP_FEATURE_ROTATE_CLUSTERED_BIT_KHR, VK_SUBGROUP_FEATURE_PARTITIONED_BIT_EXT });

flags!(VkSubmitFlags);
from_into_transparent!(VkSubmitFlags: i32);
/// `VkSubmitFlags`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkSubmitFlags(pub i32);

/// `1 << 0`  
pub const VK_SUBMIT_PROTECTED_BIT: VkSubmitFlags = VkSubmitFlags(1 << 0);
/// `VK_SUBMIT_PROTECTED_BIT`  
pub const VK_SUBMIT_PROTECTED_BIT_KHR: VkSubmitFlags = VK_SUBMIT_PROTECTED_BIT;

impl_flags_display!(VkSubmitFlags { VK_SUBMIT_PROTECTED_BIT, VK_SUBMIT_PROTECTED_BIT_KHR });

/// `VkSubmitFlags`
pub type VkSubmitFlagsKHR = VkSubmitFlags;

/// `VkSubmitInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkSubmitInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub waitSemaphoreCount: uint32_t,
    pub pWaitSemaphores: *const VkSemaphore,
    pub pWaitDstStageMask: *const VkPipelineStageFlags,
    pub commandBufferCount: uint32_t,
    pub pCommandBuffers: *const VkCommandBuffer,
    pub signalSemaphoreCount: uint32_t,
    pub pSignalSemaphores: *const VkSemaphore,
}
impl_default_zeroed_with_s_type!(VkSubmitInfo : VK_STRUCTURE_TYPE_SUBMIT_INFO);

/// `VkSubmitInfo2`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkSubmitInfo2 {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub flags: VkSubmitFlags,
    pub waitSemaphoreInfoCount: uint32_t,
    pub pWaitSemaphoreInfos: *const VkSemaphoreSubmitInfo,
    pub commandBufferInfoCount: uint32_t,
    pub pCommandBufferInfos: *const VkCommandBufferSubmitInfo,
    pub signalSemaphoreInfoCount: uint32_t,
    pub pSignalSemaphoreInfos: *const VkSemaphoreSubmitInfo,
}
impl_default_zeroed_with_s_type!(VkSubmitInfo2 : VK_STRUCTURE_TYPE_SUBMIT_INFO_2);

/// `VkSubmitInfo2`
pub type VkSubmitInfo2KHR = VkSubmitInfo2;

/// `VkSubpassBeginInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkSubpassBeginInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub contents: VkSubpassContents,
}
impl_default_zeroed_with_s_type!(VkSubpassBeginInfo : VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO);

/// `VkSubpassBeginInfo`
pub type VkSubpassBeginInfoKHR = VkSubpassBeginInfo;

from_into_transparent!(VkSubpassContents: i32);
/// `VkSubpassContents`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkSubpassContents(pub i32);

/// `0`  
pub const VK_SUBPASS_CONTENTS_INLINE: VkSubpassContents = VkSubpassContents(0);
/// `1`  
pub const VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS: VkSubpassContents = VkSubpassContents(1);
/// `VK_SUBPASS_CONTENTS_INLINE_AND_SECONDARY_COMMAND_BUFFERS_KHR`  
pub const VK_SUBPASS_CONTENTS_INLINE_AND_SECONDARY_COMMAND_BUFFERS_EXT: VkSubpassContents = VK_SUBPASS_CONTENTS_INLINE_AND_SECONDARY_COMMAND_BUFFERS_KHR;
/// `1000451000`  
pub const VK_SUBPASS_CONTENTS_INLINE_AND_SECONDARY_COMMAND_BUFFERS_KHR: VkSubpassContents = VkSubpassContents(1000451000);

impl_enum_display!(VkSubpassContents { VK_SUBPASS_CONTENTS_INLINE, VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS, VK_SUBPASS_CONTENTS_INLINE_AND_SECONDARY_COMMAND_BUFFERS_EXT, VK_SUBPASS_CONTENTS_INLINE_AND_SECONDARY_COMMAND_BUFFERS_KHR });

/// `VkSubpassDependency`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkSubpassDependency {
    pub srcSubpass: uint32_t,
    pub dstSubpass: uint32_t,
    pub srcStageMask: VkPipelineStageFlags,
    pub dstStageMask: VkPipelineStageFlags,
    /// Memory accesses from the source of the dependency to synchronize
    pub srcAccessMask: VkAccessFlags,
    /// Memory accesses from the destination of the dependency to synchronize
    pub dstAccessMask: VkAccessFlags,
    pub dependencyFlags: VkDependencyFlags,
}
impl_default_zeroed!(VkSubpassDependency);

/// `VkSubpassDependency2`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkSubpassDependency2 {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub srcSubpass: uint32_t,
    pub dstSubpass: uint32_t,
    pub srcStageMask: VkPipelineStageFlags,
    pub dstStageMask: VkPipelineStageFlags,
    pub srcAccessMask: VkAccessFlags,
    pub dstAccessMask: VkAccessFlags,
    pub dependencyFlags: VkDependencyFlags,
    pub viewOffset: int32_t,
}
impl_default_zeroed_with_s_type!(VkSubpassDependency2 : VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2);

/// `VkSubpassDependency2`
pub type VkSubpassDependency2KHR = VkSubpassDependency2;

/// `VkSubpassDescription`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkSubpassDescription {
    pub flags: VkSubpassDescriptionFlags,
    /// Must be VK_PIPELINE_BIND_POINT_GRAPHICS for now
    pub pipelineBindPoint: VkPipelineBindPoint,
    pub inputAttachmentCount: uint32_t,
    pub pInputAttachments: *const VkAttachmentReference,
    pub colorAttachmentCount: uint32_t,
    pub pColorAttachments: *const VkAttachmentReference,
    pub pResolveAttachments: *const VkAttachmentReference,
    pub pDepthStencilAttachment: *const VkAttachmentReference,
    pub preserveAttachmentCount: uint32_t,
    pub pPreserveAttachments: *const uint32_t,
}
impl_default_zeroed!(VkSubpassDescription);

/// `VkSubpassDescription2`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkSubpassDescription2 {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub flags: VkSubpassDescriptionFlags,
    pub pipelineBindPoint: VkPipelineBindPoint,
    pub viewMask: uint32_t,
    pub inputAttachmentCount: uint32_t,
    pub pInputAttachments: *const VkAttachmentReference2,
    pub colorAttachmentCount: uint32_t,
    pub pColorAttachments: *const VkAttachmentReference2,
    pub pResolveAttachments: *const VkAttachmentReference2,
    pub pDepthStencilAttachment: *const VkAttachmentReference2,
    pub preserveAttachmentCount: uint32_t,
    pub pPreserveAttachments: *const uint32_t,
}
impl_default_zeroed_with_s_type!(VkSubpassDescription2 : VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2);

/// `VkSubpassDescription2`
pub type VkSubpassDescription2KHR = VkSubpassDescription2;

/// `VkSubpassDescriptionDepthStencilResolve`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkSubpassDescriptionDepthStencilResolve {
    pub sType: VkStructureType,
    pub pNext: *const void,
    /// depth resolve mode
    pub depthResolveMode: VkResolveModeFlags,
    /// stencil resolve mode
    pub stencilResolveMode: VkResolveModeFlags,
    /// depth/stencil resolve attachment
    pub pDepthStencilResolveAttachment: *const VkAttachmentReference2,
}
impl_default_zeroed_with_s_type!(VkSubpassDescriptionDepthStencilResolve : VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE);
impl_extends!(VkSubpassDescriptionDepthStencilResolve : VkSubpassDescription2);

/// `VkSubpassDescriptionDepthStencilResolve`
pub type VkSubpassDescriptionDepthStencilResolveKHR = VkSubpassDescriptionDepthStencilResolve;

flags!(VkSubpassDescriptionFlags);
from_into_transparent!(VkSubpassDescriptionFlags: i32);
/// `VkSubpassDescriptionFlags`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkSubpassDescriptionFlags(pub i32);

/// `1 << 0`  
pub const VK_SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX: VkSubpassDescriptionFlags = VkSubpassDescriptionFlags(1 << 0);
/// `1 << 1`  
pub const VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX: VkSubpassDescriptionFlags = VkSubpassDescriptionFlags(1 << 1);
/// `VK_SUBPASS_DESCRIPTION_FRAGMENT_REGION_BIT_EXT`  
pub const VK_SUBPASS_DESCRIPTION_FRAGMENT_REGION_BIT_QCOM: VkSubpassDescriptionFlags = VK_SUBPASS_DESCRIPTION_FRAGMENT_REGION_BIT_EXT;
/// `VK_SUBPASS_DESCRIPTION_CUSTOM_RESOLVE_BIT_EXT`  
pub const VK_SUBPASS_DESCRIPTION_SHADER_RESOLVE_BIT_QCOM: VkSubpassDescriptionFlags = VK_SUBPASS_DESCRIPTION_CUSTOM_RESOLVE_BIT_EXT;
/// `1 << 8`  
pub const VK_SUBPASS_DESCRIPTION_TILE_SHADING_APRON_BIT_QCOM: VkSubpassDescriptionFlags = VkSubpassDescriptionFlags(1 << 8);
/// `VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_BIT_EXT`  
pub const VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_BIT_ARM: VkSubpassDescriptionFlags = VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_BIT_EXT;
/// `VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_EXT`  
pub const VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_ARM: VkSubpassDescriptionFlags = VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_EXT;
/// `VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_EXT`  
pub const VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_ARM: VkSubpassDescriptionFlags = VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_EXT;
/// `1 << 4`  
pub const VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_BIT_EXT: VkSubpassDescriptionFlags = VkSubpassDescriptionFlags(1 << 4);
/// `1 << 5`  
pub const VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_EXT: VkSubpassDescriptionFlags = VkSubpassDescriptionFlags(1 << 5);
/// `1 << 6`  
pub const VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_EXT: VkSubpassDescriptionFlags = VkSubpassDescriptionFlags(1 << 6);
/// `1 << 7`  
pub const VK_SUBPASS_DESCRIPTION_ENABLE_LEGACY_DITHERING_BIT_EXT: VkSubpassDescriptionFlags = VkSubpassDescriptionFlags(1 << 7);
/// `1 << 2`  
pub const VK_SUBPASS_DESCRIPTION_FRAGMENT_REGION_BIT_EXT: VkSubpassDescriptionFlags = VkSubpassDescriptionFlags(1 << 2);
/// `1 << 3`  
pub const VK_SUBPASS_DESCRIPTION_CUSTOM_RESOLVE_BIT_EXT: VkSubpassDescriptionFlags = VkSubpassDescriptionFlags(1 << 3);

impl_flags_display!(VkSubpassDescriptionFlags { VK_SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX, VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX, VK_SUBPASS_DESCRIPTION_FRAGMENT_REGION_BIT_QCOM, VK_SUBPASS_DESCRIPTION_SHADER_RESOLVE_BIT_QCOM, VK_SUBPASS_DESCRIPTION_TILE_SHADING_APRON_BIT_QCOM, VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_BIT_ARM, VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_ARM, VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_ARM, VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_BIT_EXT, VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_EXT, VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_EXT, VK_SUBPASS_DESCRIPTION_ENABLE_LEGACY_DITHERING_BIT_EXT, VK_SUBPASS_DESCRIPTION_FRAGMENT_REGION_BIT_EXT, VK_SUBPASS_DESCRIPTION_CUSTOM_RESOLVE_BIT_EXT });

/// `VkSubpassEndInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkSubpassEndInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
}
impl_default_zeroed_with_s_type!(VkSubpassEndInfo : VK_STRUCTURE_TYPE_SUBPASS_END_INFO);

/// `VkSubpassEndInfo`
pub type VkSubpassEndInfoKHR = VkSubpassEndInfo;

/// `VkRenderPassFragmentDensityMapOffsetEndInfoEXT`
pub type VkSubpassFragmentDensityMapOffsetEndInfoQCOM = VkRenderPassFragmentDensityMapOffsetEndInfoEXT;

from_into_transparent!(VkSubpassMergeStatusEXT: i32);
/// `VkSubpassMergeStatusEXT`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkSubpassMergeStatusEXT(pub i32);

/// `0`  
pub const VK_SUBPASS_MERGE_STATUS_MERGED_EXT: VkSubpassMergeStatusEXT = VkSubpassMergeStatusEXT(0);
/// `1`  
pub const VK_SUBPASS_MERGE_STATUS_DISALLOWED_EXT: VkSubpassMergeStatusEXT = VkSubpassMergeStatusEXT(1);
/// `2`  
pub const VK_SUBPASS_MERGE_STATUS_NOT_MERGED_SIDE_EFFECTS_EXT: VkSubpassMergeStatusEXT = VkSubpassMergeStatusEXT(2);
/// `3`  
pub const VK_SUBPASS_MERGE_STATUS_NOT_MERGED_SAMPLES_MISMATCH_EXT: VkSubpassMergeStatusEXT = VkSubpassMergeStatusEXT(3);
/// `4`  
pub const VK_SUBPASS_MERGE_STATUS_NOT_MERGED_VIEWS_MISMATCH_EXT: VkSubpassMergeStatusEXT = VkSubpassMergeStatusEXT(4);
/// `5`  
pub const VK_SUBPASS_MERGE_STATUS_NOT_MERGED_ALIASING_EXT: VkSubpassMergeStatusEXT = VkSubpassMergeStatusEXT(5);
/// `6`  
pub const VK_SUBPASS_MERGE_STATUS_NOT_MERGED_DEPENDENCIES_EXT: VkSubpassMergeStatusEXT = VkSubpassMergeStatusEXT(6);
/// `7`  
pub const VK_SUBPASS_MERGE_STATUS_NOT_MERGED_INCOMPATIBLE_INPUT_ATTACHMENT_EXT: VkSubpassMergeStatusEXT = VkSubpassMergeStatusEXT(7);
/// `8`  
pub const VK_SUBPASS_MERGE_STATUS_NOT_MERGED_TOO_MANY_ATTACHMENTS_EXT: VkSubpassMergeStatusEXT = VkSubpassMergeStatusEXT(8);
/// `9`  
pub const VK_SUBPASS_MERGE_STATUS_NOT_MERGED_INSUFFICIENT_STORAGE_EXT: VkSubpassMergeStatusEXT = VkSubpassMergeStatusEXT(9);
/// `10`  
pub const VK_SUBPASS_MERGE_STATUS_NOT_MERGED_DEPTH_STENCIL_COUNT_EXT: VkSubpassMergeStatusEXT = VkSubpassMergeStatusEXT(10);
/// `11`  
pub const VK_SUBPASS_MERGE_STATUS_NOT_MERGED_RESOLVE_ATTACHMENT_REUSE_EXT: VkSubpassMergeStatusEXT = VkSubpassMergeStatusEXT(11);
/// `12`  
pub const VK_SUBPASS_MERGE_STATUS_NOT_MERGED_SINGLE_SUBPASS_EXT: VkSubpassMergeStatusEXT = VkSubpassMergeStatusEXT(12);
/// `13`  
pub const VK_SUBPASS_MERGE_STATUS_NOT_MERGED_UNSPECIFIED_EXT: VkSubpassMergeStatusEXT = VkSubpassMergeStatusEXT(13);

impl_enum_display!(VkSubpassMergeStatusEXT { VK_SUBPASS_MERGE_STATUS_MERGED_EXT, VK_SUBPASS_MERGE_STATUS_DISALLOWED_EXT, VK_SUBPASS_MERGE_STATUS_NOT_MERGED_SIDE_EFFECTS_EXT, VK_SUBPASS_MERGE_STATUS_NOT_MERGED_SAMPLES_MISMATCH_EXT, VK_SUBPASS_MERGE_STATUS_NOT_MERGED_VIEWS_MISMATCH_EXT, VK_SUBPASS_MERGE_STATUS_NOT_MERGED_ALIASING_EXT, VK_SUBPASS_MERGE_STATUS_NOT_MERGED_DEPENDENCIES_EXT, VK_SUBPASS_MERGE_STATUS_NOT_MERGED_INCOMPATIBLE_INPUT_ATTACHMENT_EXT, VK_SUBPASS_MERGE_STATUS_NOT_MERGED_TOO_MANY_ATTACHMENTS_EXT, VK_SUBPASS_MERGE_STATUS_NOT_MERGED_INSUFFICIENT_STORAGE_EXT, VK_SUBPASS_MERGE_STATUS_NOT_MERGED_DEPTH_STENCIL_COUNT_EXT, VK_SUBPASS_MERGE_STATUS_NOT_MERGED_RESOLVE_ATTACHMENT_REUSE_EXT, VK_SUBPASS_MERGE_STATUS_NOT_MERGED_SINGLE_SUBPASS_EXT, VK_SUBPASS_MERGE_STATUS_NOT_MERGED_UNSPECIFIED_EXT });

/// `VkSubpassResolvePerformanceQueryEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkSubpassResolvePerformanceQueryEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub optimal: VkBool32,
}
impl_default_zeroed_with_s_type!(VkSubpassResolvePerformanceQueryEXT : VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT);
impl_extends!(VkSubpassResolvePerformanceQueryEXT : VkFormatProperties2);

/// `VkSubpassSampleLocationsEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkSubpassSampleLocationsEXT {
    pub subpassIndex: uint32_t,
    pub sampleLocationsInfo: VkSampleLocationsInfoEXT,
}
impl_default_zeroed!(VkSubpassSampleLocationsEXT);

/// `VkSubpassShadingPipelineCreateInfoHUAWEI`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkSubpassShadingPipelineCreateInfoHUAWEI {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub renderPass: VkRenderPass,
    pub subpass: uint32_t,
}
impl_default_zeroed_with_s_type!(VkSubpassShadingPipelineCreateInfoHUAWEI : VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI);
impl_extends!(VkSubpassShadingPipelineCreateInfoHUAWEI : VkComputePipelineCreateInfo);

/// `VkSubresourceHostMemcpySize`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkSubresourceHostMemcpySize {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    /// Specified in bytes
    pub size: VkDeviceSize,
}
impl_default_zeroed_with_s_type!(VkSubresourceHostMemcpySize : VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE);
impl_extends!(VkSubresourceHostMemcpySize : VkSubresourceLayout2);

/// `VkSubresourceHostMemcpySize`
pub type VkSubresourceHostMemcpySizeEXT = VkSubresourceHostMemcpySize;

/// `VkSubresourceLayout`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkSubresourceLayout {
    /// Specified in bytes
    pub offset: VkDeviceSize,
    /// Specified in bytes
    pub size: VkDeviceSize,
    /// Specified in bytes
    pub rowPitch: VkDeviceSize,
    /// Specified in bytes
    pub arrayPitch: VkDeviceSize,
    /// Specified in bytes
    pub depthPitch: VkDeviceSize,
}
impl_default_zeroed!(VkSubresourceLayout);

/// `VkSubresourceLayout2`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkSubresourceLayout2 {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub subresourceLayout: VkSubresourceLayout,
}
impl_default_zeroed_with_s_type!(VkSubresourceLayout2 : VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2);

/// `VkSubresourceLayout2`
pub type VkSubresourceLayout2EXT = VkSubresourceLayout2;

/// `VkSubresourceLayout2`
pub type VkSubresourceLayout2KHR = VkSubresourceLayout2;

/// `VkSubsampledImageFormatPropertiesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkSubsampledImageFormatPropertiesEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub subsampledImageDescriptorCount: uint32_t,
}
impl_default_zeroed_with_s_type!(VkSubsampledImageFormatPropertiesEXT : VK_STRUCTURE_TYPE_SUBSAMPLED_IMAGE_FORMAT_PROPERTIES_EXT);
impl_extends!(VkSubsampledImageFormatPropertiesEXT : VkImageFormatProperties2);

/// `VkSurfaceCapabilities2EXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkSurfaceCapabilities2EXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    /// Supported minimum number of images for the surface
    pub minImageCount: uint32_t,
    /// Supported maximum number of images for the surface, 0 for unlimited
    pub maxImageCount: uint32_t,
    /// Current image width and height for the surface, (0, 0) if undefined
    pub currentExtent: VkExtent2D,
    /// Supported minimum image width and height for the surface
    pub minImageExtent: VkExtent2D,
    /// Supported maximum image width and height for the surface
    pub maxImageExtent: VkExtent2D,
    /// Supported maximum number of image layers for the surface
    pub maxImageArrayLayers: uint32_t,
    /// 1 or more bits representing the transforms supported
    pub supportedTransforms: VkSurfaceTransformFlagsKHR,
    /// The surface's current transform relative to the device's natural orientation
    pub currentTransform: VkSurfaceTransformFlagsKHR,
    /// 1 or more bits representing the alpha compositing modes supported
    pub supportedCompositeAlpha: VkCompositeAlphaFlagsKHR,
    /// Supported image usage flags for the surface
    pub supportedUsageFlags: VkImageUsageFlags,
    pub supportedSurfaceCounters: VkSurfaceCounterFlagsEXT,
}
impl_default_zeroed_with_s_type!(VkSurfaceCapabilities2EXT : VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT);

/// `VkSurfaceCapabilities2KHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkSurfaceCapabilities2KHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub surfaceCapabilities: VkSurfaceCapabilitiesKHR,
}
impl_default_zeroed_with_s_type!(VkSurfaceCapabilities2KHR : VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR);

/// `VkSurfaceCapabilitiesFullScreenExclusiveEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkSurfaceCapabilitiesFullScreenExclusiveEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub fullScreenExclusiveSupported: VkBool32,
}
impl_default_zeroed_with_s_type!(VkSurfaceCapabilitiesFullScreenExclusiveEXT : VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT);
impl_extends!(VkSurfaceCapabilitiesFullScreenExclusiveEXT : VkSurfaceCapabilities2KHR);

/// `VkSurfaceCapabilitiesKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkSurfaceCapabilitiesKHR {
    /// Supported minimum number of images for the surface
    pub minImageCount: uint32_t,
    /// Supported maximum number of images for the surface, 0 for unlimited
    pub maxImageCount: uint32_t,
    /// Current image width and height for the surface, (0, 0) if undefined
    pub currentExtent: VkExtent2D,
    /// Supported minimum image width and height for the surface
    pub minImageExtent: VkExtent2D,
    /// Supported maximum image width and height for the surface
    pub maxImageExtent: VkExtent2D,
    /// Supported maximum number of image layers for the surface
    pub maxImageArrayLayers: uint32_t,
    /// 1 or more bits representing the transforms supported
    pub supportedTransforms: VkSurfaceTransformFlagsKHR,
    /// The surface's current transform relative to the device's natural orientation
    pub currentTransform: VkSurfaceTransformFlagsKHR,
    /// 1 or more bits representing the alpha compositing modes supported
    pub supportedCompositeAlpha: VkCompositeAlphaFlagsKHR,
    /// Supported image usage flags for the surface
    pub supportedUsageFlags: VkImageUsageFlags,
}
impl_default_zeroed!(VkSurfaceCapabilitiesKHR);

/// `VkSurfaceCapabilitiesPresentBarrierNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkSurfaceCapabilitiesPresentBarrierNV {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub presentBarrierSupported: VkBool32,
}
impl_default_zeroed_with_s_type!(VkSurfaceCapabilitiesPresentBarrierNV : VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV);
impl_extends!(VkSurfaceCapabilitiesPresentBarrierNV : VkSurfaceCapabilities2KHR);

/// `VkSurfaceCapabilitiesPresentId2KHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkSurfaceCapabilitiesPresentId2KHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub presentId2Supported: VkBool32,
}
impl_default_zeroed_with_s_type!(VkSurfaceCapabilitiesPresentId2KHR : VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_ID_2_KHR);
impl_extends!(VkSurfaceCapabilitiesPresentId2KHR : VkSurfaceCapabilities2KHR);

/// `VkSurfaceCapabilitiesPresentWait2KHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkSurfaceCapabilitiesPresentWait2KHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub presentWait2Supported: VkBool32,
}
impl_default_zeroed_with_s_type!(VkSurfaceCapabilitiesPresentWait2KHR : VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_WAIT_2_KHR);
impl_extends!(VkSurfaceCapabilitiesPresentWait2KHR : VkSurfaceCapabilities2KHR);

flags!(VkSurfaceCounterFlagsEXT);
from_into_transparent!(VkSurfaceCounterFlagsEXT: i32);
/// `VkSurfaceCounterFlagsEXT`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkSurfaceCounterFlagsEXT(pub i32);

/// `1 << 0`  
pub const VK_SURFACE_COUNTER_VBLANK_BIT_EXT: VkSurfaceCounterFlagsEXT = VkSurfaceCounterFlagsEXT(1 << 0);
/// `VK_SURFACE_COUNTER_VBLANK_BIT_EXT`  
pub const VK_SURFACE_COUNTER_VBLANK_EXT: VkSurfaceCounterFlagsEXT = VK_SURFACE_COUNTER_VBLANK_BIT_EXT;

impl_flags_display!(VkSurfaceCounterFlagsEXT { VK_SURFACE_COUNTER_VBLANK_BIT_EXT, VK_SURFACE_COUNTER_VBLANK_EXT });

flags!(VkSurfaceCreateFlagsOHOS);
from_into_transparent!(VkSurfaceCreateFlagsOHOS: i32);
/// `VkSurfaceCreateFlagsOHOS`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkSurfaceCreateFlagsOHOS(pub i32);

impl_flags_display!(VkSurfaceCreateFlagsOHOS {  });

/// `VkSurfaceCreateInfoOHOS`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkSurfaceCreateInfoOHOS {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub flags: VkSurfaceCreateFlagsOHOS,
    pub window: *mut OHNativeWindow,
}
impl_default_zeroed_with_s_type!(VkSurfaceCreateInfoOHOS : VK_STRUCTURE_TYPE_SURFACE_CREATE_INFO_OHOS);

/// `VkSurfaceFormat2KHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkSurfaceFormat2KHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub surfaceFormat: VkSurfaceFormatKHR,
}
impl_default_zeroed_with_s_type!(VkSurfaceFormat2KHR : VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR);

/// `VkSurfaceFormatKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkSurfaceFormatKHR {
    /// Supported pair of rendering format
    pub format: VkFormat,
    /// and color space for the surface
    pub colorSpace: VkColorSpaceKHR,
}
impl_default_zeroed!(VkSurfaceFormatKHR);

/// `VkSurfaceFullScreenExclusiveInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkSurfaceFullScreenExclusiveInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub fullScreenExclusive: VkFullScreenExclusiveEXT,
}
impl_default_zeroed_with_s_type!(VkSurfaceFullScreenExclusiveInfoEXT : VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT);
impl_extends!(VkSurfaceFullScreenExclusiveInfoEXT : VkPhysicalDeviceSurfaceInfo2KHR, VkSwapchainCreateInfoKHR);

/// `VkSurfaceFullScreenExclusiveWin32InfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkSurfaceFullScreenExclusiveWin32InfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub hmonitor: HMONITOR,
}
impl_default_zeroed_with_s_type!(VkSurfaceFullScreenExclusiveWin32InfoEXT : VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT);
impl_extends!(VkSurfaceFullScreenExclusiveWin32InfoEXT : VkPhysicalDeviceSurfaceInfo2KHR, VkSwapchainCreateInfoKHR);

/// `VkSurfaceKHR` : `VkInstance`
#[repr(transparent)]
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkSurfaceKHR(pub u64);
from_into_transparent!(VkSurfaceKHR: u64);
impl_handle!(VkSurfaceKHR: VK_OBJECT_TYPE_SURFACE_KHR; SubHandle = VkInstance);

/// `VkSurfacePresentModeCompatibilityKHR`
pub type VkSurfacePresentModeCompatibilityEXT = VkSurfacePresentModeCompatibilityKHR;

/// `VkSurfacePresentModeCompatibilityKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkSurfacePresentModeCompatibilityKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub presentModeCount: uint32_t,
    /// Output list of present modes compatible with the one specified in VkSurfacePresentModeKHR
    pub pPresentModes: *mut VkPresentModeKHR,
}
impl_default_zeroed_with_s_type!(VkSurfacePresentModeCompatibilityKHR : VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_KHR);
impl_extends!(VkSurfacePresentModeCompatibilityKHR : VkSurfaceCapabilities2KHR);

/// `VkSurfacePresentModeKHR`
pub type VkSurfacePresentModeEXT = VkSurfacePresentModeKHR;

/// `VkSurfacePresentModeKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkSurfacePresentModeKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub presentMode: VkPresentModeKHR,
}
impl_default_zeroed_with_s_type!(VkSurfacePresentModeKHR : VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_KHR);
impl_extends!(VkSurfacePresentModeKHR : VkPhysicalDeviceSurfaceInfo2KHR);

/// `VkSurfacePresentScalingCapabilitiesKHR`
pub type VkSurfacePresentScalingCapabilitiesEXT = VkSurfacePresentScalingCapabilitiesKHR;

/// `VkSurfacePresentScalingCapabilitiesKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkSurfacePresentScalingCapabilitiesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub supportedPresentScaling: VkPresentScalingFlagsKHR,
    pub supportedPresentGravityX: VkPresentGravityFlagsKHR,
    pub supportedPresentGravityY: VkPresentGravityFlagsKHR,
    /// Supported minimum image width and height for the surface when scaling is used
    pub minScaledImageExtent: VkExtent2D,
    /// Supported maximum image width and height for the surface when scaling is used
    pub maxScaledImageExtent: VkExtent2D,
}
impl_default_zeroed_with_s_type!(VkSurfacePresentScalingCapabilitiesKHR : VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_KHR);
impl_extends!(VkSurfacePresentScalingCapabilitiesKHR : VkSurfaceCapabilities2KHR);

/// `VkSurfaceProtectedCapabilitiesKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkSurfaceProtectedCapabilitiesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    /// Represents if surface can be protected
    pub supportsProtected: VkBool32,
}
impl_default_zeroed_with_s_type!(VkSurfaceProtectedCapabilitiesKHR : VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR);
impl_extends!(VkSurfaceProtectedCapabilitiesKHR : VkSurfaceCapabilities2KHR);

flags!(VkSurfaceTransformFlagsKHR);
from_into_transparent!(VkSurfaceTransformFlagsKHR: i32);
/// `VkSurfaceTransformFlagsKHR`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkSurfaceTransformFlagsKHR(pub i32);

/// `1 << 0`  
pub const VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR: VkSurfaceTransformFlagsKHR = VkSurfaceTransformFlagsKHR(1 << 0);
/// `1 << 1`  
pub const VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR: VkSurfaceTransformFlagsKHR = VkSurfaceTransformFlagsKHR(1 << 1);
/// `1 << 2`  
pub const VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR: VkSurfaceTransformFlagsKHR = VkSurfaceTransformFlagsKHR(1 << 2);
/// `1 << 3`  
pub const VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR: VkSurfaceTransformFlagsKHR = VkSurfaceTransformFlagsKHR(1 << 3);
/// `1 << 4`  
pub const VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR: VkSurfaceTransformFlagsKHR = VkSurfaceTransformFlagsKHR(1 << 4);
/// `1 << 5`  
pub const VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR: VkSurfaceTransformFlagsKHR = VkSurfaceTransformFlagsKHR(1 << 5);
/// `1 << 6`  
pub const VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR: VkSurfaceTransformFlagsKHR = VkSurfaceTransformFlagsKHR(1 << 6);
/// `1 << 7`  
pub const VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR: VkSurfaceTransformFlagsKHR = VkSurfaceTransformFlagsKHR(1 << 7);
/// `1 << 8`  
pub const VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR: VkSurfaceTransformFlagsKHR = VkSurfaceTransformFlagsKHR(1 << 8);

impl_flags_display!(VkSurfaceTransformFlagsKHR { VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR, VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR, VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR, VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR, VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR, VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR, VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR, VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR, VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR });

/// `VkSwapchainCalibratedTimestampInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkSwapchainCalibratedTimestampInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub swapchain: VkSwapchainKHR,
    pub presentStage: VkPresentStageFlagsEXT,
    pub timeDomainId: uint64_t,
}
impl_default_zeroed_with_s_type!(VkSwapchainCalibratedTimestampInfoEXT : VK_STRUCTURE_TYPE_SWAPCHAIN_CALIBRATED_TIMESTAMP_INFO_EXT);
impl_extends!(VkSwapchainCalibratedTimestampInfoEXT : VkCalibratedTimestampInfoKHR);

/// `VkSwapchainCounterCreateInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkSwapchainCounterCreateInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub surfaceCounters: VkSurfaceCounterFlagsEXT,
}
impl_default_zeroed_with_s_type!(VkSwapchainCounterCreateInfoEXT : VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT);
impl_extends!(VkSwapchainCounterCreateInfoEXT : VkSwapchainCreateInfoKHR);

flags!(VkSwapchainCreateFlagsKHR);
from_into_transparent!(VkSwapchainCreateFlagsKHR: i32);
/// `VkSwapchainCreateFlagsKHR`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkSwapchainCreateFlagsKHR(pub i32);

/// `1 << 0`  
/// 
/// Allow images with VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT
pub const VK_SWAPCHAIN_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR: VkSwapchainCreateFlagsKHR = VkSwapchainCreateFlagsKHR(1 << 0);
/// `1 << 1`  
/// 
/// Swapchain is protected
pub const VK_SWAPCHAIN_CREATE_PROTECTED_BIT_KHR: VkSwapchainCreateFlagsKHR = VkSwapchainCreateFlagsKHR(1 << 1);
/// `1 << 2`  
pub const VK_SWAPCHAIN_CREATE_MUTABLE_FORMAT_BIT_KHR: VkSwapchainCreateFlagsKHR = VkSwapchainCreateFlagsKHR(1 << 2);
/// `1 << 9`  
pub const VK_SWAPCHAIN_CREATE_PRESENT_TIMING_BIT_EXT: VkSwapchainCreateFlagsKHR = VkSwapchainCreateFlagsKHR(1 << 9);
/// `VK_SWAPCHAIN_CREATE_DEFERRED_MEMORY_ALLOCATION_BIT_KHR`  
pub const VK_SWAPCHAIN_CREATE_DEFERRED_MEMORY_ALLOCATION_BIT_EXT: VkSwapchainCreateFlagsKHR = VK_SWAPCHAIN_CREATE_DEFERRED_MEMORY_ALLOCATION_BIT_KHR;
/// `1 << 5`  
pub const VK_SWAPCHAIN_CREATE_RESERVED_5_BIT_EXT: VkSwapchainCreateFlagsKHR = VkSwapchainCreateFlagsKHR(1 << 5);
/// `1 << 4`  
pub const VK_SWAPCHAIN_CREATE_RESERVED_4_BIT_EXT: VkSwapchainCreateFlagsKHR = VkSwapchainCreateFlagsKHR(1 << 4);
/// `1 << 6`  
/// 
/// Allow use of VK_KHR_present_id2 with this swapchain
pub const VK_SWAPCHAIN_CREATE_PRESENT_ID_2_BIT_KHR: VkSwapchainCreateFlagsKHR = VkSwapchainCreateFlagsKHR(1 << 6);
/// `1 << 7`  
/// 
/// Allow use of VK_KHR_present_wait2 with this swapchain
pub const VK_SWAPCHAIN_CREATE_PRESENT_WAIT_2_BIT_KHR: VkSwapchainCreateFlagsKHR = VkSwapchainCreateFlagsKHR(1 << 7);
/// `1 << 3`  
pub const VK_SWAPCHAIN_CREATE_DEFERRED_MEMORY_ALLOCATION_BIT_KHR: VkSwapchainCreateFlagsKHR = VkSwapchainCreateFlagsKHR(1 << 3);
/// `1 << 8`  
pub const VK_SWAPCHAIN_CREATE_RESERVED_8_BIT_EXT: VkSwapchainCreateFlagsKHR = VkSwapchainCreateFlagsKHR(1 << 8);

impl_flags_display!(VkSwapchainCreateFlagsKHR { VK_SWAPCHAIN_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR, VK_SWAPCHAIN_CREATE_PROTECTED_BIT_KHR, VK_SWAPCHAIN_CREATE_MUTABLE_FORMAT_BIT_KHR, VK_SWAPCHAIN_CREATE_PRESENT_TIMING_BIT_EXT, VK_SWAPCHAIN_CREATE_DEFERRED_MEMORY_ALLOCATION_BIT_EXT, VK_SWAPCHAIN_CREATE_RESERVED_5_BIT_EXT, VK_SWAPCHAIN_CREATE_RESERVED_4_BIT_EXT, VK_SWAPCHAIN_CREATE_PRESENT_ID_2_BIT_KHR, VK_SWAPCHAIN_CREATE_PRESENT_WAIT_2_BIT_KHR, VK_SWAPCHAIN_CREATE_DEFERRED_MEMORY_ALLOCATION_BIT_KHR, VK_SWAPCHAIN_CREATE_RESERVED_8_BIT_EXT });

/// `VkSwapchainCreateInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkSwapchainCreateInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub flags: VkSwapchainCreateFlagsKHR,
    /// The swapchain's target surface
    pub surface: VkSurfaceKHR,
    /// Minimum number of presentation images the application needs
    pub minImageCount: uint32_t,
    /// Format of the presentation images
    pub imageFormat: VkFormat,
    /// Colorspace of the presentation images
    pub imageColorSpace: VkColorSpaceKHR,
    /// Dimensions of the presentation images
    pub imageExtent: VkExtent2D,
    /// Determines the number of views for multiview/stereo presentation
    pub imageArrayLayers: uint32_t,
    /// Bits indicating how the presentation images will be used
    pub imageUsage: VkImageUsageFlags,
    /// Sharing mode used for the presentation images
    pub imageSharingMode: VkSharingMode,
    /// Number of queue families having access to the images in case of concurrent sharing mode
    pub queueFamilyIndexCount: uint32_t,
    /// Array of queue family indices having access to the images in case of concurrent sharing mode
    pub pQueueFamilyIndices: *const uint32_t,
    /// The transform, relative to the device's natural orientation, applied to the image content prior to presentation
    pub preTransform: VkSurfaceTransformFlagsKHR,
    /// The alpha blending mode used when compositing this surface with other surfaces in the window system
    pub compositeAlpha: VkCompositeAlphaFlagsKHR,
    /// Which presentation mode to use for presents on this swap chain
    pub presentMode: VkPresentModeKHR,
    /// Specifies whether presentable images may be affected by window clip regions
    pub clipped: VkBool32,
    /// Existing swap chain to replace, if any
    pub oldSwapchain: VkSwapchainKHR,
}
impl_default_zeroed_with_s_type!(VkSwapchainCreateInfoKHR : VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR);

/// `VkSwapchainDisplayNativeHdrCreateInfoAMD`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkSwapchainDisplayNativeHdrCreateInfoAMD {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub localDimmingEnable: VkBool32,
}
impl_default_zeroed_with_s_type!(VkSwapchainDisplayNativeHdrCreateInfoAMD : VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD);
impl_extends!(VkSwapchainDisplayNativeHdrCreateInfoAMD : VkSwapchainCreateInfoKHR);

/// `VkSwapchainImageCreateInfoANDROID`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkSwapchainImageCreateInfoANDROID {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub usage: VkSwapchainImageUsageFlagsANDROID,
}
impl_default_zeroed_with_s_type!(VkSwapchainImageCreateInfoANDROID : VK_STRUCTURE_TYPE_SWAPCHAIN_IMAGE_CREATE_INFO_ANDROID);
impl_extends!(VkSwapchainImageCreateInfoANDROID : VkImageCreateInfo);

/// `VkSwapchainImageCreateInfoOHOS`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkSwapchainImageCreateInfoOHOS {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub usage: VkSwapchainImageUsageFlagsOHOS,
}
impl_default_zeroed_with_s_type!(VkSwapchainImageCreateInfoOHOS : VK_STRUCTURE_TYPE_SWAPCHAIN_IMAGE_CREATE_INFO_OHOS);
impl_extends!(VkSwapchainImageCreateInfoOHOS : VkImageCreateInfo);

flags!(VkSwapchainImageUsageFlagsANDROID);
from_into_transparent!(VkSwapchainImageUsageFlagsANDROID: i32);
/// `VkSwapchainImageUsageFlagsANDROID`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkSwapchainImageUsageFlagsANDROID(pub i32);

/// `1 << 0`  
pub const VK_SWAPCHAIN_IMAGE_USAGE_SHARED_BIT_ANDROID: VkSwapchainImageUsageFlagsANDROID = VkSwapchainImageUsageFlagsANDROID(1 << 0);

impl_flags_display!(VkSwapchainImageUsageFlagsANDROID { VK_SWAPCHAIN_IMAGE_USAGE_SHARED_BIT_ANDROID });

flags!(VkSwapchainImageUsageFlagsOHOS);
from_into_transparent!(VkSwapchainImageUsageFlagsOHOS: i32);
/// `VkSwapchainImageUsageFlagsOHOS`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkSwapchainImageUsageFlagsOHOS(pub i32);

/// `1 << 0`  
pub const VK_SWAPCHAIN_IMAGE_USAGE_SHARED_BIT_OHOS: VkSwapchainImageUsageFlagsOHOS = VkSwapchainImageUsageFlagsOHOS(1 << 0);

impl_flags_display!(VkSwapchainImageUsageFlagsOHOS { VK_SWAPCHAIN_IMAGE_USAGE_SHARED_BIT_OHOS });

/// `VkSwapchainKHR` : `VkDevice`
#[repr(transparent)]
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkSwapchainKHR(pub u64);
from_into_transparent!(VkSwapchainKHR: u64);
impl_handle!(VkSwapchainKHR: VK_OBJECT_TYPE_SWAPCHAIN_KHR; SubHandle = VkDevice);

/// `VkSwapchainLatencyCreateInfoNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkSwapchainLatencyCreateInfoNV {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub latencyModeEnable: VkBool32,
}
impl_default_zeroed_with_s_type!(VkSwapchainLatencyCreateInfoNV : VK_STRUCTURE_TYPE_SWAPCHAIN_LATENCY_CREATE_INFO_NV);
impl_extends!(VkSwapchainLatencyCreateInfoNV : VkSwapchainCreateInfoKHR);

/// `VkSwapchainPresentBarrierCreateInfoNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkSwapchainPresentBarrierCreateInfoNV {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub presentBarrierEnable: VkBool32,
}
impl_default_zeroed_with_s_type!(VkSwapchainPresentBarrierCreateInfoNV : VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV);
impl_extends!(VkSwapchainPresentBarrierCreateInfoNV : VkSwapchainCreateInfoKHR);

/// `VkSwapchainPresentFenceInfoKHR`
pub type VkSwapchainPresentFenceInfoEXT = VkSwapchainPresentFenceInfoKHR;

/// `VkSwapchainPresentFenceInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkSwapchainPresentFenceInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    /// Copy of VkPresentInfoKHR::swapchainCount
    pub swapchainCount: uint32_t,
    /// Fence to signal for each swapchain
    pub pFences: *const VkFence,
}
impl_default_zeroed_with_s_type!(VkSwapchainPresentFenceInfoKHR : VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_KHR);
impl_extends!(VkSwapchainPresentFenceInfoKHR : VkPresentInfoKHR);

/// `VkSwapchainPresentModeInfoKHR`
pub type VkSwapchainPresentModeInfoEXT = VkSwapchainPresentModeInfoKHR;

/// `VkSwapchainPresentModeInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkSwapchainPresentModeInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    /// Copy of VkPresentInfoKHR::swapchainCount
    pub swapchainCount: uint32_t,
    /// Presentation mode for each swapchain
    pub pPresentModes: *const VkPresentModeKHR,
}
impl_default_zeroed_with_s_type!(VkSwapchainPresentModeInfoKHR : VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_KHR);
impl_extends!(VkSwapchainPresentModeInfoKHR : VkPresentInfoKHR);

/// `VkSwapchainPresentModesCreateInfoKHR`
pub type VkSwapchainPresentModesCreateInfoEXT = VkSwapchainPresentModesCreateInfoKHR;

/// `VkSwapchainPresentModesCreateInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkSwapchainPresentModesCreateInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub presentModeCount: uint32_t,
    pub pPresentModes: *const VkPresentModeKHR,
}
impl_default_zeroed_with_s_type!(VkSwapchainPresentModesCreateInfoKHR : VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_KHR);
impl_extends!(VkSwapchainPresentModesCreateInfoKHR : VkSwapchainCreateInfoKHR);

/// `VkSwapchainPresentScalingCreateInfoKHR`
pub type VkSwapchainPresentScalingCreateInfoEXT = VkSwapchainPresentScalingCreateInfoKHR;

/// `VkSwapchainPresentScalingCreateInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkSwapchainPresentScalingCreateInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub scalingBehavior: VkPresentScalingFlagsKHR,
    pub presentGravityX: VkPresentGravityFlagsKHR,
    pub presentGravityY: VkPresentGravityFlagsKHR,
}
impl_default_zeroed_with_s_type!(VkSwapchainPresentScalingCreateInfoKHR : VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_KHR);
impl_extends!(VkSwapchainPresentScalingCreateInfoKHR : VkSwapchainCreateInfoKHR);

/// `VkSwapchainTimeDomainPropertiesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkSwapchainTimeDomainPropertiesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub timeDomainCount: uint32_t,
    /// Available time domains to use with the swapchain
    pub pTimeDomains: *mut VkTimeDomainKHR,
    /// Unique identifier for a time domain
    pub pTimeDomainIds: *mut uint64_t,
}
impl_default_zeroed_with_s_type!(VkSwapchainTimeDomainPropertiesEXT : VK_STRUCTURE_TYPE_SWAPCHAIN_TIME_DOMAIN_PROPERTIES_EXT);

/// `VkSwapchainTimingPropertiesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkSwapchainTimingPropertiesEXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    /// Number of nanoseconds from the start of one refresh cycle to the next
    pub refreshDuration: uint64_t,
    /// Interval in nanoseconds between refresh cycles durations
    pub refreshInterval: uint64_t,
}
impl_default_zeroed_with_s_type!(VkSwapchainTimingPropertiesEXT : VK_STRUCTURE_TYPE_SWAPCHAIN_TIMING_PROPERTIES_EXT);

/// `VkSysmemColorSpaceFUCHSIA`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkSysmemColorSpaceFUCHSIA {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub colorSpace: uint32_t,
}
impl_default_zeroed_with_s_type!(VkSysmemColorSpaceFUCHSIA : VK_STRUCTURE_TYPE_SYSMEM_COLOR_SPACE_FUCHSIA);

from_into_transparent!(VkSystemAllocationScope: i32);
/// `VkSystemAllocationScope`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkSystemAllocationScope(pub i32);

/// `0`  
pub const VK_SYSTEM_ALLOCATION_SCOPE_COMMAND: VkSystemAllocationScope = VkSystemAllocationScope(0);
/// `1`  
pub const VK_SYSTEM_ALLOCATION_SCOPE_OBJECT: VkSystemAllocationScope = VkSystemAllocationScope(1);
/// `2`  
pub const VK_SYSTEM_ALLOCATION_SCOPE_CACHE: VkSystemAllocationScope = VkSystemAllocationScope(2);
/// `3`  
pub const VK_SYSTEM_ALLOCATION_SCOPE_DEVICE: VkSystemAllocationScope = VkSystemAllocationScope(3);
/// `4`  
pub const VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE: VkSystemAllocationScope = VkSystemAllocationScope(4);

impl_enum_display!(VkSystemAllocationScope { VK_SYSTEM_ALLOCATION_SCOPE_COMMAND, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT, VK_SYSTEM_ALLOCATION_SCOPE_CACHE, VK_SYSTEM_ALLOCATION_SCOPE_DEVICE, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE });

/// `VkTensorARM` : `VkDevice`
#[repr(transparent)]
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkTensorARM(pub u64);
from_into_transparent!(VkTensorARM: u64);
impl_handle!(VkTensorARM: VK_OBJECT_TYPE_TENSOR_ARM; SubHandle = VkDevice);

/// `VkTensorCaptureDescriptorDataInfoARM`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkTensorCaptureDescriptorDataInfoARM {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub tensor: VkTensorARM,
}
impl_default_zeroed_with_s_type!(VkTensorCaptureDescriptorDataInfoARM : VK_STRUCTURE_TYPE_TENSOR_CAPTURE_DESCRIPTOR_DATA_INFO_ARM);

/// `VkTensorCopyARM`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkTensorCopyARM {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub dimensionCount: uint32_t,
    pub pSrcOffset: *const uint64_t,
    pub pDstOffset: *const uint64_t,
    pub pExtent: *const uint64_t,
}
impl_default_zeroed_with_s_type!(VkTensorCopyARM : VK_STRUCTURE_TYPE_TENSOR_COPY_ARM);

flags!(VkTensorCreateFlagsARM);
from_into_transparent!(VkTensorCreateFlagsARM: i64);
/// `VkTensorCreateFlagsARM`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkTensorCreateFlagsARM(pub i64);

/// `1 << 0`  
pub const VK_TENSOR_CREATE_MUTABLE_FORMAT_BIT_ARM: VkTensorCreateFlagsARM = VkTensorCreateFlagsARM(1 << 0);
/// `1 << 1`  
pub const VK_TENSOR_CREATE_PROTECTED_BIT_ARM: VkTensorCreateFlagsARM = VkTensorCreateFlagsARM(1 << 1);
/// `1 << 3`  
pub const VK_TENSOR_CREATE_DESCRIPTOR_HEAP_CAPTURE_REPLAY_BIT_ARM: VkTensorCreateFlagsARM = VkTensorCreateFlagsARM(1 << 3);
/// `1 << 2`  
pub const VK_TENSOR_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_ARM: VkTensorCreateFlagsARM = VkTensorCreateFlagsARM(1 << 2);

impl_flags_display!(VkTensorCreateFlagsARM { VK_TENSOR_CREATE_MUTABLE_FORMAT_BIT_ARM, VK_TENSOR_CREATE_PROTECTED_BIT_ARM, VK_TENSOR_CREATE_DESCRIPTOR_HEAP_CAPTURE_REPLAY_BIT_ARM, VK_TENSOR_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_ARM });

/// `VkTensorCreateInfoARM`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkTensorCreateInfoARM {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub flags: VkTensorCreateFlagsARM,
    pub pDescription: *const VkTensorDescriptionARM,
    pub sharingMode: VkSharingMode,
    pub queueFamilyIndexCount: uint32_t,
    pub pQueueFamilyIndices: *const uint32_t,
}
impl_default_zeroed_with_s_type!(VkTensorCreateInfoARM : VK_STRUCTURE_TYPE_TENSOR_CREATE_INFO_ARM);

/// `VkTensorDependencyInfoARM`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkTensorDependencyInfoARM {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub tensorMemoryBarrierCount: uint32_t,
    pub pTensorMemoryBarriers: *const VkTensorMemoryBarrierARM,
}
impl_default_zeroed_with_s_type!(VkTensorDependencyInfoARM : VK_STRUCTURE_TYPE_TENSOR_DEPENDENCY_INFO_ARM);
impl_extends!(VkTensorDependencyInfoARM : VkDependencyInfo);

/// `VkTensorDescriptionARM`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkTensorDescriptionARM {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub tiling: VkTensorTilingARM,
    pub format: VkFormat,
    pub dimensionCount: uint32_t,
    pub pDimensions: *const int64_t,
    pub pStrides: *const int64_t,
    pub usage: VkTensorUsageFlagsARM,
}
impl_default_zeroed_with_s_type!(VkTensorDescriptionARM : VK_STRUCTURE_TYPE_TENSOR_DESCRIPTION_ARM);
impl_extends!(VkTensorDescriptionARM : VkDataGraphPipelineResourceInfoARM, VkDataGraphPipelineConstantARM);

/// `VkTensorFormatPropertiesARM`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkTensorFormatPropertiesARM {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub optimalTilingTensorFeatures: VkFormatFeatureFlags2,
    pub linearTilingTensorFeatures: VkFormatFeatureFlags2,
}
impl_default_zeroed_with_s_type!(VkTensorFormatPropertiesARM : VK_STRUCTURE_TYPE_TENSOR_FORMAT_PROPERTIES_ARM);
impl_extends!(VkTensorFormatPropertiesARM : VkFormatProperties2);

/// `VkTensorMemoryBarrierARM`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkTensorMemoryBarrierARM {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub srcStageMask: VkPipelineStageFlags2,
    pub srcAccessMask: VkAccessFlags2,
    pub dstStageMask: VkPipelineStageFlags2,
    pub dstAccessMask: VkAccessFlags2,
    pub srcQueueFamilyIndex: uint32_t,
    pub dstQueueFamilyIndex: uint32_t,
    pub tensor: VkTensorARM,
}
impl_default_zeroed_with_s_type!(VkTensorMemoryBarrierARM : VK_STRUCTURE_TYPE_TENSOR_MEMORY_BARRIER_ARM);
impl_extends!(VkTensorMemoryBarrierARM : VkDependencyInfo);

/// `VkTensorMemoryRequirementsInfoARM`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkTensorMemoryRequirementsInfoARM {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub tensor: VkTensorARM,
}
impl_default_zeroed_with_s_type!(VkTensorMemoryRequirementsInfoARM : VK_STRUCTURE_TYPE_TENSOR_MEMORY_REQUIREMENTS_INFO_ARM);

from_into_transparent!(VkTensorTilingARM: i32);
/// `VkTensorTilingARM`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkTensorTilingARM(pub i32);

/// `0`  
pub const VK_TENSOR_TILING_OPTIMAL_ARM: VkTensorTilingARM = VkTensorTilingARM(0);
/// `1`  
pub const VK_TENSOR_TILING_LINEAR_ARM: VkTensorTilingARM = VkTensorTilingARM(1);

impl_enum_display!(VkTensorTilingARM { VK_TENSOR_TILING_OPTIMAL_ARM, VK_TENSOR_TILING_LINEAR_ARM });

flags!(VkTensorUsageFlagsARM);
from_into_transparent!(VkTensorUsageFlagsARM: i64);
/// `VkTensorUsageFlagsARM`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkTensorUsageFlagsARM(pub i64);

/// `1 << 1`  
/// 
/// Tensor written/read through shader descriptor
pub const VK_TENSOR_USAGE_SHADER_BIT_ARM: VkTensorUsageFlagsARM = VkTensorUsageFlagsARM(1 << 1);
/// `1 << 2`  
/// 
/// Tensor can be src of a transfer operation
pub const VK_TENSOR_USAGE_TRANSFER_SRC_BIT_ARM: VkTensorUsageFlagsARM = VkTensorUsageFlagsARM(1 << 2);
/// `1 << 3`  
/// 
/// Tensor can be dst of a transfer operation
pub const VK_TENSOR_USAGE_TRANSFER_DST_BIT_ARM: VkTensorUsageFlagsARM = VkTensorUsageFlagsARM(1 << 3);
/// `1 << 4`  
/// 
/// Tensor can be aliased with an image
pub const VK_TENSOR_USAGE_IMAGE_ALIASING_BIT_ARM: VkTensorUsageFlagsARM = VkTensorUsageFlagsARM(1 << 4);
/// `1 << 5`  
pub const VK_TENSOR_USAGE_DATA_GRAPH_BIT_ARM: VkTensorUsageFlagsARM = VkTensorUsageFlagsARM(1 << 5);

impl_flags_display!(VkTensorUsageFlagsARM { VK_TENSOR_USAGE_SHADER_BIT_ARM, VK_TENSOR_USAGE_TRANSFER_SRC_BIT_ARM, VK_TENSOR_USAGE_TRANSFER_DST_BIT_ARM, VK_TENSOR_USAGE_IMAGE_ALIASING_BIT_ARM, VK_TENSOR_USAGE_DATA_GRAPH_BIT_ARM });

/// `VkTensorViewARM` : `VkDevice`
#[repr(transparent)]
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkTensorViewARM(pub u64);
from_into_transparent!(VkTensorViewARM: u64);
impl_handle!(VkTensorViewARM: VK_OBJECT_TYPE_TENSOR_VIEW_ARM; SubHandle = VkDevice);

/// `VkTensorViewCaptureDescriptorDataInfoARM`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkTensorViewCaptureDescriptorDataInfoARM {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub tensorView: VkTensorViewARM,
}
impl_default_zeroed_with_s_type!(VkTensorViewCaptureDescriptorDataInfoARM : VK_STRUCTURE_TYPE_TENSOR_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_ARM);

flags!(VkTensorViewCreateFlagsARM);
from_into_transparent!(VkTensorViewCreateFlagsARM: i64);
/// `VkTensorViewCreateFlagsARM`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkTensorViewCreateFlagsARM(pub i64);

/// `1 << 0`  
pub const VK_TENSOR_VIEW_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_ARM: VkTensorViewCreateFlagsARM = VkTensorViewCreateFlagsARM(1 << 0);

impl_flags_display!(VkTensorViewCreateFlagsARM { VK_TENSOR_VIEW_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_ARM });

/// `VkTensorViewCreateInfoARM`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkTensorViewCreateInfoARM {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub flags: VkTensorViewCreateFlagsARM,
    pub tensor: VkTensorARM,
    pub format: VkFormat,
}
impl_default_zeroed_with_s_type!(VkTensorViewCreateInfoARM : VK_STRUCTURE_TYPE_TENSOR_VIEW_CREATE_INFO_ARM);

from_into_transparent!(VkTessellationDomainOrigin: i32);
/// `VkTessellationDomainOrigin`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkTessellationDomainOrigin(pub i32);

/// `0`  
pub const VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT: VkTessellationDomainOrigin = VkTessellationDomainOrigin(0);
/// `1`  
pub const VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT: VkTessellationDomainOrigin = VkTessellationDomainOrigin(1);
/// `VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT`  
pub const VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT_KHR: VkTessellationDomainOrigin = VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT;
/// `VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT`  
pub const VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT_KHR: VkTessellationDomainOrigin = VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT;

impl_enum_display!(VkTessellationDomainOrigin { VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT, VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT, VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT_KHR, VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT_KHR });

/// `VkTessellationDomainOrigin`
pub type VkTessellationDomainOriginKHR = VkTessellationDomainOrigin;

/// `VkTexelBufferDescriptorInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkTexelBufferDescriptorInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub format: VkFormat,
    pub addressRange: VkDeviceAddressRangeEXT,
}
impl_default_zeroed_with_s_type!(VkTexelBufferDescriptorInfoEXT : VK_STRUCTURE_TYPE_TEXEL_BUFFER_DESCRIPTOR_INFO_EXT);

/// `VkTextureLODGatherFormatPropertiesAMD`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkTextureLODGatherFormatPropertiesAMD {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub supportsTextureGatherLODBiasAMD: VkBool32,
}
impl_default_zeroed_with_s_type!(VkTextureLODGatherFormatPropertiesAMD : VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD);
impl_extends!(VkTextureLODGatherFormatPropertiesAMD : VkImageFormatProperties2);

/// `VkTileMemoryBindInfoQCOM`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkTileMemoryBindInfoQCOM {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub memory: VkDeviceMemory,
}
impl_default_zeroed_with_s_type!(VkTileMemoryBindInfoQCOM : VK_STRUCTURE_TYPE_TILE_MEMORY_BIND_INFO_QCOM);
impl_extends!(VkTileMemoryBindInfoQCOM : VkCommandBufferInheritanceInfo);

/// `VkTileMemoryRequirementsQCOM`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkTileMemoryRequirementsQCOM {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub size: VkDeviceSize,
    pub alignment: VkDeviceSize,
}
impl_default_zeroed_with_s_type!(VkTileMemoryRequirementsQCOM : VK_STRUCTURE_TYPE_TILE_MEMORY_REQUIREMENTS_QCOM);
impl_extends!(VkTileMemoryRequirementsQCOM : VkMemoryRequirements2);

/// `VkTileMemorySizeInfoQCOM`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkTileMemorySizeInfoQCOM {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub size: VkDeviceSize,
}
impl_default_zeroed_with_s_type!(VkTileMemorySizeInfoQCOM : VK_STRUCTURE_TYPE_TILE_MEMORY_SIZE_INFO_QCOM);
impl_extends!(VkTileMemorySizeInfoQCOM : VkRenderPassCreateInfo, VkRenderPassCreateInfo2, VkRenderingInfo);

/// `VkTilePropertiesQCOM`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkTilePropertiesQCOM {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub tileSize: VkExtent3D,
    pub apronSize: VkExtent2D,
    pub origin: VkOffset2D,
}
impl_default_zeroed_with_s_type!(VkTilePropertiesQCOM : VK_STRUCTURE_TYPE_TILE_PROPERTIES_QCOM);

flags!(VkTileShadingRenderPassFlagsQCOM);
from_into_transparent!(VkTileShadingRenderPassFlagsQCOM: i32);
/// `VkTileShadingRenderPassFlagsQCOM`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkTileShadingRenderPassFlagsQCOM(pub i32);

/// `1 << 0`  
pub const VK_TILE_SHADING_RENDER_PASS_ENABLE_BIT_QCOM: VkTileShadingRenderPassFlagsQCOM = VkTileShadingRenderPassFlagsQCOM(1 << 0);
/// `1 << 1`  
pub const VK_TILE_SHADING_RENDER_PASS_PER_TILE_EXECUTION_BIT_QCOM: VkTileShadingRenderPassFlagsQCOM = VkTileShadingRenderPassFlagsQCOM(1 << 1);

impl_flags_display!(VkTileShadingRenderPassFlagsQCOM { VK_TILE_SHADING_RENDER_PASS_ENABLE_BIT_QCOM, VK_TILE_SHADING_RENDER_PASS_PER_TILE_EXECUTION_BIT_QCOM });

/// `VkTimeDomainKHR`
pub type VkTimeDomainEXT = VkTimeDomainKHR;

from_into_transparent!(VkTimeDomainKHR: i32);
/// `VkTimeDomainKHR`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkTimeDomainKHR(pub i32);

/// `0`  
pub const VK_TIME_DOMAIN_DEVICE_KHR: VkTimeDomainKHR = VkTimeDomainKHR(0);
/// `1`  
pub const VK_TIME_DOMAIN_CLOCK_MONOTONIC_KHR: VkTimeDomainKHR = VkTimeDomainKHR(1);
/// `2`  
pub const VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_KHR: VkTimeDomainKHR = VkTimeDomainKHR(2);
/// `3`  
pub const VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_KHR: VkTimeDomainKHR = VkTimeDomainKHR(3);
/// `VK_TIME_DOMAIN_DEVICE_KHR`  
pub const VK_TIME_DOMAIN_DEVICE_EXT: VkTimeDomainKHR = VK_TIME_DOMAIN_DEVICE_KHR;
/// `VK_TIME_DOMAIN_CLOCK_MONOTONIC_KHR`  
pub const VK_TIME_DOMAIN_CLOCK_MONOTONIC_EXT: VkTimeDomainKHR = VK_TIME_DOMAIN_CLOCK_MONOTONIC_KHR;
/// `VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_KHR`  
pub const VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_EXT: VkTimeDomainKHR = VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_KHR;
/// `VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_KHR`  
pub const VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_EXT: VkTimeDomainKHR = VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_KHR;
/// `1000208000`  
pub const VK_TIME_DOMAIN_PRESENT_STAGE_LOCAL_EXT: VkTimeDomainKHR = VkTimeDomainKHR(1000208000);
/// `1000208001`  
pub const VK_TIME_DOMAIN_SWAPCHAIN_LOCAL_EXT: VkTimeDomainKHR = VkTimeDomainKHR(1000208001);

impl_enum_display!(VkTimeDomainKHR { VK_TIME_DOMAIN_DEVICE_KHR, VK_TIME_DOMAIN_CLOCK_MONOTONIC_KHR, VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_KHR, VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_KHR, VK_TIME_DOMAIN_DEVICE_EXT, VK_TIME_DOMAIN_CLOCK_MONOTONIC_EXT, VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_EXT, VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_EXT, VK_TIME_DOMAIN_PRESENT_STAGE_LOCAL_EXT, VK_TIME_DOMAIN_SWAPCHAIN_LOCAL_EXT });

/// `VkTimelineSemaphoreSubmitInfo`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkTimelineSemaphoreSubmitInfo {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub waitSemaphoreValueCount: uint32_t,
    pub pWaitSemaphoreValues: *const uint64_t,
    pub signalSemaphoreValueCount: uint32_t,
    pub pSignalSemaphoreValues: *const uint64_t,
}
impl_default_zeroed_with_s_type!(VkTimelineSemaphoreSubmitInfo : VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO);
impl_extends!(VkTimelineSemaphoreSubmitInfo : VkSubmitInfo, VkBindSparseInfo);

/// `VkTimelineSemaphoreSubmitInfo`
pub type VkTimelineSemaphoreSubmitInfoKHR = VkTimelineSemaphoreSubmitInfo;

flags!(VkToolPurposeFlags);
from_into_transparent!(VkToolPurposeFlags: i32);
/// `VkToolPurposeFlags`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkToolPurposeFlags(pub i32);

/// `1 << 0`  
pub const VK_TOOL_PURPOSE_VALIDATION_BIT: VkToolPurposeFlags = VkToolPurposeFlags(1 << 0);
/// `1 << 1`  
pub const VK_TOOL_PURPOSE_PROFILING_BIT: VkToolPurposeFlags = VkToolPurposeFlags(1 << 1);
/// `1 << 2`  
pub const VK_TOOL_PURPOSE_TRACING_BIT: VkToolPurposeFlags = VkToolPurposeFlags(1 << 2);
/// `1 << 3`  
pub const VK_TOOL_PURPOSE_ADDITIONAL_FEATURES_BIT: VkToolPurposeFlags = VkToolPurposeFlags(1 << 3);
/// `1 << 4`  
pub const VK_TOOL_PURPOSE_MODIFYING_FEATURES_BIT: VkToolPurposeFlags = VkToolPurposeFlags(1 << 4);
/// `VK_TOOL_PURPOSE_VALIDATION_BIT`  
pub const VK_TOOL_PURPOSE_VALIDATION_BIT_EXT: VkToolPurposeFlags = VK_TOOL_PURPOSE_VALIDATION_BIT;
/// `VK_TOOL_PURPOSE_PROFILING_BIT`  
pub const VK_TOOL_PURPOSE_PROFILING_BIT_EXT: VkToolPurposeFlags = VK_TOOL_PURPOSE_PROFILING_BIT;
/// `VK_TOOL_PURPOSE_TRACING_BIT`  
pub const VK_TOOL_PURPOSE_TRACING_BIT_EXT: VkToolPurposeFlags = VK_TOOL_PURPOSE_TRACING_BIT;
/// `VK_TOOL_PURPOSE_ADDITIONAL_FEATURES_BIT`  
pub const VK_TOOL_PURPOSE_ADDITIONAL_FEATURES_BIT_EXT: VkToolPurposeFlags = VK_TOOL_PURPOSE_ADDITIONAL_FEATURES_BIT;
/// `VK_TOOL_PURPOSE_MODIFYING_FEATURES_BIT`  
pub const VK_TOOL_PURPOSE_MODIFYING_FEATURES_BIT_EXT: VkToolPurposeFlags = VK_TOOL_PURPOSE_MODIFYING_FEATURES_BIT;
/// `1 << 5`  
pub const VK_TOOL_PURPOSE_DEBUG_REPORTING_BIT_EXT: VkToolPurposeFlags = VkToolPurposeFlags(1 << 5);
/// `1 << 6`  
pub const VK_TOOL_PURPOSE_DEBUG_MARKERS_BIT_EXT: VkToolPurposeFlags = VkToolPurposeFlags(1 << 6);

impl_flags_display!(VkToolPurposeFlags { VK_TOOL_PURPOSE_VALIDATION_BIT, VK_TOOL_PURPOSE_PROFILING_BIT, VK_TOOL_PURPOSE_TRACING_BIT, VK_TOOL_PURPOSE_ADDITIONAL_FEATURES_BIT, VK_TOOL_PURPOSE_MODIFYING_FEATURES_BIT, VK_TOOL_PURPOSE_VALIDATION_BIT_EXT, VK_TOOL_PURPOSE_PROFILING_BIT_EXT, VK_TOOL_PURPOSE_TRACING_BIT_EXT, VK_TOOL_PURPOSE_ADDITIONAL_FEATURES_BIT_EXT, VK_TOOL_PURPOSE_MODIFYING_FEATURES_BIT_EXT, VK_TOOL_PURPOSE_DEBUG_REPORTING_BIT_EXT, VK_TOOL_PURPOSE_DEBUG_MARKERS_BIT_EXT });

/// `VkToolPurposeFlags`
pub type VkToolPurposeFlagsEXT = VkToolPurposeFlags;

/// `VkTraceRaysIndirectCommand2KHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkTraceRaysIndirectCommand2KHR {
    pub raygenShaderRecordAddress: VkDeviceAddress,
    pub raygenShaderRecordSize: VkDeviceSize,
    pub missShaderBindingTableAddress: VkDeviceAddress,
    pub missShaderBindingTableSize: VkDeviceSize,
    pub missShaderBindingTableStride: VkDeviceSize,
    pub hitShaderBindingTableAddress: VkDeviceAddress,
    pub hitShaderBindingTableSize: VkDeviceSize,
    pub hitShaderBindingTableStride: VkDeviceSize,
    pub callableShaderBindingTableAddress: VkDeviceAddress,
    pub callableShaderBindingTableSize: VkDeviceSize,
    pub callableShaderBindingTableStride: VkDeviceSize,
    pub width: uint32_t,
    pub height: uint32_t,
    pub depth: uint32_t,
}
impl_default_zeroed!(VkTraceRaysIndirectCommand2KHR);

/// `VkTraceRaysIndirectCommandKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkTraceRaysIndirectCommandKHR {
    pub width: uint32_t,
    pub height: uint32_t,
    pub depth: uint32_t,
}
impl_default_zeroed!(VkTraceRaysIndirectCommandKHR);

/// `VkTransformMatrixKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkTransformMatrixKHR {
    pub matrix: [float; 3 as usize],
}
impl_default_zeroed!(VkTransformMatrixKHR);

/// `VkTransformMatrixKHR`
pub type VkTransformMatrixNV = VkTransformMatrixKHR;

flags!(VkUbmSurfaceCreateFlagsSEC);
from_into_transparent!(VkUbmSurfaceCreateFlagsSEC: i32);
/// `VkUbmSurfaceCreateFlagsSEC`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkUbmSurfaceCreateFlagsSEC(pub i32);

impl_flags_display!(VkUbmSurfaceCreateFlagsSEC {  });

/// `VkUbmSurfaceCreateInfoSEC`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkUbmSurfaceCreateInfoSEC {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub flags: VkUbmSurfaceCreateFlagsSEC,
    pub device: *mut ubm_device,
    pub surface: *mut ubm_surface,
}
impl_default_zeroed_with_s_type!(VkUbmSurfaceCreateInfoSEC : VK_STRUCTURE_TYPE_UBM_SURFACE_CREATE_INFO_SEC);

flags!(VkValidationCacheCreateFlagsEXT);
from_into_transparent!(VkValidationCacheCreateFlagsEXT: i32);
/// `VkValidationCacheCreateFlagsEXT`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkValidationCacheCreateFlagsEXT(pub i32);

impl_flags_display!(VkValidationCacheCreateFlagsEXT {  });

/// `VkValidationCacheCreateInfoEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkValidationCacheCreateInfoEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub flags: VkValidationCacheCreateFlagsEXT,
    pub initialDataSize: size_t,
    pub pInitialData: *const void,
}
impl_default_zeroed_with_s_type!(VkValidationCacheCreateInfoEXT : VK_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT);

/// `VkValidationCacheEXT` : `VkDevice`
#[repr(transparent)]
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkValidationCacheEXT(pub u64);
from_into_transparent!(VkValidationCacheEXT: u64);
impl_handle!(VkValidationCacheEXT: VK_OBJECT_TYPE_VALIDATION_CACHE_EXT; SubHandle = VkDevice);

from_into_transparent!(VkValidationCacheHeaderVersionEXT: i32);
/// `VkValidationCacheHeaderVersionEXT`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkValidationCacheHeaderVersionEXT(pub i32);

/// `1`  
pub const VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT: VkValidationCacheHeaderVersionEXT = VkValidationCacheHeaderVersionEXT(1);

impl_enum_display!(VkValidationCacheHeaderVersionEXT { VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT });

from_into_transparent!(VkValidationCheckEXT: i32);
/// `VkValidationCheckEXT`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkValidationCheckEXT(pub i32);

/// `0`  
pub const VK_VALIDATION_CHECK_ALL_EXT: VkValidationCheckEXT = VkValidationCheckEXT(0);
/// `1`  
pub const VK_VALIDATION_CHECK_SHADERS_EXT: VkValidationCheckEXT = VkValidationCheckEXT(1);

impl_enum_display!(VkValidationCheckEXT { VK_VALIDATION_CHECK_ALL_EXT, VK_VALIDATION_CHECK_SHADERS_EXT });

from_into_transparent!(VkValidationFeatureDisableEXT: i32);
/// `VkValidationFeatureDisableEXT`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkValidationFeatureDisableEXT(pub i32);

/// `0`  
pub const VK_VALIDATION_FEATURE_DISABLE_ALL_EXT: VkValidationFeatureDisableEXT = VkValidationFeatureDisableEXT(0);
/// `1`  
pub const VK_VALIDATION_FEATURE_DISABLE_SHADERS_EXT: VkValidationFeatureDisableEXT = VkValidationFeatureDisableEXT(1);
/// `2`  
pub const VK_VALIDATION_FEATURE_DISABLE_THREAD_SAFETY_EXT: VkValidationFeatureDisableEXT = VkValidationFeatureDisableEXT(2);
/// `3`  
pub const VK_VALIDATION_FEATURE_DISABLE_API_PARAMETERS_EXT: VkValidationFeatureDisableEXT = VkValidationFeatureDisableEXT(3);
/// `4`  
pub const VK_VALIDATION_FEATURE_DISABLE_OBJECT_LIFETIMES_EXT: VkValidationFeatureDisableEXT = VkValidationFeatureDisableEXT(4);
/// `5`  
pub const VK_VALIDATION_FEATURE_DISABLE_CORE_CHECKS_EXT: VkValidationFeatureDisableEXT = VkValidationFeatureDisableEXT(5);
/// `6`  
pub const VK_VALIDATION_FEATURE_DISABLE_UNIQUE_HANDLES_EXT: VkValidationFeatureDisableEXT = VkValidationFeatureDisableEXT(6);
/// `7`  
pub const VK_VALIDATION_FEATURE_DISABLE_SHADER_VALIDATION_CACHE_EXT: VkValidationFeatureDisableEXT = VkValidationFeatureDisableEXT(7);

impl_enum_display!(VkValidationFeatureDisableEXT { VK_VALIDATION_FEATURE_DISABLE_ALL_EXT, VK_VALIDATION_FEATURE_DISABLE_SHADERS_EXT, VK_VALIDATION_FEATURE_DISABLE_THREAD_SAFETY_EXT, VK_VALIDATION_FEATURE_DISABLE_API_PARAMETERS_EXT, VK_VALIDATION_FEATURE_DISABLE_OBJECT_LIFETIMES_EXT, VK_VALIDATION_FEATURE_DISABLE_CORE_CHECKS_EXT, VK_VALIDATION_FEATURE_DISABLE_UNIQUE_HANDLES_EXT, VK_VALIDATION_FEATURE_DISABLE_SHADER_VALIDATION_CACHE_EXT });

from_into_transparent!(VkValidationFeatureEnableEXT: i32);
/// `VkValidationFeatureEnableEXT`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkValidationFeatureEnableEXT(pub i32);

/// `0`  
pub const VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_EXT: VkValidationFeatureEnableEXT = VkValidationFeatureEnableEXT(0);
/// `1`  
pub const VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_RESERVE_BINDING_SLOT_EXT: VkValidationFeatureEnableEXT = VkValidationFeatureEnableEXT(1);
/// `2`  
pub const VK_VALIDATION_FEATURE_ENABLE_BEST_PRACTICES_EXT: VkValidationFeatureEnableEXT = VkValidationFeatureEnableEXT(2);
/// `3`  
pub const VK_VALIDATION_FEATURE_ENABLE_DEBUG_PRINTF_EXT: VkValidationFeatureEnableEXT = VkValidationFeatureEnableEXT(3);
/// `4`  
pub const VK_VALIDATION_FEATURE_ENABLE_SYNCHRONIZATION_VALIDATION_EXT: VkValidationFeatureEnableEXT = VkValidationFeatureEnableEXT(4);

impl_enum_display!(VkValidationFeatureEnableEXT { VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_EXT, VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_RESERVE_BINDING_SLOT_EXT, VK_VALIDATION_FEATURE_ENABLE_BEST_PRACTICES_EXT, VK_VALIDATION_FEATURE_ENABLE_DEBUG_PRINTF_EXT, VK_VALIDATION_FEATURE_ENABLE_SYNCHRONIZATION_VALIDATION_EXT });

/// `VkValidationFeaturesEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkValidationFeaturesEXT {
    /// Must be VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT
    pub sType: VkStructureType,
    pub pNext: *const void,
    /// Number of validation features to enable
    pub enabledValidationFeatureCount: uint32_t,
    /// Validation features to enable
    pub pEnabledValidationFeatures: *const VkValidationFeatureEnableEXT,
    /// Number of validation features to disable
    pub disabledValidationFeatureCount: uint32_t,
    /// Validation features to disable
    pub pDisabledValidationFeatures: *const VkValidationFeatureDisableEXT,
}
impl_default_zeroed_with_s_type!(VkValidationFeaturesEXT : VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT);
impl_extends!(VkValidationFeaturesEXT : VkInstanceCreateInfo, VkShaderModuleCreateInfo, VkShaderCreateInfoEXT);

/// `VkValidationFlagsEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkValidationFlagsEXT {
    /// Must be VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT
    pub sType: VkStructureType,
    pub pNext: *const void,
    /// Number of validation checks to disable
    pub disabledValidationCheckCount: uint32_t,
    /// Validation checks to disable
    pub pDisabledValidationChecks: *const VkValidationCheckEXT,
}
impl_default_zeroed_with_s_type!(VkValidationFlagsEXT : VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT);
impl_extends!(VkValidationFlagsEXT : VkInstanceCreateInfo);

from_into_transparent!(VkVendorId: i32);
/// `VkVendorId`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkVendorId(pub i32);

/// `0x10000`  
/// 
/// Khronos vendor ID
pub const VK_VENDOR_ID_KHRONOS: VkVendorId = VkVendorId(0x10000);
/// `0x10001`  
/// 
/// Vivante vendor ID
pub const VK_VENDOR_ID_VIV: VkVendorId = VkVendorId(0x10001);
/// `0x10002`  
/// 
/// VeriSilicon vendor ID
pub const VK_VENDOR_ID_VSI: VkVendorId = VkVendorId(0x10002);
/// `0x10003`  
/// 
/// Kazan Software Renderer
pub const VK_VENDOR_ID_KAZAN: VkVendorId = VkVendorId(0x10003);
/// `0x10004`  
/// 
/// Codeplay Software Ltd. vendor ID
pub const VK_VENDOR_ID_CODEPLAY: VkVendorId = VkVendorId(0x10004);
/// `0x10005`  
/// 
/// Mesa vendor ID
pub const VK_VENDOR_ID_MESA: VkVendorId = VkVendorId(0x10005);
/// `0x10006`  
/// 
/// PoCL vendor ID
pub const VK_VENDOR_ID_POCL: VkVendorId = VkVendorId(0x10006);
/// `0x10007`  
/// 
/// Mobileye vendor ID
pub const VK_VENDOR_ID_MOBILEYE: VkVendorId = VkVendorId(0x10007);

impl_enum_display!(VkVendorId { VK_VENDOR_ID_KHRONOS, VK_VENDOR_ID_VIV, VK_VENDOR_ID_VSI, VK_VENDOR_ID_KAZAN, VK_VENDOR_ID_CODEPLAY, VK_VENDOR_ID_MESA, VK_VENDOR_ID_POCL, VK_VENDOR_ID_MOBILEYE });

/// `VkVertexInputAttributeDescription`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVertexInputAttributeDescription {
    /// location of the shader vertex attrib
    pub location: uint32_t,
    /// Vertex buffer binding id
    pub binding: uint32_t,
    /// format of source data
    pub format: VkFormat,
    /// Offset of first element in bytes from base of vertex
    pub offset: uint32_t,
}
impl_default_zeroed!(VkVertexInputAttributeDescription);

/// `VkVertexInputAttributeDescription2EXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVertexInputAttributeDescription2EXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    /// location of the shader vertex attrib
    pub location: uint32_t,
    /// Vertex buffer binding id
    pub binding: uint32_t,
    /// format of source data
    pub format: VkFormat,
    /// Offset of first element in bytes from base of vertex
    pub offset: uint32_t,
}
impl_default_zeroed_with_s_type!(VkVertexInputAttributeDescription2EXT : VK_STRUCTURE_TYPE_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT);

/// `VkVertexInputBindingDescription`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVertexInputBindingDescription {
    /// Vertex buffer binding id
    pub binding: uint32_t,
    /// Distance between vertices in bytes (0 = no advancement)
    pub stride: uint32_t,
    /// The rate at which the vertex data is consumed
    pub inputRate: VkVertexInputRate,
}
impl_default_zeroed!(VkVertexInputBindingDescription);

/// `VkVertexInputBindingDescription2EXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVertexInputBindingDescription2EXT {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub binding: uint32_t,
    pub stride: uint32_t,
    pub inputRate: VkVertexInputRate,
    pub divisor: uint32_t,
}
impl_default_zeroed_with_s_type!(VkVertexInputBindingDescription2EXT : VK_STRUCTURE_TYPE_VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT);

/// `VkVertexInputBindingDivisorDescription`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVertexInputBindingDivisorDescription {
    pub binding: uint32_t,
    pub divisor: uint32_t,
}
impl_default_zeroed!(VkVertexInputBindingDivisorDescription);

/// `VkVertexInputBindingDivisorDescription`
pub type VkVertexInputBindingDivisorDescriptionEXT = VkVertexInputBindingDivisorDescription;

/// `VkVertexInputBindingDivisorDescription`
pub type VkVertexInputBindingDivisorDescriptionKHR = VkVertexInputBindingDivisorDescription;

from_into_transparent!(VkVertexInputRate: i32);
/// `VkVertexInputRate`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkVertexInputRate(pub i32);

/// `0`  
pub const VK_VERTEX_INPUT_RATE_VERTEX: VkVertexInputRate = VkVertexInputRate(0);
/// `1`  
pub const VK_VERTEX_INPUT_RATE_INSTANCE: VkVertexInputRate = VkVertexInputRate(1);

impl_enum_display!(VkVertexInputRate { VK_VERTEX_INPUT_RATE_VERTEX, VK_VERTEX_INPUT_RATE_INSTANCE });

flags!(VkViSurfaceCreateFlagsNN);
from_into_transparent!(VkViSurfaceCreateFlagsNN: i32);
/// `VkViSurfaceCreateFlagsNN`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkViSurfaceCreateFlagsNN(pub i32);

impl_flags_display!(VkViSurfaceCreateFlagsNN {  });

/// `VkViSurfaceCreateInfoNN`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkViSurfaceCreateInfoNN {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub flags: VkViSurfaceCreateFlagsNN,
    pub window: *mut void,
}
impl_default_zeroed_with_s_type!(VkViSurfaceCreateInfoNN : VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN);

flags!(VkVideoBeginCodingFlagsKHR);
from_into_transparent!(VkVideoBeginCodingFlagsKHR: i32);
/// `VkVideoBeginCodingFlagsKHR`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkVideoBeginCodingFlagsKHR(pub i32);

impl_flags_display!(VkVideoBeginCodingFlagsKHR {  });

/// `VkVideoBeginCodingInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVideoBeginCodingInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub flags: VkVideoBeginCodingFlagsKHR,
    pub videoSession: VkVideoSessionKHR,
    pub videoSessionParameters: VkVideoSessionParametersKHR,
    pub referenceSlotCount: uint32_t,
    pub pReferenceSlots: *const VkVideoReferenceSlotInfoKHR,
}
impl_default_zeroed_with_s_type!(VkVideoBeginCodingInfoKHR : VK_STRUCTURE_TYPE_VIDEO_BEGIN_CODING_INFO_KHR);

/// `VkVideoCapabilitiesKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVideoCapabilitiesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub flags: VkVideoCapabilityFlagsKHR,
    pub minBitstreamBufferOffsetAlignment: VkDeviceSize,
    pub minBitstreamBufferSizeAlignment: VkDeviceSize,
    pub pictureAccessGranularity: VkExtent2D,
    pub minCodedExtent: VkExtent2D,
    pub maxCodedExtent: VkExtent2D,
    pub maxDpbSlots: uint32_t,
    pub maxActiveReferencePictures: uint32_t,
    pub stdHeaderVersion: VkExtensionProperties,
}
impl_default_zeroed_with_s_type!(VkVideoCapabilitiesKHR : VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR);

flags!(VkVideoCapabilityFlagsKHR);
from_into_transparent!(VkVideoCapabilityFlagsKHR: i32);
/// `VkVideoCapabilityFlagsKHR`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkVideoCapabilityFlagsKHR(pub i32);

/// `1 << 0`  
pub const VK_VIDEO_CAPABILITY_PROTECTED_CONTENT_BIT_KHR: VkVideoCapabilityFlagsKHR = VkVideoCapabilityFlagsKHR(1 << 0);
/// `1 << 1`  
pub const VK_VIDEO_CAPABILITY_SEPARATE_REFERENCE_IMAGES_BIT_KHR: VkVideoCapabilityFlagsKHR = VkVideoCapabilityFlagsKHR(1 << 1);

impl_flags_display!(VkVideoCapabilityFlagsKHR { VK_VIDEO_CAPABILITY_PROTECTED_CONTENT_BIT_KHR, VK_VIDEO_CAPABILITY_SEPARATE_REFERENCE_IMAGES_BIT_KHR });

flags!(VkVideoChromaSubsamplingFlagsKHR);
from_into_transparent!(VkVideoChromaSubsamplingFlagsKHR: i32);
/// `VkVideoChromaSubsamplingFlagsKHR`
/// 
/// Vulkan video chroma subsampling definitions
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkVideoChromaSubsamplingFlagsKHR(pub i32);

/// `0`  
pub const VK_VIDEO_CHROMA_SUBSAMPLING_INVALID_KHR: VkVideoChromaSubsamplingFlagsKHR = VkVideoChromaSubsamplingFlagsKHR(0);
/// `1 << 0`  
pub const VK_VIDEO_CHROMA_SUBSAMPLING_MONOCHROME_BIT_KHR: VkVideoChromaSubsamplingFlagsKHR = VkVideoChromaSubsamplingFlagsKHR(1 << 0);
/// `1 << 1`  
pub const VK_VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR: VkVideoChromaSubsamplingFlagsKHR = VkVideoChromaSubsamplingFlagsKHR(1 << 1);
/// `1 << 2`  
pub const VK_VIDEO_CHROMA_SUBSAMPLING_422_BIT_KHR: VkVideoChromaSubsamplingFlagsKHR = VkVideoChromaSubsamplingFlagsKHR(1 << 2);
/// `1 << 3`  
pub const VK_VIDEO_CHROMA_SUBSAMPLING_444_BIT_KHR: VkVideoChromaSubsamplingFlagsKHR = VkVideoChromaSubsamplingFlagsKHR(1 << 3);

impl_flags_display!(VkVideoChromaSubsamplingFlagsKHR { VK_VIDEO_CHROMA_SUBSAMPLING_INVALID_KHR, VK_VIDEO_CHROMA_SUBSAMPLING_MONOCHROME_BIT_KHR, VK_VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR, VK_VIDEO_CHROMA_SUBSAMPLING_422_BIT_KHR, VK_VIDEO_CHROMA_SUBSAMPLING_444_BIT_KHR });

flags!(VkVideoCodecOperationFlagsKHR);
from_into_transparent!(VkVideoCodecOperationFlagsKHR: i32);
/// `VkVideoCodecOperationFlagsKHR`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkVideoCodecOperationFlagsKHR(pub i32);

/// `0`  
pub const VK_VIDEO_CODEC_OPERATION_NONE_KHR: VkVideoCodecOperationFlagsKHR = VkVideoCodecOperationFlagsKHR(0);
/// `1 << 16`  
pub const VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR: VkVideoCodecOperationFlagsKHR = VkVideoCodecOperationFlagsKHR(1 << 16);
/// `1 << 17`  
pub const VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR: VkVideoCodecOperationFlagsKHR = VkVideoCodecOperationFlagsKHR(1 << 17);
/// `1 << 0`  
pub const VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR: VkVideoCodecOperationFlagsKHR = VkVideoCodecOperationFlagsKHR(1 << 0);
/// `1 << 1`  
pub const VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR: VkVideoCodecOperationFlagsKHR = VkVideoCodecOperationFlagsKHR(1 << 1);
/// `1 << 2`  
pub const VK_VIDEO_CODEC_OPERATION_DECODE_AV1_BIT_KHR: VkVideoCodecOperationFlagsKHR = VkVideoCodecOperationFlagsKHR(1 << 2);
/// `1 << 18`  
pub const VK_VIDEO_CODEC_OPERATION_ENCODE_AV1_BIT_KHR: VkVideoCodecOperationFlagsKHR = VkVideoCodecOperationFlagsKHR(1 << 18);
/// `1 << 3`  
pub const VK_VIDEO_CODEC_OPERATION_DECODE_VP9_BIT_KHR: VkVideoCodecOperationFlagsKHR = VkVideoCodecOperationFlagsKHR(1 << 3);

impl_flags_display!(VkVideoCodecOperationFlagsKHR { VK_VIDEO_CODEC_OPERATION_NONE_KHR, VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR, VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR, VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR, VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR, VK_VIDEO_CODEC_OPERATION_DECODE_AV1_BIT_KHR, VK_VIDEO_CODEC_OPERATION_ENCODE_AV1_BIT_KHR, VK_VIDEO_CODEC_OPERATION_DECODE_VP9_BIT_KHR });

flags!(VkVideoCodingControlFlagsKHR);
from_into_transparent!(VkVideoCodingControlFlagsKHR: i32);
/// `VkVideoCodingControlFlagsKHR`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkVideoCodingControlFlagsKHR(pub i32);

/// `1 << 0`  
pub const VK_VIDEO_CODING_CONTROL_RESET_BIT_KHR: VkVideoCodingControlFlagsKHR = VkVideoCodingControlFlagsKHR(1 << 0);
/// `1 << 1`  
pub const VK_VIDEO_CODING_CONTROL_ENCODE_RATE_CONTROL_BIT_KHR: VkVideoCodingControlFlagsKHR = VkVideoCodingControlFlagsKHR(1 << 1);
/// `1 << 2`  
pub const VK_VIDEO_CODING_CONTROL_ENCODE_QUALITY_LEVEL_BIT_KHR: VkVideoCodingControlFlagsKHR = VkVideoCodingControlFlagsKHR(1 << 2);

impl_flags_display!(VkVideoCodingControlFlagsKHR { VK_VIDEO_CODING_CONTROL_RESET_BIT_KHR, VK_VIDEO_CODING_CONTROL_ENCODE_RATE_CONTROL_BIT_KHR, VK_VIDEO_CODING_CONTROL_ENCODE_QUALITY_LEVEL_BIT_KHR });

/// `VkVideoCodingControlInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVideoCodingControlInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub flags: VkVideoCodingControlFlagsKHR,
}
impl_default_zeroed_with_s_type!(VkVideoCodingControlInfoKHR : VK_STRUCTURE_TYPE_VIDEO_CODING_CONTROL_INFO_KHR);

flags!(VkVideoComponentBitDepthFlagsKHR);
from_into_transparent!(VkVideoComponentBitDepthFlagsKHR: i32);
/// `VkVideoComponentBitDepthFlagsKHR`
/// 
/// Vulkan video component bit depth definitions
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkVideoComponentBitDepthFlagsKHR(pub i32);

/// `0`  
pub const VK_VIDEO_COMPONENT_BIT_DEPTH_INVALID_KHR: VkVideoComponentBitDepthFlagsKHR = VkVideoComponentBitDepthFlagsKHR(0);
/// `1 << 0`  
pub const VK_VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR: VkVideoComponentBitDepthFlagsKHR = VkVideoComponentBitDepthFlagsKHR(1 << 0);
/// `1 << 2`  
pub const VK_VIDEO_COMPONENT_BIT_DEPTH_10_BIT_KHR: VkVideoComponentBitDepthFlagsKHR = VkVideoComponentBitDepthFlagsKHR(1 << 2);
/// `1 << 4`  
pub const VK_VIDEO_COMPONENT_BIT_DEPTH_12_BIT_KHR: VkVideoComponentBitDepthFlagsKHR = VkVideoComponentBitDepthFlagsKHR(1 << 4);

impl_flags_display!(VkVideoComponentBitDepthFlagsKHR { VK_VIDEO_COMPONENT_BIT_DEPTH_INVALID_KHR, VK_VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR, VK_VIDEO_COMPONENT_BIT_DEPTH_10_BIT_KHR, VK_VIDEO_COMPONENT_BIT_DEPTH_12_BIT_KHR });

/// `VkVideoDecodeAV1CapabilitiesKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVideoDecodeAV1CapabilitiesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub maxLevel: StdVideoAV1Level,
}
impl_default_zeroed_with_s_type!(VkVideoDecodeAV1CapabilitiesKHR : VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_CAPABILITIES_KHR);
impl_extends!(VkVideoDecodeAV1CapabilitiesKHR : VkVideoCapabilitiesKHR);

/// `VkVideoDecodeAV1DpbSlotInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVideoDecodeAV1DpbSlotInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub pStdReferenceInfo: *const StdVideoDecodeAV1ReferenceInfo,
}
impl_default_zeroed_with_s_type!(VkVideoDecodeAV1DpbSlotInfoKHR : VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_DPB_SLOT_INFO_KHR);
impl_extends!(VkVideoDecodeAV1DpbSlotInfoKHR : VkVideoReferenceSlotInfoKHR);

/// `VkVideoDecodeAV1InlineSessionParametersInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVideoDecodeAV1InlineSessionParametersInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub pStdSequenceHeader: *const StdVideoAV1SequenceHeader,
}
impl_default_zeroed_with_s_type!(VkVideoDecodeAV1InlineSessionParametersInfoKHR : VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_INLINE_SESSION_PARAMETERS_INFO_KHR);
impl_extends!(VkVideoDecodeAV1InlineSessionParametersInfoKHR : VkVideoDecodeInfoKHR);

/// `VkVideoDecodeAV1PictureInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVideoDecodeAV1PictureInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub pStdPictureInfo: *const StdVideoDecodeAV1PictureInfo,
    pub referenceNameSlotIndices: [int32_t; VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR as usize],
    pub frameHeaderOffset: uint32_t,
    pub tileCount: uint32_t,
    pub pTileOffsets: *const uint32_t,
    pub pTileSizes: *const uint32_t,
}
impl_default_zeroed_with_s_type!(VkVideoDecodeAV1PictureInfoKHR : VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PICTURE_INFO_KHR);
impl_extends!(VkVideoDecodeAV1PictureInfoKHR : VkVideoDecodeInfoKHR);

/// `VkVideoDecodeAV1ProfileInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVideoDecodeAV1ProfileInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub stdProfile: StdVideoAV1Profile,
    pub filmGrainSupport: VkBool32,
}
impl_default_zeroed_with_s_type!(VkVideoDecodeAV1ProfileInfoKHR : VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PROFILE_INFO_KHR);
impl_extends!(VkVideoDecodeAV1ProfileInfoKHR : VkVideoProfileInfoKHR, VkQueryPoolCreateInfo);

/// `VkVideoDecodeAV1SessionParametersCreateInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVideoDecodeAV1SessionParametersCreateInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub pStdSequenceHeader: *const StdVideoAV1SequenceHeader,
}
impl_default_zeroed_with_s_type!(VkVideoDecodeAV1SessionParametersCreateInfoKHR : VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR);
impl_extends!(VkVideoDecodeAV1SessionParametersCreateInfoKHR : VkVideoSessionParametersCreateInfoKHR);

/// `VkVideoDecodeCapabilitiesKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVideoDecodeCapabilitiesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub flags: VkVideoDecodeCapabilityFlagsKHR,
}
impl_default_zeroed_with_s_type!(VkVideoDecodeCapabilitiesKHR : VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR);
impl_extends!(VkVideoDecodeCapabilitiesKHR : VkVideoCapabilitiesKHR);

flags!(VkVideoDecodeCapabilityFlagsKHR);
from_into_transparent!(VkVideoDecodeCapabilityFlagsKHR: i32);
/// `VkVideoDecodeCapabilityFlagsKHR`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkVideoDecodeCapabilityFlagsKHR(pub i32);

/// `1 << 0`  
pub const VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_COINCIDE_BIT_KHR: VkVideoDecodeCapabilityFlagsKHR = VkVideoDecodeCapabilityFlagsKHR(1 << 0);
/// `1 << 1`  
pub const VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_DISTINCT_BIT_KHR: VkVideoDecodeCapabilityFlagsKHR = VkVideoDecodeCapabilityFlagsKHR(1 << 1);

impl_flags_display!(VkVideoDecodeCapabilityFlagsKHR { VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_COINCIDE_BIT_KHR, VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_DISTINCT_BIT_KHR });

flags!(VkVideoDecodeFlagsKHR);
from_into_transparent!(VkVideoDecodeFlagsKHR: i32);
/// `VkVideoDecodeFlagsKHR`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkVideoDecodeFlagsKHR(pub i32);

impl_flags_display!(VkVideoDecodeFlagsKHR {  });

/// `VkVideoDecodeH264CapabilitiesKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVideoDecodeH264CapabilitiesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub maxLevelIdc: StdVideoH264LevelIdc,
    pub fieldOffsetGranularity: VkOffset2D,
}
impl_default_zeroed_with_s_type!(VkVideoDecodeH264CapabilitiesKHR : VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_KHR);
impl_extends!(VkVideoDecodeH264CapabilitiesKHR : VkVideoCapabilitiesKHR);

/// `VkVideoDecodeH264DpbSlotInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVideoDecodeH264DpbSlotInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub pStdReferenceInfo: *const StdVideoDecodeH264ReferenceInfo,
}
impl_default_zeroed_with_s_type!(VkVideoDecodeH264DpbSlotInfoKHR : VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR);
impl_extends!(VkVideoDecodeH264DpbSlotInfoKHR : VkVideoReferenceSlotInfoKHR);

/// `VkVideoDecodeH264InlineSessionParametersInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVideoDecodeH264InlineSessionParametersInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub pStdSPS: *const StdVideoH264SequenceParameterSet,
    pub pStdPPS: *const StdVideoH264PictureParameterSet,
}
impl_default_zeroed_with_s_type!(VkVideoDecodeH264InlineSessionParametersInfoKHR : VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_INLINE_SESSION_PARAMETERS_INFO_KHR);
impl_extends!(VkVideoDecodeH264InlineSessionParametersInfoKHR : VkVideoDecodeInfoKHR);

/// `VkVideoDecodeH264PictureInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVideoDecodeH264PictureInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub pStdPictureInfo: *const StdVideoDecodeH264PictureInfo,
    pub sliceCount: uint32_t,
    pub pSliceOffsets: *const uint32_t,
}
impl_default_zeroed_with_s_type!(VkVideoDecodeH264PictureInfoKHR : VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_KHR);
impl_extends!(VkVideoDecodeH264PictureInfoKHR : VkVideoDecodeInfoKHR);

flags!(VkVideoDecodeH264PictureLayoutFlagsKHR);
from_into_transparent!(VkVideoDecodeH264PictureLayoutFlagsKHR: i32);
/// `VkVideoDecodeH264PictureLayoutFlagsKHR`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkVideoDecodeH264PictureLayoutFlagsKHR(pub i32);

/// `0`  
pub const VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_PROGRESSIVE_KHR: VkVideoDecodeH264PictureLayoutFlagsKHR = VkVideoDecodeH264PictureLayoutFlagsKHR(0);
/// `1 << 0`  
pub const VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_INTERLEAVED_LINES_BIT_KHR: VkVideoDecodeH264PictureLayoutFlagsKHR = VkVideoDecodeH264PictureLayoutFlagsKHR(1 << 0);
/// `1 << 1`  
pub const VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_SEPARATE_PLANES_BIT_KHR: VkVideoDecodeH264PictureLayoutFlagsKHR = VkVideoDecodeH264PictureLayoutFlagsKHR(1 << 1);

impl_flags_display!(VkVideoDecodeH264PictureLayoutFlagsKHR { VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_PROGRESSIVE_KHR, VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_INTERLEAVED_LINES_BIT_KHR, VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_SEPARATE_PLANES_BIT_KHR });

/// `VkVideoDecodeH264ProfileInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVideoDecodeH264ProfileInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub stdProfileIdc: StdVideoH264ProfileIdc,
    pub pictureLayout: VkVideoDecodeH264PictureLayoutFlagsKHR,
}
impl_default_zeroed_with_s_type!(VkVideoDecodeH264ProfileInfoKHR : VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_KHR);
impl_extends!(VkVideoDecodeH264ProfileInfoKHR : VkVideoProfileInfoKHR, VkQueryPoolCreateInfo);

/// `VkVideoDecodeH264SessionParametersAddInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVideoDecodeH264SessionParametersAddInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub stdSPSCount: uint32_t,
    pub pStdSPSs: *const StdVideoH264SequenceParameterSet,
    pub stdPPSCount: uint32_t,
    /// List of Picture Parameters associated with the spsStd, above
    pub pStdPPSs: *const StdVideoH264PictureParameterSet,
}
impl_default_zeroed_with_s_type!(VkVideoDecodeH264SessionParametersAddInfoKHR : VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR);
impl_extends!(VkVideoDecodeH264SessionParametersAddInfoKHR : VkVideoSessionParametersUpdateInfoKHR);

/// `VkVideoDecodeH264SessionParametersCreateInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVideoDecodeH264SessionParametersCreateInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub maxStdSPSCount: uint32_t,
    pub maxStdPPSCount: uint32_t,
    pub pParametersAddInfo: *const VkVideoDecodeH264SessionParametersAddInfoKHR,
}
impl_default_zeroed_with_s_type!(VkVideoDecodeH264SessionParametersCreateInfoKHR : VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR);
impl_extends!(VkVideoDecodeH264SessionParametersCreateInfoKHR : VkVideoSessionParametersCreateInfoKHR);

/// `VkVideoDecodeH265CapabilitiesKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVideoDecodeH265CapabilitiesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub maxLevelIdc: StdVideoH265LevelIdc,
}
impl_default_zeroed_with_s_type!(VkVideoDecodeH265CapabilitiesKHR : VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_KHR);
impl_extends!(VkVideoDecodeH265CapabilitiesKHR : VkVideoCapabilitiesKHR);

/// `VkVideoDecodeH265DpbSlotInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVideoDecodeH265DpbSlotInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub pStdReferenceInfo: *const StdVideoDecodeH265ReferenceInfo,
}
impl_default_zeroed_with_s_type!(VkVideoDecodeH265DpbSlotInfoKHR : VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR);
impl_extends!(VkVideoDecodeH265DpbSlotInfoKHR : VkVideoReferenceSlotInfoKHR);

/// `VkVideoDecodeH265InlineSessionParametersInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVideoDecodeH265InlineSessionParametersInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub pStdVPS: *const StdVideoH265VideoParameterSet,
    pub pStdSPS: *const StdVideoH265SequenceParameterSet,
    pub pStdPPS: *const StdVideoH265PictureParameterSet,
}
impl_default_zeroed_with_s_type!(VkVideoDecodeH265InlineSessionParametersInfoKHR : VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_INLINE_SESSION_PARAMETERS_INFO_KHR);
impl_extends!(VkVideoDecodeH265InlineSessionParametersInfoKHR : VkVideoDecodeInfoKHR);

/// `VkVideoDecodeH265PictureInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVideoDecodeH265PictureInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub pStdPictureInfo: *const StdVideoDecodeH265PictureInfo,
    pub sliceSegmentCount: uint32_t,
    pub pSliceSegmentOffsets: *const uint32_t,
}
impl_default_zeroed_with_s_type!(VkVideoDecodeH265PictureInfoKHR : VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_KHR);
impl_extends!(VkVideoDecodeH265PictureInfoKHR : VkVideoDecodeInfoKHR);

/// `VkVideoDecodeH265ProfileInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVideoDecodeH265ProfileInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub stdProfileIdc: StdVideoH265ProfileIdc,
}
impl_default_zeroed_with_s_type!(VkVideoDecodeH265ProfileInfoKHR : VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_INFO_KHR);
impl_extends!(VkVideoDecodeH265ProfileInfoKHR : VkVideoProfileInfoKHR, VkQueryPoolCreateInfo);

/// `VkVideoDecodeH265SessionParametersAddInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVideoDecodeH265SessionParametersAddInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub stdVPSCount: uint32_t,
    pub pStdVPSs: *const StdVideoH265VideoParameterSet,
    pub stdSPSCount: uint32_t,
    pub pStdSPSs: *const StdVideoH265SequenceParameterSet,
    pub stdPPSCount: uint32_t,
    /// List of Picture Parameters associated with the spsStd, above
    pub pStdPPSs: *const StdVideoH265PictureParameterSet,
}
impl_default_zeroed_with_s_type!(VkVideoDecodeH265SessionParametersAddInfoKHR : VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR);
impl_extends!(VkVideoDecodeH265SessionParametersAddInfoKHR : VkVideoSessionParametersUpdateInfoKHR);

/// `VkVideoDecodeH265SessionParametersCreateInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVideoDecodeH265SessionParametersCreateInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub maxStdVPSCount: uint32_t,
    pub maxStdSPSCount: uint32_t,
    pub maxStdPPSCount: uint32_t,
    pub pParametersAddInfo: *const VkVideoDecodeH265SessionParametersAddInfoKHR,
}
impl_default_zeroed_with_s_type!(VkVideoDecodeH265SessionParametersCreateInfoKHR : VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR);
impl_extends!(VkVideoDecodeH265SessionParametersCreateInfoKHR : VkVideoSessionParametersCreateInfoKHR);

/// `VkVideoDecodeInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVideoDecodeInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub flags: VkVideoDecodeFlagsKHR,
    pub srcBuffer: VkBuffer,
    pub srcBufferOffset: VkDeviceSize,
    pub srcBufferRange: VkDeviceSize,
    pub dstPictureResource: VkVideoPictureResourceInfoKHR,
    pub pSetupReferenceSlot: *const VkVideoReferenceSlotInfoKHR,
    pub referenceSlotCount: uint32_t,
    pub pReferenceSlots: *const VkVideoReferenceSlotInfoKHR,
}
impl_default_zeroed_with_s_type!(VkVideoDecodeInfoKHR : VK_STRUCTURE_TYPE_VIDEO_DECODE_INFO_KHR);

flags!(VkVideoDecodeUsageFlagsKHR);
from_into_transparent!(VkVideoDecodeUsageFlagsKHR: i32);
/// `VkVideoDecodeUsageFlagsKHR`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkVideoDecodeUsageFlagsKHR(pub i32);

/// `0`  
pub const VK_VIDEO_DECODE_USAGE_DEFAULT_KHR: VkVideoDecodeUsageFlagsKHR = VkVideoDecodeUsageFlagsKHR(0);
/// `1 << 0`  
pub const VK_VIDEO_DECODE_USAGE_TRANSCODING_BIT_KHR: VkVideoDecodeUsageFlagsKHR = VkVideoDecodeUsageFlagsKHR(1 << 0);
/// `1 << 1`  
pub const VK_VIDEO_DECODE_USAGE_OFFLINE_BIT_KHR: VkVideoDecodeUsageFlagsKHR = VkVideoDecodeUsageFlagsKHR(1 << 1);
/// `1 << 2`  
pub const VK_VIDEO_DECODE_USAGE_STREAMING_BIT_KHR: VkVideoDecodeUsageFlagsKHR = VkVideoDecodeUsageFlagsKHR(1 << 2);

impl_flags_display!(VkVideoDecodeUsageFlagsKHR { VK_VIDEO_DECODE_USAGE_DEFAULT_KHR, VK_VIDEO_DECODE_USAGE_TRANSCODING_BIT_KHR, VK_VIDEO_DECODE_USAGE_OFFLINE_BIT_KHR, VK_VIDEO_DECODE_USAGE_STREAMING_BIT_KHR });

/// `VkVideoDecodeUsageInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVideoDecodeUsageInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub videoUsageHints: VkVideoDecodeUsageFlagsKHR,
}
impl_default_zeroed_with_s_type!(VkVideoDecodeUsageInfoKHR : VK_STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR);
impl_extends!(VkVideoDecodeUsageInfoKHR : VkVideoProfileInfoKHR, VkQueryPoolCreateInfo);

/// `VkVideoDecodeVP9CapabilitiesKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVideoDecodeVP9CapabilitiesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub maxLevel: StdVideoVP9Level,
}
impl_default_zeroed_with_s_type!(VkVideoDecodeVP9CapabilitiesKHR : VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_CAPABILITIES_KHR);
impl_extends!(VkVideoDecodeVP9CapabilitiesKHR : VkVideoCapabilitiesKHR);

/// `VkVideoDecodeVP9PictureInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVideoDecodeVP9PictureInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub pStdPictureInfo: *const StdVideoDecodeVP9PictureInfo,
    pub referenceNameSlotIndices: [int32_t; VK_MAX_VIDEO_VP9_REFERENCES_PER_FRAME_KHR as usize],
    pub uncompressedHeaderOffset: uint32_t,
    pub compressedHeaderOffset: uint32_t,
    pub tilesOffset: uint32_t,
}
impl_default_zeroed_with_s_type!(VkVideoDecodeVP9PictureInfoKHR : VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PICTURE_INFO_KHR);
impl_extends!(VkVideoDecodeVP9PictureInfoKHR : VkVideoDecodeInfoKHR);

/// `VkVideoDecodeVP9ProfileInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVideoDecodeVP9ProfileInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub stdProfile: StdVideoVP9Profile,
}
impl_default_zeroed_with_s_type!(VkVideoDecodeVP9ProfileInfoKHR : VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PROFILE_INFO_KHR);
impl_extends!(VkVideoDecodeVP9ProfileInfoKHR : VkVideoProfileInfoKHR, VkQueryPoolCreateInfo);

/// `VkVideoEncodeAV1CapabilitiesKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVideoEncodeAV1CapabilitiesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub flags: VkVideoEncodeAV1CapabilityFlagsKHR,
    pub maxLevel: StdVideoAV1Level,
    pub codedPictureAlignment: VkExtent2D,
    pub maxTiles: VkExtent2D,
    pub minTileSize: VkExtent2D,
    pub maxTileSize: VkExtent2D,
    pub superblockSizes: VkVideoEncodeAV1SuperblockSizeFlagsKHR,
    pub maxSingleReferenceCount: uint32_t,
    pub singleReferenceNameMask: uint32_t,
    pub maxUnidirectionalCompoundReferenceCount: uint32_t,
    pub maxUnidirectionalCompoundGroup1ReferenceCount: uint32_t,
    pub unidirectionalCompoundReferenceNameMask: uint32_t,
    pub maxBidirectionalCompoundReferenceCount: uint32_t,
    pub maxBidirectionalCompoundGroup1ReferenceCount: uint32_t,
    pub maxBidirectionalCompoundGroup2ReferenceCount: uint32_t,
    pub bidirectionalCompoundReferenceNameMask: uint32_t,
    pub maxTemporalLayerCount: uint32_t,
    pub maxSpatialLayerCount: uint32_t,
    pub maxOperatingPoints: uint32_t,
    pub minQIndex: uint32_t,
    pub maxQIndex: uint32_t,
    pub prefersGopRemainingFrames: VkBool32,
    pub requiresGopRemainingFrames: VkBool32,
    pub stdSyntaxFlags: VkVideoEncodeAV1StdFlagsKHR,
}
impl_default_zeroed_with_s_type!(VkVideoEncodeAV1CapabilitiesKHR : VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_CAPABILITIES_KHR);
impl_extends!(VkVideoEncodeAV1CapabilitiesKHR : VkVideoCapabilitiesKHR);

flags!(VkVideoEncodeAV1CapabilityFlagsKHR);
from_into_transparent!(VkVideoEncodeAV1CapabilityFlagsKHR: i32);
/// `VkVideoEncodeAV1CapabilityFlagsKHR`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkVideoEncodeAV1CapabilityFlagsKHR(pub i32);

/// `1 << 0`  
pub const VK_VIDEO_ENCODE_AV1_CAPABILITY_PER_RATE_CONTROL_GROUP_MIN_MAX_Q_INDEX_BIT_KHR: VkVideoEncodeAV1CapabilityFlagsKHR = VkVideoEncodeAV1CapabilityFlagsKHR(1 << 0);
/// `1 << 1`  
pub const VK_VIDEO_ENCODE_AV1_CAPABILITY_GENERATE_OBU_EXTENSION_HEADER_BIT_KHR: VkVideoEncodeAV1CapabilityFlagsKHR = VkVideoEncodeAV1CapabilityFlagsKHR(1 << 1);
/// `1 << 2`  
pub const VK_VIDEO_ENCODE_AV1_CAPABILITY_PRIMARY_REFERENCE_CDF_ONLY_BIT_KHR: VkVideoEncodeAV1CapabilityFlagsKHR = VkVideoEncodeAV1CapabilityFlagsKHR(1 << 2);
/// `1 << 3`  
pub const VK_VIDEO_ENCODE_AV1_CAPABILITY_FRAME_SIZE_OVERRIDE_BIT_KHR: VkVideoEncodeAV1CapabilityFlagsKHR = VkVideoEncodeAV1CapabilityFlagsKHR(1 << 3);
/// `1 << 4`  
pub const VK_VIDEO_ENCODE_AV1_CAPABILITY_MOTION_VECTOR_SCALING_BIT_KHR: VkVideoEncodeAV1CapabilityFlagsKHR = VkVideoEncodeAV1CapabilityFlagsKHR(1 << 4);
/// `1 << 5`  
pub const VK_VIDEO_ENCODE_AV1_CAPABILITY_COMPOUND_PREDICTION_INTRA_REFRESH_BIT_KHR: VkVideoEncodeAV1CapabilityFlagsKHR = VkVideoEncodeAV1CapabilityFlagsKHR(1 << 5);

impl_flags_display!(VkVideoEncodeAV1CapabilityFlagsKHR { VK_VIDEO_ENCODE_AV1_CAPABILITY_PER_RATE_CONTROL_GROUP_MIN_MAX_Q_INDEX_BIT_KHR, VK_VIDEO_ENCODE_AV1_CAPABILITY_GENERATE_OBU_EXTENSION_HEADER_BIT_KHR, VK_VIDEO_ENCODE_AV1_CAPABILITY_PRIMARY_REFERENCE_CDF_ONLY_BIT_KHR, VK_VIDEO_ENCODE_AV1_CAPABILITY_FRAME_SIZE_OVERRIDE_BIT_KHR, VK_VIDEO_ENCODE_AV1_CAPABILITY_MOTION_VECTOR_SCALING_BIT_KHR, VK_VIDEO_ENCODE_AV1_CAPABILITY_COMPOUND_PREDICTION_INTRA_REFRESH_BIT_KHR });

/// `VkVideoEncodeAV1DpbSlotInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVideoEncodeAV1DpbSlotInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub pStdReferenceInfo: *const StdVideoEncodeAV1ReferenceInfo,
}
impl_default_zeroed_with_s_type!(VkVideoEncodeAV1DpbSlotInfoKHR : VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_DPB_SLOT_INFO_KHR);
impl_extends!(VkVideoEncodeAV1DpbSlotInfoKHR : VkVideoReferenceSlotInfoKHR);

/// `VkVideoEncodeAV1FrameSizeKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVideoEncodeAV1FrameSizeKHR {
    pub intraFrameSize: uint32_t,
    pub predictiveFrameSize: uint32_t,
    pub bipredictiveFrameSize: uint32_t,
}
impl_default_zeroed!(VkVideoEncodeAV1FrameSizeKHR);

/// `VkVideoEncodeAV1GopRemainingFrameInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVideoEncodeAV1GopRemainingFrameInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub useGopRemainingFrames: VkBool32,
    pub gopRemainingIntra: uint32_t,
    pub gopRemainingPredictive: uint32_t,
    pub gopRemainingBipredictive: uint32_t,
}
impl_default_zeroed_with_s_type!(VkVideoEncodeAV1GopRemainingFrameInfoKHR : VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_GOP_REMAINING_FRAME_INFO_KHR);
impl_extends!(VkVideoEncodeAV1GopRemainingFrameInfoKHR : VkVideoBeginCodingInfoKHR);

/// `VkVideoEncodeAV1PictureInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVideoEncodeAV1PictureInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub predictionMode: VkVideoEncodeAV1PredictionModeKHR,
    pub rateControlGroup: VkVideoEncodeAV1RateControlGroupKHR,
    pub constantQIndex: uint32_t,
    pub pStdPictureInfo: *const StdVideoEncodeAV1PictureInfo,
    pub referenceNameSlotIndices: [int32_t; VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR as usize],
    pub primaryReferenceCdfOnly: VkBool32,
    pub generateObuExtensionHeader: VkBool32,
}
impl_default_zeroed_with_s_type!(VkVideoEncodeAV1PictureInfoKHR : VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PICTURE_INFO_KHR);
impl_extends!(VkVideoEncodeAV1PictureInfoKHR : VkVideoEncodeInfoKHR);

from_into_transparent!(VkVideoEncodeAV1PredictionModeKHR: i32);
/// `VkVideoEncodeAV1PredictionModeKHR`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkVideoEncodeAV1PredictionModeKHR(pub i32);

/// `0`  
pub const VK_VIDEO_ENCODE_AV1_PREDICTION_MODE_INTRA_ONLY_KHR: VkVideoEncodeAV1PredictionModeKHR = VkVideoEncodeAV1PredictionModeKHR(0);
/// `1`  
pub const VK_VIDEO_ENCODE_AV1_PREDICTION_MODE_SINGLE_REFERENCE_KHR: VkVideoEncodeAV1PredictionModeKHR = VkVideoEncodeAV1PredictionModeKHR(1);
/// `2`  
pub const VK_VIDEO_ENCODE_AV1_PREDICTION_MODE_UNIDIRECTIONAL_COMPOUND_KHR: VkVideoEncodeAV1PredictionModeKHR = VkVideoEncodeAV1PredictionModeKHR(2);
/// `3`  
pub const VK_VIDEO_ENCODE_AV1_PREDICTION_MODE_BIDIRECTIONAL_COMPOUND_KHR: VkVideoEncodeAV1PredictionModeKHR = VkVideoEncodeAV1PredictionModeKHR(3);

impl_enum_display!(VkVideoEncodeAV1PredictionModeKHR { VK_VIDEO_ENCODE_AV1_PREDICTION_MODE_INTRA_ONLY_KHR, VK_VIDEO_ENCODE_AV1_PREDICTION_MODE_SINGLE_REFERENCE_KHR, VK_VIDEO_ENCODE_AV1_PREDICTION_MODE_UNIDIRECTIONAL_COMPOUND_KHR, VK_VIDEO_ENCODE_AV1_PREDICTION_MODE_BIDIRECTIONAL_COMPOUND_KHR });

/// `VkVideoEncodeAV1ProfileInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVideoEncodeAV1ProfileInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub stdProfile: StdVideoAV1Profile,
}
impl_default_zeroed_with_s_type!(VkVideoEncodeAV1ProfileInfoKHR : VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PROFILE_INFO_KHR);
impl_extends!(VkVideoEncodeAV1ProfileInfoKHR : VkVideoProfileInfoKHR, VkQueryPoolCreateInfo);

/// `VkVideoEncodeAV1QIndexKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVideoEncodeAV1QIndexKHR {
    pub intraQIndex: uint32_t,
    pub predictiveQIndex: uint32_t,
    pub bipredictiveQIndex: uint32_t,
}
impl_default_zeroed!(VkVideoEncodeAV1QIndexKHR);

/// `VkVideoEncodeAV1QualityLevelPropertiesKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVideoEncodeAV1QualityLevelPropertiesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub preferredRateControlFlags: VkVideoEncodeAV1RateControlFlagsKHR,
    pub preferredGopFrameCount: uint32_t,
    pub preferredKeyFramePeriod: uint32_t,
    pub preferredConsecutiveBipredictiveFrameCount: uint32_t,
    pub preferredTemporalLayerCount: uint32_t,
    pub preferredConstantQIndex: VkVideoEncodeAV1QIndexKHR,
    pub preferredMaxSingleReferenceCount: uint32_t,
    pub preferredSingleReferenceNameMask: uint32_t,
    pub preferredMaxUnidirectionalCompoundReferenceCount: uint32_t,
    pub preferredMaxUnidirectionalCompoundGroup1ReferenceCount: uint32_t,
    pub preferredUnidirectionalCompoundReferenceNameMask: uint32_t,
    pub preferredMaxBidirectionalCompoundReferenceCount: uint32_t,
    pub preferredMaxBidirectionalCompoundGroup1ReferenceCount: uint32_t,
    pub preferredMaxBidirectionalCompoundGroup2ReferenceCount: uint32_t,
    pub preferredBidirectionalCompoundReferenceNameMask: uint32_t,
}
impl_default_zeroed_with_s_type!(VkVideoEncodeAV1QualityLevelPropertiesKHR : VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUALITY_LEVEL_PROPERTIES_KHR);
impl_extends!(VkVideoEncodeAV1QualityLevelPropertiesKHR : VkVideoEncodeQualityLevelPropertiesKHR);

/// `VkVideoEncodeAV1QuantizationMapCapabilitiesKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVideoEncodeAV1QuantizationMapCapabilitiesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub minQIndexDelta: int32_t,
    pub maxQIndexDelta: int32_t,
}
impl_default_zeroed_with_s_type!(VkVideoEncodeAV1QuantizationMapCapabilitiesKHR : VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUANTIZATION_MAP_CAPABILITIES_KHR);
impl_extends!(VkVideoEncodeAV1QuantizationMapCapabilitiesKHR : VkVideoCapabilitiesKHR);

flags!(VkVideoEncodeAV1RateControlFlagsKHR);
from_into_transparent!(VkVideoEncodeAV1RateControlFlagsKHR: i32);
/// `VkVideoEncodeAV1RateControlFlagsKHR`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkVideoEncodeAV1RateControlFlagsKHR(pub i32);

/// `1 << 0`  
pub const VK_VIDEO_ENCODE_AV1_RATE_CONTROL_REGULAR_GOP_BIT_KHR: VkVideoEncodeAV1RateControlFlagsKHR = VkVideoEncodeAV1RateControlFlagsKHR(1 << 0);
/// `1 << 1`  
pub const VK_VIDEO_ENCODE_AV1_RATE_CONTROL_TEMPORAL_LAYER_PATTERN_DYADIC_BIT_KHR: VkVideoEncodeAV1RateControlFlagsKHR = VkVideoEncodeAV1RateControlFlagsKHR(1 << 1);
/// `1 << 2`  
pub const VK_VIDEO_ENCODE_AV1_RATE_CONTROL_REFERENCE_PATTERN_FLAT_BIT_KHR: VkVideoEncodeAV1RateControlFlagsKHR = VkVideoEncodeAV1RateControlFlagsKHR(1 << 2);
/// `1 << 3`  
pub const VK_VIDEO_ENCODE_AV1_RATE_CONTROL_REFERENCE_PATTERN_DYADIC_BIT_KHR: VkVideoEncodeAV1RateControlFlagsKHR = VkVideoEncodeAV1RateControlFlagsKHR(1 << 3);

impl_flags_display!(VkVideoEncodeAV1RateControlFlagsKHR { VK_VIDEO_ENCODE_AV1_RATE_CONTROL_REGULAR_GOP_BIT_KHR, VK_VIDEO_ENCODE_AV1_RATE_CONTROL_TEMPORAL_LAYER_PATTERN_DYADIC_BIT_KHR, VK_VIDEO_ENCODE_AV1_RATE_CONTROL_REFERENCE_PATTERN_FLAT_BIT_KHR, VK_VIDEO_ENCODE_AV1_RATE_CONTROL_REFERENCE_PATTERN_DYADIC_BIT_KHR });

from_into_transparent!(VkVideoEncodeAV1RateControlGroupKHR: i32);
/// `VkVideoEncodeAV1RateControlGroupKHR`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkVideoEncodeAV1RateControlGroupKHR(pub i32);

/// `0`  
pub const VK_VIDEO_ENCODE_AV1_RATE_CONTROL_GROUP_INTRA_KHR: VkVideoEncodeAV1RateControlGroupKHR = VkVideoEncodeAV1RateControlGroupKHR(0);
/// `1`  
pub const VK_VIDEO_ENCODE_AV1_RATE_CONTROL_GROUP_PREDICTIVE_KHR: VkVideoEncodeAV1RateControlGroupKHR = VkVideoEncodeAV1RateControlGroupKHR(1);
/// `2`  
pub const VK_VIDEO_ENCODE_AV1_RATE_CONTROL_GROUP_BIPREDICTIVE_KHR: VkVideoEncodeAV1RateControlGroupKHR = VkVideoEncodeAV1RateControlGroupKHR(2);

impl_enum_display!(VkVideoEncodeAV1RateControlGroupKHR { VK_VIDEO_ENCODE_AV1_RATE_CONTROL_GROUP_INTRA_KHR, VK_VIDEO_ENCODE_AV1_RATE_CONTROL_GROUP_PREDICTIVE_KHR, VK_VIDEO_ENCODE_AV1_RATE_CONTROL_GROUP_BIPREDICTIVE_KHR });

/// `VkVideoEncodeAV1RateControlInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVideoEncodeAV1RateControlInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub flags: VkVideoEncodeAV1RateControlFlagsKHR,
    pub gopFrameCount: uint32_t,
    pub keyFramePeriod: uint32_t,
    pub consecutiveBipredictiveFrameCount: uint32_t,
    pub temporalLayerCount: uint32_t,
}
impl_default_zeroed_with_s_type!(VkVideoEncodeAV1RateControlInfoKHR : VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_INFO_KHR);
impl_extends!(VkVideoEncodeAV1RateControlInfoKHR : VkVideoCodingControlInfoKHR, VkVideoBeginCodingInfoKHR);

/// `VkVideoEncodeAV1RateControlLayerInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVideoEncodeAV1RateControlLayerInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub useMinQIndex: VkBool32,
    pub minQIndex: VkVideoEncodeAV1QIndexKHR,
    pub useMaxQIndex: VkBool32,
    pub maxQIndex: VkVideoEncodeAV1QIndexKHR,
    pub useMaxFrameSize: VkBool32,
    pub maxFrameSize: VkVideoEncodeAV1FrameSizeKHR,
}
impl_default_zeroed_with_s_type!(VkVideoEncodeAV1RateControlLayerInfoKHR : VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_LAYER_INFO_KHR);
impl_extends!(VkVideoEncodeAV1RateControlLayerInfoKHR : VkVideoEncodeRateControlLayerInfoKHR);

/// `VkVideoEncodeAV1SessionCreateInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVideoEncodeAV1SessionCreateInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub useMaxLevel: VkBool32,
    pub maxLevel: StdVideoAV1Level,
}
impl_default_zeroed_with_s_type!(VkVideoEncodeAV1SessionCreateInfoKHR : VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_CREATE_INFO_KHR);
impl_extends!(VkVideoEncodeAV1SessionCreateInfoKHR : VkVideoSessionCreateInfoKHR);

/// `VkVideoEncodeAV1SessionParametersCreateInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVideoEncodeAV1SessionParametersCreateInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub pStdSequenceHeader: *const StdVideoAV1SequenceHeader,
    pub pStdDecoderModelInfo: *const StdVideoEncodeAV1DecoderModelInfo,
    pub stdOperatingPointCount: uint32_t,
    pub pStdOperatingPoints: *const StdVideoEncodeAV1OperatingPointInfo,
}
impl_default_zeroed_with_s_type!(VkVideoEncodeAV1SessionParametersCreateInfoKHR : VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR);
impl_extends!(VkVideoEncodeAV1SessionParametersCreateInfoKHR : VkVideoSessionParametersCreateInfoKHR);

flags!(VkVideoEncodeAV1StdFlagsKHR);
from_into_transparent!(VkVideoEncodeAV1StdFlagsKHR: i32);
/// `VkVideoEncodeAV1StdFlagsKHR`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkVideoEncodeAV1StdFlagsKHR(pub i32);

/// `1 << 0`  
pub const VK_VIDEO_ENCODE_AV1_STD_UNIFORM_TILE_SPACING_FLAG_SET_BIT_KHR: VkVideoEncodeAV1StdFlagsKHR = VkVideoEncodeAV1StdFlagsKHR(1 << 0);
/// `1 << 1`  
pub const VK_VIDEO_ENCODE_AV1_STD_SKIP_MODE_PRESENT_UNSET_BIT_KHR: VkVideoEncodeAV1StdFlagsKHR = VkVideoEncodeAV1StdFlagsKHR(1 << 1);
/// `1 << 2`  
pub const VK_VIDEO_ENCODE_AV1_STD_PRIMARY_REF_FRAME_BIT_KHR: VkVideoEncodeAV1StdFlagsKHR = VkVideoEncodeAV1StdFlagsKHR(1 << 2);
/// `1 << 3`  
pub const VK_VIDEO_ENCODE_AV1_STD_DELTA_Q_BIT_KHR: VkVideoEncodeAV1StdFlagsKHR = VkVideoEncodeAV1StdFlagsKHR(1 << 3);

impl_flags_display!(VkVideoEncodeAV1StdFlagsKHR { VK_VIDEO_ENCODE_AV1_STD_UNIFORM_TILE_SPACING_FLAG_SET_BIT_KHR, VK_VIDEO_ENCODE_AV1_STD_SKIP_MODE_PRESENT_UNSET_BIT_KHR, VK_VIDEO_ENCODE_AV1_STD_PRIMARY_REF_FRAME_BIT_KHR, VK_VIDEO_ENCODE_AV1_STD_DELTA_Q_BIT_KHR });

flags!(VkVideoEncodeAV1SuperblockSizeFlagsKHR);
from_into_transparent!(VkVideoEncodeAV1SuperblockSizeFlagsKHR: i32);
/// `VkVideoEncodeAV1SuperblockSizeFlagsKHR`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkVideoEncodeAV1SuperblockSizeFlagsKHR(pub i32);

/// `1 << 0`  
pub const VK_VIDEO_ENCODE_AV1_SUPERBLOCK_SIZE_64_BIT_KHR: VkVideoEncodeAV1SuperblockSizeFlagsKHR = VkVideoEncodeAV1SuperblockSizeFlagsKHR(1 << 0);
/// `1 << 1`  
pub const VK_VIDEO_ENCODE_AV1_SUPERBLOCK_SIZE_128_BIT_KHR: VkVideoEncodeAV1SuperblockSizeFlagsKHR = VkVideoEncodeAV1SuperblockSizeFlagsKHR(1 << 1);

impl_flags_display!(VkVideoEncodeAV1SuperblockSizeFlagsKHR { VK_VIDEO_ENCODE_AV1_SUPERBLOCK_SIZE_64_BIT_KHR, VK_VIDEO_ENCODE_AV1_SUPERBLOCK_SIZE_128_BIT_KHR });

/// `VkVideoEncodeCapabilitiesKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVideoEncodeCapabilitiesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub flags: VkVideoEncodeCapabilityFlagsKHR,
    pub rateControlModes: VkVideoEncodeRateControlModeFlagsKHR,
    pub maxRateControlLayers: uint32_t,
    pub maxBitrate: uint64_t,
    pub maxQualityLevels: uint32_t,
    pub encodeInputPictureGranularity: VkExtent2D,
    pub supportedEncodeFeedbackFlags: VkVideoEncodeFeedbackFlagsKHR,
}
impl_default_zeroed_with_s_type!(VkVideoEncodeCapabilitiesKHR : VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR);
impl_extends!(VkVideoEncodeCapabilitiesKHR : VkVideoCapabilitiesKHR);

flags!(VkVideoEncodeCapabilityFlagsKHR);
from_into_transparent!(VkVideoEncodeCapabilityFlagsKHR: i32);
/// `VkVideoEncodeCapabilityFlagsKHR`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkVideoEncodeCapabilityFlagsKHR(pub i32);

/// `1 << 0`  
pub const VK_VIDEO_ENCODE_CAPABILITY_PRECEDING_EXTERNALLY_ENCODED_BYTES_BIT_KHR: VkVideoEncodeCapabilityFlagsKHR = VkVideoEncodeCapabilityFlagsKHR(1 << 0);
/// `1 << 1`  
pub const VK_VIDEO_ENCODE_CAPABILITY_INSUFFICIENT_BITSTREAM_BUFFER_RANGE_DETECTION_BIT_KHR: VkVideoEncodeCapabilityFlagsKHR = VkVideoEncodeCapabilityFlagsKHR(1 << 1);
/// `1 << 2`  
pub const VK_VIDEO_ENCODE_CAPABILITY_QUANTIZATION_DELTA_MAP_BIT_KHR: VkVideoEncodeCapabilityFlagsKHR = VkVideoEncodeCapabilityFlagsKHR(1 << 2);
/// `1 << 3`  
pub const VK_VIDEO_ENCODE_CAPABILITY_EMPHASIS_MAP_BIT_KHR: VkVideoEncodeCapabilityFlagsKHR = VkVideoEncodeCapabilityFlagsKHR(1 << 3);

impl_flags_display!(VkVideoEncodeCapabilityFlagsKHR { VK_VIDEO_ENCODE_CAPABILITY_PRECEDING_EXTERNALLY_ENCODED_BYTES_BIT_KHR, VK_VIDEO_ENCODE_CAPABILITY_INSUFFICIENT_BITSTREAM_BUFFER_RANGE_DETECTION_BIT_KHR, VK_VIDEO_ENCODE_CAPABILITY_QUANTIZATION_DELTA_MAP_BIT_KHR, VK_VIDEO_ENCODE_CAPABILITY_EMPHASIS_MAP_BIT_KHR });

flags!(VkVideoEncodeContentFlagsKHR);
from_into_transparent!(VkVideoEncodeContentFlagsKHR: i32);
/// `VkVideoEncodeContentFlagsKHR`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkVideoEncodeContentFlagsKHR(pub i32);

/// `0`  
pub const VK_VIDEO_ENCODE_CONTENT_DEFAULT_KHR: VkVideoEncodeContentFlagsKHR = VkVideoEncodeContentFlagsKHR(0);
/// `1 << 0`  
pub const VK_VIDEO_ENCODE_CONTENT_CAMERA_BIT_KHR: VkVideoEncodeContentFlagsKHR = VkVideoEncodeContentFlagsKHR(1 << 0);
/// `1 << 1`  
pub const VK_VIDEO_ENCODE_CONTENT_DESKTOP_BIT_KHR: VkVideoEncodeContentFlagsKHR = VkVideoEncodeContentFlagsKHR(1 << 1);
/// `1 << 2`  
pub const VK_VIDEO_ENCODE_CONTENT_RENDERED_BIT_KHR: VkVideoEncodeContentFlagsKHR = VkVideoEncodeContentFlagsKHR(1 << 2);

impl_flags_display!(VkVideoEncodeContentFlagsKHR { VK_VIDEO_ENCODE_CONTENT_DEFAULT_KHR, VK_VIDEO_ENCODE_CONTENT_CAMERA_BIT_KHR, VK_VIDEO_ENCODE_CONTENT_DESKTOP_BIT_KHR, VK_VIDEO_ENCODE_CONTENT_RENDERED_BIT_KHR });

flags!(VkVideoEncodeFeedbackFlagsKHR);
from_into_transparent!(VkVideoEncodeFeedbackFlagsKHR: i32);
/// `VkVideoEncodeFeedbackFlagsKHR`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkVideoEncodeFeedbackFlagsKHR(pub i32);

/// `1 << 0`  
pub const VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_BUFFER_OFFSET_BIT_KHR: VkVideoEncodeFeedbackFlagsKHR = VkVideoEncodeFeedbackFlagsKHR(1 << 0);
/// `1 << 1`  
pub const VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_BYTES_WRITTEN_BIT_KHR: VkVideoEncodeFeedbackFlagsKHR = VkVideoEncodeFeedbackFlagsKHR(1 << 1);
/// `1 << 2`  
pub const VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_HAS_OVERRIDES_BIT_KHR: VkVideoEncodeFeedbackFlagsKHR = VkVideoEncodeFeedbackFlagsKHR(1 << 2);
/// `1 << 3`  
pub const VK_VIDEO_ENCODE_FEEDBACK_RESERVED_3_BIT_KHR: VkVideoEncodeFeedbackFlagsKHR = VkVideoEncodeFeedbackFlagsKHR(1 << 3);
/// `1 << 4`  
pub const VK_VIDEO_ENCODE_FEEDBACK_RESERVED_4_BIT_KHR: VkVideoEncodeFeedbackFlagsKHR = VkVideoEncodeFeedbackFlagsKHR(1 << 4);
/// `1 << 5`  
pub const VK_VIDEO_ENCODE_FEEDBACK_RESERVED_5_BIT_KHR: VkVideoEncodeFeedbackFlagsKHR = VkVideoEncodeFeedbackFlagsKHR(1 << 5);
/// `1 << 6`  
pub const VK_VIDEO_ENCODE_FEEDBACK_RESERVED_6_BIT_KHR: VkVideoEncodeFeedbackFlagsKHR = VkVideoEncodeFeedbackFlagsKHR(1 << 6);
/// `1 << 7`  
pub const VK_VIDEO_ENCODE_FEEDBACK_RESERVED_7_BIT_KHR: VkVideoEncodeFeedbackFlagsKHR = VkVideoEncodeFeedbackFlagsKHR(1 << 7);
/// `1 << 8`  
pub const VK_VIDEO_ENCODE_FEEDBACK_RESERVED_8_BIT_KHR: VkVideoEncodeFeedbackFlagsKHR = VkVideoEncodeFeedbackFlagsKHR(1 << 8);
/// `1 << 9`  
pub const VK_VIDEO_ENCODE_FEEDBACK_RESERVED_9_BIT_KHR: VkVideoEncodeFeedbackFlagsKHR = VkVideoEncodeFeedbackFlagsKHR(1 << 9);

impl_flags_display!(VkVideoEncodeFeedbackFlagsKHR { VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_BUFFER_OFFSET_BIT_KHR, VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_BYTES_WRITTEN_BIT_KHR, VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_HAS_OVERRIDES_BIT_KHR, VK_VIDEO_ENCODE_FEEDBACK_RESERVED_3_BIT_KHR, VK_VIDEO_ENCODE_FEEDBACK_RESERVED_4_BIT_KHR, VK_VIDEO_ENCODE_FEEDBACK_RESERVED_5_BIT_KHR, VK_VIDEO_ENCODE_FEEDBACK_RESERVED_6_BIT_KHR, VK_VIDEO_ENCODE_FEEDBACK_RESERVED_7_BIT_KHR, VK_VIDEO_ENCODE_FEEDBACK_RESERVED_8_BIT_KHR, VK_VIDEO_ENCODE_FEEDBACK_RESERVED_9_BIT_KHR });

flags!(VkVideoEncodeFlagsKHR);
from_into_transparent!(VkVideoEncodeFlagsKHR: i32);
/// `VkVideoEncodeFlagsKHR`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkVideoEncodeFlagsKHR(pub i32);

/// `1 << 2`  
pub const VK_VIDEO_ENCODE_INTRA_REFRESH_BIT_KHR: VkVideoEncodeFlagsKHR = VkVideoEncodeFlagsKHR(1 << 2);
/// `1 << 0`  
pub const VK_VIDEO_ENCODE_WITH_QUANTIZATION_DELTA_MAP_BIT_KHR: VkVideoEncodeFlagsKHR = VkVideoEncodeFlagsKHR(1 << 0);
/// `1 << 1`  
pub const VK_VIDEO_ENCODE_WITH_EMPHASIS_MAP_BIT_KHR: VkVideoEncodeFlagsKHR = VkVideoEncodeFlagsKHR(1 << 1);

impl_flags_display!(VkVideoEncodeFlagsKHR { VK_VIDEO_ENCODE_INTRA_REFRESH_BIT_KHR, VK_VIDEO_ENCODE_WITH_QUANTIZATION_DELTA_MAP_BIT_KHR, VK_VIDEO_ENCODE_WITH_EMPHASIS_MAP_BIT_KHR });

/// `VkVideoEncodeH264CapabilitiesKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVideoEncodeH264CapabilitiesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub flags: VkVideoEncodeH264CapabilityFlagsKHR,
    pub maxLevelIdc: StdVideoH264LevelIdc,
    pub maxSliceCount: uint32_t,
    pub maxPPictureL0ReferenceCount: uint32_t,
    pub maxBPictureL0ReferenceCount: uint32_t,
    pub maxL1ReferenceCount: uint32_t,
    pub maxTemporalLayerCount: uint32_t,
    pub expectDyadicTemporalLayerPattern: VkBool32,
    pub minQp: int32_t,
    pub maxQp: int32_t,
    pub prefersGopRemainingFrames: VkBool32,
    pub requiresGopRemainingFrames: VkBool32,
    pub stdSyntaxFlags: VkVideoEncodeH264StdFlagsKHR,
}
impl_default_zeroed_with_s_type!(VkVideoEncodeH264CapabilitiesKHR : VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_KHR);
impl_extends!(VkVideoEncodeH264CapabilitiesKHR : VkVideoCapabilitiesKHR);

flags!(VkVideoEncodeH264CapabilityFlagsKHR);
from_into_transparent!(VkVideoEncodeH264CapabilityFlagsKHR: i32);
/// `VkVideoEncodeH264CapabilityFlagsKHR`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkVideoEncodeH264CapabilityFlagsKHR(pub i32);

/// `1 << 0`  
pub const VK_VIDEO_ENCODE_H264_CAPABILITY_HRD_COMPLIANCE_BIT_KHR: VkVideoEncodeH264CapabilityFlagsKHR = VkVideoEncodeH264CapabilityFlagsKHR(1 << 0);
/// `1 << 1`  
pub const VK_VIDEO_ENCODE_H264_CAPABILITY_PREDICTION_WEIGHT_TABLE_GENERATED_BIT_KHR: VkVideoEncodeH264CapabilityFlagsKHR = VkVideoEncodeH264CapabilityFlagsKHR(1 << 1);
/// `1 << 2`  
pub const VK_VIDEO_ENCODE_H264_CAPABILITY_ROW_UNALIGNED_SLICE_BIT_KHR: VkVideoEncodeH264CapabilityFlagsKHR = VkVideoEncodeH264CapabilityFlagsKHR(1 << 2);
/// `1 << 3`  
pub const VK_VIDEO_ENCODE_H264_CAPABILITY_DIFFERENT_SLICE_TYPE_BIT_KHR: VkVideoEncodeH264CapabilityFlagsKHR = VkVideoEncodeH264CapabilityFlagsKHR(1 << 3);
/// `1 << 4`  
pub const VK_VIDEO_ENCODE_H264_CAPABILITY_B_FRAME_IN_L0_LIST_BIT_KHR: VkVideoEncodeH264CapabilityFlagsKHR = VkVideoEncodeH264CapabilityFlagsKHR(1 << 4);
/// `1 << 5`  
pub const VK_VIDEO_ENCODE_H264_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_KHR: VkVideoEncodeH264CapabilityFlagsKHR = VkVideoEncodeH264CapabilityFlagsKHR(1 << 5);
/// `1 << 6`  
pub const VK_VIDEO_ENCODE_H264_CAPABILITY_PER_PICTURE_TYPE_MIN_MAX_QP_BIT_KHR: VkVideoEncodeH264CapabilityFlagsKHR = VkVideoEncodeH264CapabilityFlagsKHR(1 << 6);
/// `1 << 7`  
pub const VK_VIDEO_ENCODE_H264_CAPABILITY_PER_SLICE_CONSTANT_QP_BIT_KHR: VkVideoEncodeH264CapabilityFlagsKHR = VkVideoEncodeH264CapabilityFlagsKHR(1 << 7);
/// `1 << 8`  
pub const VK_VIDEO_ENCODE_H264_CAPABILITY_GENERATE_PREFIX_NALU_BIT_KHR: VkVideoEncodeH264CapabilityFlagsKHR = VkVideoEncodeH264CapabilityFlagsKHR(1 << 8);
/// `1 << 10`  
pub const VK_VIDEO_ENCODE_H264_CAPABILITY_B_PICTURE_INTRA_REFRESH_BIT_KHR: VkVideoEncodeH264CapabilityFlagsKHR = VkVideoEncodeH264CapabilityFlagsKHR(1 << 10);
/// `1 << 9`  
pub const VK_VIDEO_ENCODE_H264_CAPABILITY_MB_QP_DIFF_WRAPAROUND_BIT_KHR: VkVideoEncodeH264CapabilityFlagsKHR = VkVideoEncodeH264CapabilityFlagsKHR(1 << 9);

impl_flags_display!(VkVideoEncodeH264CapabilityFlagsKHR { VK_VIDEO_ENCODE_H264_CAPABILITY_HRD_COMPLIANCE_BIT_KHR, VK_VIDEO_ENCODE_H264_CAPABILITY_PREDICTION_WEIGHT_TABLE_GENERATED_BIT_KHR, VK_VIDEO_ENCODE_H264_CAPABILITY_ROW_UNALIGNED_SLICE_BIT_KHR, VK_VIDEO_ENCODE_H264_CAPABILITY_DIFFERENT_SLICE_TYPE_BIT_KHR, VK_VIDEO_ENCODE_H264_CAPABILITY_B_FRAME_IN_L0_LIST_BIT_KHR, VK_VIDEO_ENCODE_H264_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_KHR, VK_VIDEO_ENCODE_H264_CAPABILITY_PER_PICTURE_TYPE_MIN_MAX_QP_BIT_KHR, VK_VIDEO_ENCODE_H264_CAPABILITY_PER_SLICE_CONSTANT_QP_BIT_KHR, VK_VIDEO_ENCODE_H264_CAPABILITY_GENERATE_PREFIX_NALU_BIT_KHR, VK_VIDEO_ENCODE_H264_CAPABILITY_B_PICTURE_INTRA_REFRESH_BIT_KHR, VK_VIDEO_ENCODE_H264_CAPABILITY_MB_QP_DIFF_WRAPAROUND_BIT_KHR });

/// `VkVideoEncodeH264DpbSlotInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVideoEncodeH264DpbSlotInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub pStdReferenceInfo: *const StdVideoEncodeH264ReferenceInfo,
}
impl_default_zeroed_with_s_type!(VkVideoEncodeH264DpbSlotInfoKHR : VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_KHR);
impl_extends!(VkVideoEncodeH264DpbSlotInfoKHR : VkVideoReferenceSlotInfoKHR);

/// `VkVideoEncodeH264FrameSizeKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVideoEncodeH264FrameSizeKHR {
    pub frameISize: uint32_t,
    pub framePSize: uint32_t,
    pub frameBSize: uint32_t,
}
impl_default_zeroed!(VkVideoEncodeH264FrameSizeKHR);

/// `VkVideoEncodeH264GopRemainingFrameInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVideoEncodeH264GopRemainingFrameInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub useGopRemainingFrames: VkBool32,
    pub gopRemainingI: uint32_t,
    pub gopRemainingP: uint32_t,
    pub gopRemainingB: uint32_t,
}
impl_default_zeroed_with_s_type!(VkVideoEncodeH264GopRemainingFrameInfoKHR : VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_GOP_REMAINING_FRAME_INFO_KHR);
impl_extends!(VkVideoEncodeH264GopRemainingFrameInfoKHR : VkVideoBeginCodingInfoKHR);

/// `VkVideoEncodeH264NaluSliceInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVideoEncodeH264NaluSliceInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub constantQp: int32_t,
    pub pStdSliceHeader: *const StdVideoEncodeH264SliceHeader,
}
impl_default_zeroed_with_s_type!(VkVideoEncodeH264NaluSliceInfoKHR : VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_NALU_SLICE_INFO_KHR);

/// `VkVideoEncodeH264PictureInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVideoEncodeH264PictureInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub naluSliceEntryCount: uint32_t,
    pub pNaluSliceEntries: *const VkVideoEncodeH264NaluSliceInfoKHR,
    pub pStdPictureInfo: *const StdVideoEncodeH264PictureInfo,
    pub generatePrefixNalu: VkBool32,
}
impl_default_zeroed_with_s_type!(VkVideoEncodeH264PictureInfoKHR : VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PICTURE_INFO_KHR);
impl_extends!(VkVideoEncodeH264PictureInfoKHR : VkVideoEncodeInfoKHR);

/// `VkVideoEncodeH264ProfileInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVideoEncodeH264ProfileInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub stdProfileIdc: StdVideoH264ProfileIdc,
}
impl_default_zeroed_with_s_type!(VkVideoEncodeH264ProfileInfoKHR : VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_KHR);
impl_extends!(VkVideoEncodeH264ProfileInfoKHR : VkVideoProfileInfoKHR, VkQueryPoolCreateInfo);

/// `VkVideoEncodeH264QpKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVideoEncodeH264QpKHR {
    pub qpI: int32_t,
    pub qpP: int32_t,
    pub qpB: int32_t,
}
impl_default_zeroed!(VkVideoEncodeH264QpKHR);

/// `VkVideoEncodeH264QualityLevelPropertiesKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVideoEncodeH264QualityLevelPropertiesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub preferredRateControlFlags: VkVideoEncodeH264RateControlFlagsKHR,
    pub preferredGopFrameCount: uint32_t,
    pub preferredIdrPeriod: uint32_t,
    pub preferredConsecutiveBFrameCount: uint32_t,
    pub preferredTemporalLayerCount: uint32_t,
    pub preferredConstantQp: VkVideoEncodeH264QpKHR,
    pub preferredMaxL0ReferenceCount: uint32_t,
    pub preferredMaxL1ReferenceCount: uint32_t,
    pub preferredStdEntropyCodingModeFlag: VkBool32,
}
impl_default_zeroed_with_s_type!(VkVideoEncodeH264QualityLevelPropertiesKHR : VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_KHR);
impl_extends!(VkVideoEncodeH264QualityLevelPropertiesKHR : VkVideoEncodeQualityLevelPropertiesKHR);

/// `VkVideoEncodeH264QuantizationMapCapabilitiesKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVideoEncodeH264QuantizationMapCapabilitiesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub minQpDelta: int32_t,
    pub maxQpDelta: int32_t,
}
impl_default_zeroed_with_s_type!(VkVideoEncodeH264QuantizationMapCapabilitiesKHR : VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUANTIZATION_MAP_CAPABILITIES_KHR);
impl_extends!(VkVideoEncodeH264QuantizationMapCapabilitiesKHR : VkVideoCapabilitiesKHR);

flags!(VkVideoEncodeH264RateControlFlagsKHR);
from_into_transparent!(VkVideoEncodeH264RateControlFlagsKHR: i32);
/// `VkVideoEncodeH264RateControlFlagsKHR`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkVideoEncodeH264RateControlFlagsKHR(pub i32);

/// `1 << 0`  
pub const VK_VIDEO_ENCODE_H264_RATE_CONTROL_ATTEMPT_HRD_COMPLIANCE_BIT_KHR: VkVideoEncodeH264RateControlFlagsKHR = VkVideoEncodeH264RateControlFlagsKHR(1 << 0);
/// `1 << 1`  
pub const VK_VIDEO_ENCODE_H264_RATE_CONTROL_REGULAR_GOP_BIT_KHR: VkVideoEncodeH264RateControlFlagsKHR = VkVideoEncodeH264RateControlFlagsKHR(1 << 1);
/// `1 << 2`  
pub const VK_VIDEO_ENCODE_H264_RATE_CONTROL_REFERENCE_PATTERN_FLAT_BIT_KHR: VkVideoEncodeH264RateControlFlagsKHR = VkVideoEncodeH264RateControlFlagsKHR(1 << 2);
/// `1 << 3`  
pub const VK_VIDEO_ENCODE_H264_RATE_CONTROL_REFERENCE_PATTERN_DYADIC_BIT_KHR: VkVideoEncodeH264RateControlFlagsKHR = VkVideoEncodeH264RateControlFlagsKHR(1 << 3);
/// `1 << 4`  
pub const VK_VIDEO_ENCODE_H264_RATE_CONTROL_TEMPORAL_LAYER_PATTERN_DYADIC_BIT_KHR: VkVideoEncodeH264RateControlFlagsKHR = VkVideoEncodeH264RateControlFlagsKHR(1 << 4);

impl_flags_display!(VkVideoEncodeH264RateControlFlagsKHR { VK_VIDEO_ENCODE_H264_RATE_CONTROL_ATTEMPT_HRD_COMPLIANCE_BIT_KHR, VK_VIDEO_ENCODE_H264_RATE_CONTROL_REGULAR_GOP_BIT_KHR, VK_VIDEO_ENCODE_H264_RATE_CONTROL_REFERENCE_PATTERN_FLAT_BIT_KHR, VK_VIDEO_ENCODE_H264_RATE_CONTROL_REFERENCE_PATTERN_DYADIC_BIT_KHR, VK_VIDEO_ENCODE_H264_RATE_CONTROL_TEMPORAL_LAYER_PATTERN_DYADIC_BIT_KHR });

/// `VkVideoEncodeH264RateControlInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVideoEncodeH264RateControlInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub flags: VkVideoEncodeH264RateControlFlagsKHR,
    pub gopFrameCount: uint32_t,
    pub idrPeriod: uint32_t,
    pub consecutiveBFrameCount: uint32_t,
    pub temporalLayerCount: uint32_t,
}
impl_default_zeroed_with_s_type!(VkVideoEncodeH264RateControlInfoKHR : VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_KHR);
impl_extends!(VkVideoEncodeH264RateControlInfoKHR : VkVideoCodingControlInfoKHR, VkVideoBeginCodingInfoKHR);

/// `VkVideoEncodeH264RateControlLayerInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVideoEncodeH264RateControlLayerInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub useMinQp: VkBool32,
    pub minQp: VkVideoEncodeH264QpKHR,
    pub useMaxQp: VkBool32,
    pub maxQp: VkVideoEncodeH264QpKHR,
    pub useMaxFrameSize: VkBool32,
    pub maxFrameSize: VkVideoEncodeH264FrameSizeKHR,
}
impl_default_zeroed_with_s_type!(VkVideoEncodeH264RateControlLayerInfoKHR : VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_KHR);
impl_extends!(VkVideoEncodeH264RateControlLayerInfoKHR : VkVideoEncodeRateControlLayerInfoKHR);

/// `VkVideoEncodeH264SessionCreateInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVideoEncodeH264SessionCreateInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub useMaxLevelIdc: VkBool32,
    pub maxLevelIdc: StdVideoH264LevelIdc,
}
impl_default_zeroed_with_s_type!(VkVideoEncodeH264SessionCreateInfoKHR : VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_KHR);
impl_extends!(VkVideoEncodeH264SessionCreateInfoKHR : VkVideoSessionCreateInfoKHR);

/// `VkVideoEncodeH264SessionParametersAddInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVideoEncodeH264SessionParametersAddInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub stdSPSCount: uint32_t,
    pub pStdSPSs: *const StdVideoH264SequenceParameterSet,
    pub stdPPSCount: uint32_t,
    /// List of Picture Parameters associated with the spsStd, above
    pub pStdPPSs: *const StdVideoH264PictureParameterSet,
}
impl_default_zeroed_with_s_type!(VkVideoEncodeH264SessionParametersAddInfoKHR : VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR);
impl_extends!(VkVideoEncodeH264SessionParametersAddInfoKHR : VkVideoSessionParametersUpdateInfoKHR);

/// `VkVideoEncodeH264SessionParametersCreateInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVideoEncodeH264SessionParametersCreateInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub maxStdSPSCount: uint32_t,
    pub maxStdPPSCount: uint32_t,
    pub pParametersAddInfo: *const VkVideoEncodeH264SessionParametersAddInfoKHR,
}
impl_default_zeroed_with_s_type!(VkVideoEncodeH264SessionParametersCreateInfoKHR : VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR);
impl_extends!(VkVideoEncodeH264SessionParametersCreateInfoKHR : VkVideoSessionParametersCreateInfoKHR);

/// `VkVideoEncodeH264SessionParametersFeedbackInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVideoEncodeH264SessionParametersFeedbackInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub hasStdSPSOverrides: VkBool32,
    pub hasStdPPSOverrides: VkBool32,
}
impl_default_zeroed_with_s_type!(VkVideoEncodeH264SessionParametersFeedbackInfoKHR : VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_FEEDBACK_INFO_KHR);
impl_extends!(VkVideoEncodeH264SessionParametersFeedbackInfoKHR : VkVideoEncodeSessionParametersFeedbackInfoKHR);

/// `VkVideoEncodeH264SessionParametersGetInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVideoEncodeH264SessionParametersGetInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub writeStdSPS: VkBool32,
    pub writeStdPPS: VkBool32,
    pub stdSPSId: uint32_t,
    pub stdPPSId: uint32_t,
}
impl_default_zeroed_with_s_type!(VkVideoEncodeH264SessionParametersGetInfoKHR : VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_GET_INFO_KHR);
impl_extends!(VkVideoEncodeH264SessionParametersGetInfoKHR : VkVideoEncodeSessionParametersGetInfoKHR);

flags!(VkVideoEncodeH264StdFlagsKHR);
from_into_transparent!(VkVideoEncodeH264StdFlagsKHR: i32);
/// `VkVideoEncodeH264StdFlagsKHR`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkVideoEncodeH264StdFlagsKHR(pub i32);

/// `1 << 0`  
pub const VK_VIDEO_ENCODE_H264_STD_SEPARATE_COLOR_PLANE_FLAG_SET_BIT_KHR: VkVideoEncodeH264StdFlagsKHR = VkVideoEncodeH264StdFlagsKHR(1 << 0);
/// `1 << 1`  
pub const VK_VIDEO_ENCODE_H264_STD_QPPRIME_Y_ZERO_TRANSFORM_BYPASS_FLAG_SET_BIT_KHR: VkVideoEncodeH264StdFlagsKHR = VkVideoEncodeH264StdFlagsKHR(1 << 1);
/// `1 << 2`  
pub const VK_VIDEO_ENCODE_H264_STD_SCALING_MATRIX_PRESENT_FLAG_SET_BIT_KHR: VkVideoEncodeH264StdFlagsKHR = VkVideoEncodeH264StdFlagsKHR(1 << 2);
/// `1 << 3`  
pub const VK_VIDEO_ENCODE_H264_STD_CHROMA_QP_INDEX_OFFSET_BIT_KHR: VkVideoEncodeH264StdFlagsKHR = VkVideoEncodeH264StdFlagsKHR(1 << 3);
/// `1 << 4`  
pub const VK_VIDEO_ENCODE_H264_STD_SECOND_CHROMA_QP_INDEX_OFFSET_BIT_KHR: VkVideoEncodeH264StdFlagsKHR = VkVideoEncodeH264StdFlagsKHR(1 << 4);
/// `1 << 5`  
pub const VK_VIDEO_ENCODE_H264_STD_PIC_INIT_QP_MINUS26_BIT_KHR: VkVideoEncodeH264StdFlagsKHR = VkVideoEncodeH264StdFlagsKHR(1 << 5);
/// `1 << 6`  
pub const VK_VIDEO_ENCODE_H264_STD_WEIGHTED_PRED_FLAG_SET_BIT_KHR: VkVideoEncodeH264StdFlagsKHR = VkVideoEncodeH264StdFlagsKHR(1 << 6);
/// `1 << 7`  
pub const VK_VIDEO_ENCODE_H264_STD_WEIGHTED_BIPRED_IDC_EXPLICIT_BIT_KHR: VkVideoEncodeH264StdFlagsKHR = VkVideoEncodeH264StdFlagsKHR(1 << 7);
/// `1 << 8`  
pub const VK_VIDEO_ENCODE_H264_STD_WEIGHTED_BIPRED_IDC_IMPLICIT_BIT_KHR: VkVideoEncodeH264StdFlagsKHR = VkVideoEncodeH264StdFlagsKHR(1 << 8);
/// `1 << 9`  
pub const VK_VIDEO_ENCODE_H264_STD_TRANSFORM_8X8_MODE_FLAG_SET_BIT_KHR: VkVideoEncodeH264StdFlagsKHR = VkVideoEncodeH264StdFlagsKHR(1 << 9);
/// `1 << 10`  
pub const VK_VIDEO_ENCODE_H264_STD_DIRECT_SPATIAL_MV_PRED_FLAG_UNSET_BIT_KHR: VkVideoEncodeH264StdFlagsKHR = VkVideoEncodeH264StdFlagsKHR(1 << 10);
/// `1 << 11`  
pub const VK_VIDEO_ENCODE_H264_STD_ENTROPY_CODING_MODE_FLAG_UNSET_BIT_KHR: VkVideoEncodeH264StdFlagsKHR = VkVideoEncodeH264StdFlagsKHR(1 << 11);
/// `1 << 12`  
pub const VK_VIDEO_ENCODE_H264_STD_ENTROPY_CODING_MODE_FLAG_SET_BIT_KHR: VkVideoEncodeH264StdFlagsKHR = VkVideoEncodeH264StdFlagsKHR(1 << 12);
/// `1 << 13`  
pub const VK_VIDEO_ENCODE_H264_STD_DIRECT_8X8_INFERENCE_FLAG_UNSET_BIT_KHR: VkVideoEncodeH264StdFlagsKHR = VkVideoEncodeH264StdFlagsKHR(1 << 13);
/// `1 << 14`  
pub const VK_VIDEO_ENCODE_H264_STD_CONSTRAINED_INTRA_PRED_FLAG_SET_BIT_KHR: VkVideoEncodeH264StdFlagsKHR = VkVideoEncodeH264StdFlagsKHR(1 << 14);
/// `1 << 15`  
pub const VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_DISABLED_BIT_KHR: VkVideoEncodeH264StdFlagsKHR = VkVideoEncodeH264StdFlagsKHR(1 << 15);
/// `1 << 16`  
pub const VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_ENABLED_BIT_KHR: VkVideoEncodeH264StdFlagsKHR = VkVideoEncodeH264StdFlagsKHR(1 << 16);
/// `1 << 17`  
pub const VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_PARTIAL_BIT_KHR: VkVideoEncodeH264StdFlagsKHR = VkVideoEncodeH264StdFlagsKHR(1 << 17);
/// `1 << 19`  
pub const VK_VIDEO_ENCODE_H264_STD_SLICE_QP_DELTA_BIT_KHR: VkVideoEncodeH264StdFlagsKHR = VkVideoEncodeH264StdFlagsKHR(1 << 19);
/// `1 << 20`  
pub const VK_VIDEO_ENCODE_H264_STD_DIFFERENT_SLICE_QP_DELTA_BIT_KHR: VkVideoEncodeH264StdFlagsKHR = VkVideoEncodeH264StdFlagsKHR(1 << 20);

impl_flags_display!(VkVideoEncodeH264StdFlagsKHR { VK_VIDEO_ENCODE_H264_STD_SEPARATE_COLOR_PLANE_FLAG_SET_BIT_KHR, VK_VIDEO_ENCODE_H264_STD_QPPRIME_Y_ZERO_TRANSFORM_BYPASS_FLAG_SET_BIT_KHR, VK_VIDEO_ENCODE_H264_STD_SCALING_MATRIX_PRESENT_FLAG_SET_BIT_KHR, VK_VIDEO_ENCODE_H264_STD_CHROMA_QP_INDEX_OFFSET_BIT_KHR, VK_VIDEO_ENCODE_H264_STD_SECOND_CHROMA_QP_INDEX_OFFSET_BIT_KHR, VK_VIDEO_ENCODE_H264_STD_PIC_INIT_QP_MINUS26_BIT_KHR, VK_VIDEO_ENCODE_H264_STD_WEIGHTED_PRED_FLAG_SET_BIT_KHR, VK_VIDEO_ENCODE_H264_STD_WEIGHTED_BIPRED_IDC_EXPLICIT_BIT_KHR, VK_VIDEO_ENCODE_H264_STD_WEIGHTED_BIPRED_IDC_IMPLICIT_BIT_KHR, VK_VIDEO_ENCODE_H264_STD_TRANSFORM_8X8_MODE_FLAG_SET_BIT_KHR, VK_VIDEO_ENCODE_H264_STD_DIRECT_SPATIAL_MV_PRED_FLAG_UNSET_BIT_KHR, VK_VIDEO_ENCODE_H264_STD_ENTROPY_CODING_MODE_FLAG_UNSET_BIT_KHR, VK_VIDEO_ENCODE_H264_STD_ENTROPY_CODING_MODE_FLAG_SET_BIT_KHR, VK_VIDEO_ENCODE_H264_STD_DIRECT_8X8_INFERENCE_FLAG_UNSET_BIT_KHR, VK_VIDEO_ENCODE_H264_STD_CONSTRAINED_INTRA_PRED_FLAG_SET_BIT_KHR, VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_DISABLED_BIT_KHR, VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_ENABLED_BIT_KHR, VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_PARTIAL_BIT_KHR, VK_VIDEO_ENCODE_H264_STD_SLICE_QP_DELTA_BIT_KHR, VK_VIDEO_ENCODE_H264_STD_DIFFERENT_SLICE_QP_DELTA_BIT_KHR });

/// `VkVideoEncodeH265CapabilitiesKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVideoEncodeH265CapabilitiesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub flags: VkVideoEncodeH265CapabilityFlagsKHR,
    pub maxLevelIdc: StdVideoH265LevelIdc,
    pub maxSliceSegmentCount: uint32_t,
    pub maxTiles: VkExtent2D,
    pub ctbSizes: VkVideoEncodeH265CtbSizeFlagsKHR,
    pub transformBlockSizes: VkVideoEncodeH265TransformBlockSizeFlagsKHR,
    pub maxPPictureL0ReferenceCount: uint32_t,
    pub maxBPictureL0ReferenceCount: uint32_t,
    pub maxL1ReferenceCount: uint32_t,
    pub maxSubLayerCount: uint32_t,
    pub expectDyadicTemporalSubLayerPattern: VkBool32,
    pub minQp: int32_t,
    pub maxQp: int32_t,
    pub prefersGopRemainingFrames: VkBool32,
    pub requiresGopRemainingFrames: VkBool32,
    pub stdSyntaxFlags: VkVideoEncodeH265StdFlagsKHR,
}
impl_default_zeroed_with_s_type!(VkVideoEncodeH265CapabilitiesKHR : VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_KHR);
impl_extends!(VkVideoEncodeH265CapabilitiesKHR : VkVideoCapabilitiesKHR);

flags!(VkVideoEncodeH265CapabilityFlagsKHR);
from_into_transparent!(VkVideoEncodeH265CapabilityFlagsKHR: i32);
/// `VkVideoEncodeH265CapabilityFlagsKHR`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkVideoEncodeH265CapabilityFlagsKHR(pub i32);

/// `1 << 0`  
pub const VK_VIDEO_ENCODE_H265_CAPABILITY_HRD_COMPLIANCE_BIT_KHR: VkVideoEncodeH265CapabilityFlagsKHR = VkVideoEncodeH265CapabilityFlagsKHR(1 << 0);
/// `1 << 1`  
pub const VK_VIDEO_ENCODE_H265_CAPABILITY_PREDICTION_WEIGHT_TABLE_GENERATED_BIT_KHR: VkVideoEncodeH265CapabilityFlagsKHR = VkVideoEncodeH265CapabilityFlagsKHR(1 << 1);
/// `1 << 2`  
pub const VK_VIDEO_ENCODE_H265_CAPABILITY_ROW_UNALIGNED_SLICE_SEGMENT_BIT_KHR: VkVideoEncodeH265CapabilityFlagsKHR = VkVideoEncodeH265CapabilityFlagsKHR(1 << 2);
/// `1 << 3`  
pub const VK_VIDEO_ENCODE_H265_CAPABILITY_DIFFERENT_SLICE_SEGMENT_TYPE_BIT_KHR: VkVideoEncodeH265CapabilityFlagsKHR = VkVideoEncodeH265CapabilityFlagsKHR(1 << 3);
/// `1 << 4`  
pub const VK_VIDEO_ENCODE_H265_CAPABILITY_B_FRAME_IN_L0_LIST_BIT_KHR: VkVideoEncodeH265CapabilityFlagsKHR = VkVideoEncodeH265CapabilityFlagsKHR(1 << 4);
/// `1 << 5`  
pub const VK_VIDEO_ENCODE_H265_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_KHR: VkVideoEncodeH265CapabilityFlagsKHR = VkVideoEncodeH265CapabilityFlagsKHR(1 << 5);
/// `1 << 6`  
pub const VK_VIDEO_ENCODE_H265_CAPABILITY_PER_PICTURE_TYPE_MIN_MAX_QP_BIT_KHR: VkVideoEncodeH265CapabilityFlagsKHR = VkVideoEncodeH265CapabilityFlagsKHR(1 << 6);
/// `1 << 7`  
pub const VK_VIDEO_ENCODE_H265_CAPABILITY_PER_SLICE_SEGMENT_CONSTANT_QP_BIT_KHR: VkVideoEncodeH265CapabilityFlagsKHR = VkVideoEncodeH265CapabilityFlagsKHR(1 << 7);
/// `1 << 8`  
pub const VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_TILES_PER_SLICE_SEGMENT_BIT_KHR: VkVideoEncodeH265CapabilityFlagsKHR = VkVideoEncodeH265CapabilityFlagsKHR(1 << 8);
/// `1 << 9`  
pub const VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_SLICE_SEGMENTS_PER_TILE_BIT_KHR: VkVideoEncodeH265CapabilityFlagsKHR = VkVideoEncodeH265CapabilityFlagsKHR(1 << 9);
/// `1 << 11`  
pub const VK_VIDEO_ENCODE_H265_CAPABILITY_B_PICTURE_INTRA_REFRESH_BIT_KHR: VkVideoEncodeH265CapabilityFlagsKHR = VkVideoEncodeH265CapabilityFlagsKHR(1 << 11);
/// `1 << 10`  
pub const VK_VIDEO_ENCODE_H265_CAPABILITY_CU_QP_DIFF_WRAPAROUND_BIT_KHR: VkVideoEncodeH265CapabilityFlagsKHR = VkVideoEncodeH265CapabilityFlagsKHR(1 << 10);

impl_flags_display!(VkVideoEncodeH265CapabilityFlagsKHR { VK_VIDEO_ENCODE_H265_CAPABILITY_HRD_COMPLIANCE_BIT_KHR, VK_VIDEO_ENCODE_H265_CAPABILITY_PREDICTION_WEIGHT_TABLE_GENERATED_BIT_KHR, VK_VIDEO_ENCODE_H265_CAPABILITY_ROW_UNALIGNED_SLICE_SEGMENT_BIT_KHR, VK_VIDEO_ENCODE_H265_CAPABILITY_DIFFERENT_SLICE_SEGMENT_TYPE_BIT_KHR, VK_VIDEO_ENCODE_H265_CAPABILITY_B_FRAME_IN_L0_LIST_BIT_KHR, VK_VIDEO_ENCODE_H265_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_KHR, VK_VIDEO_ENCODE_H265_CAPABILITY_PER_PICTURE_TYPE_MIN_MAX_QP_BIT_KHR, VK_VIDEO_ENCODE_H265_CAPABILITY_PER_SLICE_SEGMENT_CONSTANT_QP_BIT_KHR, VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_TILES_PER_SLICE_SEGMENT_BIT_KHR, VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_SLICE_SEGMENTS_PER_TILE_BIT_KHR, VK_VIDEO_ENCODE_H265_CAPABILITY_B_PICTURE_INTRA_REFRESH_BIT_KHR, VK_VIDEO_ENCODE_H265_CAPABILITY_CU_QP_DIFF_WRAPAROUND_BIT_KHR });

flags!(VkVideoEncodeH265CtbSizeFlagsKHR);
from_into_transparent!(VkVideoEncodeH265CtbSizeFlagsKHR: i32);
/// `VkVideoEncodeH265CtbSizeFlagsKHR`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkVideoEncodeH265CtbSizeFlagsKHR(pub i32);

/// `1 << 0`  
pub const VK_VIDEO_ENCODE_H265_CTB_SIZE_16_BIT_KHR: VkVideoEncodeH265CtbSizeFlagsKHR = VkVideoEncodeH265CtbSizeFlagsKHR(1 << 0);
/// `1 << 1`  
pub const VK_VIDEO_ENCODE_H265_CTB_SIZE_32_BIT_KHR: VkVideoEncodeH265CtbSizeFlagsKHR = VkVideoEncodeH265CtbSizeFlagsKHR(1 << 1);
/// `1 << 2`  
pub const VK_VIDEO_ENCODE_H265_CTB_SIZE_64_BIT_KHR: VkVideoEncodeH265CtbSizeFlagsKHR = VkVideoEncodeH265CtbSizeFlagsKHR(1 << 2);

impl_flags_display!(VkVideoEncodeH265CtbSizeFlagsKHR { VK_VIDEO_ENCODE_H265_CTB_SIZE_16_BIT_KHR, VK_VIDEO_ENCODE_H265_CTB_SIZE_32_BIT_KHR, VK_VIDEO_ENCODE_H265_CTB_SIZE_64_BIT_KHR });

/// `VkVideoEncodeH265DpbSlotInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVideoEncodeH265DpbSlotInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub pStdReferenceInfo: *const StdVideoEncodeH265ReferenceInfo,
}
impl_default_zeroed_with_s_type!(VkVideoEncodeH265DpbSlotInfoKHR : VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_KHR);
impl_extends!(VkVideoEncodeH265DpbSlotInfoKHR : VkVideoReferenceSlotInfoKHR);

/// `VkVideoEncodeH265FrameSizeKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVideoEncodeH265FrameSizeKHR {
    pub frameISize: uint32_t,
    pub framePSize: uint32_t,
    pub frameBSize: uint32_t,
}
impl_default_zeroed!(VkVideoEncodeH265FrameSizeKHR);

/// `VkVideoEncodeH265GopRemainingFrameInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVideoEncodeH265GopRemainingFrameInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub useGopRemainingFrames: VkBool32,
    pub gopRemainingI: uint32_t,
    pub gopRemainingP: uint32_t,
    pub gopRemainingB: uint32_t,
}
impl_default_zeroed_with_s_type!(VkVideoEncodeH265GopRemainingFrameInfoKHR : VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_GOP_REMAINING_FRAME_INFO_KHR);
impl_extends!(VkVideoEncodeH265GopRemainingFrameInfoKHR : VkVideoBeginCodingInfoKHR);

/// `VkVideoEncodeH265NaluSliceSegmentInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVideoEncodeH265NaluSliceSegmentInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub constantQp: int32_t,
    pub pStdSliceSegmentHeader: *const StdVideoEncodeH265SliceSegmentHeader,
}
impl_default_zeroed_with_s_type!(VkVideoEncodeH265NaluSliceSegmentInfoKHR : VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO_KHR);

/// `VkVideoEncodeH265PictureInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVideoEncodeH265PictureInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub naluSliceSegmentEntryCount: uint32_t,
    pub pNaluSliceSegmentEntries: *const VkVideoEncodeH265NaluSliceSegmentInfoKHR,
    pub pStdPictureInfo: *const StdVideoEncodeH265PictureInfo,
}
impl_default_zeroed_with_s_type!(VkVideoEncodeH265PictureInfoKHR : VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PICTURE_INFO_KHR);
impl_extends!(VkVideoEncodeH265PictureInfoKHR : VkVideoEncodeInfoKHR);

/// `VkVideoEncodeH265ProfileInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVideoEncodeH265ProfileInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub stdProfileIdc: StdVideoH265ProfileIdc,
}
impl_default_zeroed_with_s_type!(VkVideoEncodeH265ProfileInfoKHR : VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_KHR);
impl_extends!(VkVideoEncodeH265ProfileInfoKHR : VkVideoProfileInfoKHR, VkQueryPoolCreateInfo);

/// `VkVideoEncodeH265QpKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVideoEncodeH265QpKHR {
    pub qpI: int32_t,
    pub qpP: int32_t,
    pub qpB: int32_t,
}
impl_default_zeroed!(VkVideoEncodeH265QpKHR);

/// `VkVideoEncodeH265QualityLevelPropertiesKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVideoEncodeH265QualityLevelPropertiesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub preferredRateControlFlags: VkVideoEncodeH265RateControlFlagsKHR,
    pub preferredGopFrameCount: uint32_t,
    pub preferredIdrPeriod: uint32_t,
    pub preferredConsecutiveBFrameCount: uint32_t,
    pub preferredSubLayerCount: uint32_t,
    pub preferredConstantQp: VkVideoEncodeH265QpKHR,
    pub preferredMaxL0ReferenceCount: uint32_t,
    pub preferredMaxL1ReferenceCount: uint32_t,
}
impl_default_zeroed_with_s_type!(VkVideoEncodeH265QualityLevelPropertiesKHR : VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUALITY_LEVEL_PROPERTIES_KHR);
impl_extends!(VkVideoEncodeH265QualityLevelPropertiesKHR : VkVideoEncodeQualityLevelPropertiesKHR);

/// `VkVideoEncodeH265QuantizationMapCapabilitiesKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVideoEncodeH265QuantizationMapCapabilitiesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub minQpDelta: int32_t,
    pub maxQpDelta: int32_t,
}
impl_default_zeroed_with_s_type!(VkVideoEncodeH265QuantizationMapCapabilitiesKHR : VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUANTIZATION_MAP_CAPABILITIES_KHR);
impl_extends!(VkVideoEncodeH265QuantizationMapCapabilitiesKHR : VkVideoCapabilitiesKHR);

flags!(VkVideoEncodeH265RateControlFlagsKHR);
from_into_transparent!(VkVideoEncodeH265RateControlFlagsKHR: i32);
/// `VkVideoEncodeH265RateControlFlagsKHR`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkVideoEncodeH265RateControlFlagsKHR(pub i32);

/// `1 << 0`  
pub const VK_VIDEO_ENCODE_H265_RATE_CONTROL_ATTEMPT_HRD_COMPLIANCE_BIT_KHR: VkVideoEncodeH265RateControlFlagsKHR = VkVideoEncodeH265RateControlFlagsKHR(1 << 0);
/// `1 << 1`  
pub const VK_VIDEO_ENCODE_H265_RATE_CONTROL_REGULAR_GOP_BIT_KHR: VkVideoEncodeH265RateControlFlagsKHR = VkVideoEncodeH265RateControlFlagsKHR(1 << 1);
/// `1 << 2`  
pub const VK_VIDEO_ENCODE_H265_RATE_CONTROL_REFERENCE_PATTERN_FLAT_BIT_KHR: VkVideoEncodeH265RateControlFlagsKHR = VkVideoEncodeH265RateControlFlagsKHR(1 << 2);
/// `1 << 3`  
pub const VK_VIDEO_ENCODE_H265_RATE_CONTROL_REFERENCE_PATTERN_DYADIC_BIT_KHR: VkVideoEncodeH265RateControlFlagsKHR = VkVideoEncodeH265RateControlFlagsKHR(1 << 3);
/// `1 << 4`  
pub const VK_VIDEO_ENCODE_H265_RATE_CONTROL_TEMPORAL_SUB_LAYER_PATTERN_DYADIC_BIT_KHR: VkVideoEncodeH265RateControlFlagsKHR = VkVideoEncodeH265RateControlFlagsKHR(1 << 4);

impl_flags_display!(VkVideoEncodeH265RateControlFlagsKHR { VK_VIDEO_ENCODE_H265_RATE_CONTROL_ATTEMPT_HRD_COMPLIANCE_BIT_KHR, VK_VIDEO_ENCODE_H265_RATE_CONTROL_REGULAR_GOP_BIT_KHR, VK_VIDEO_ENCODE_H265_RATE_CONTROL_REFERENCE_PATTERN_FLAT_BIT_KHR, VK_VIDEO_ENCODE_H265_RATE_CONTROL_REFERENCE_PATTERN_DYADIC_BIT_KHR, VK_VIDEO_ENCODE_H265_RATE_CONTROL_TEMPORAL_SUB_LAYER_PATTERN_DYADIC_BIT_KHR });

/// `VkVideoEncodeH265RateControlInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVideoEncodeH265RateControlInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub flags: VkVideoEncodeH265RateControlFlagsKHR,
    pub gopFrameCount: uint32_t,
    pub idrPeriod: uint32_t,
    pub consecutiveBFrameCount: uint32_t,
    pub subLayerCount: uint32_t,
}
impl_default_zeroed_with_s_type!(VkVideoEncodeH265RateControlInfoKHR : VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_KHR);
impl_extends!(VkVideoEncodeH265RateControlInfoKHR : VkVideoCodingControlInfoKHR, VkVideoBeginCodingInfoKHR);

/// `VkVideoEncodeH265RateControlLayerInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVideoEncodeH265RateControlLayerInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub useMinQp: VkBool32,
    pub minQp: VkVideoEncodeH265QpKHR,
    pub useMaxQp: VkBool32,
    pub maxQp: VkVideoEncodeH265QpKHR,
    pub useMaxFrameSize: VkBool32,
    pub maxFrameSize: VkVideoEncodeH265FrameSizeKHR,
}
impl_default_zeroed_with_s_type!(VkVideoEncodeH265RateControlLayerInfoKHR : VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_KHR);
impl_extends!(VkVideoEncodeH265RateControlLayerInfoKHR : VkVideoEncodeRateControlLayerInfoKHR);

/// `VkVideoEncodeH265SessionCreateInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVideoEncodeH265SessionCreateInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub useMaxLevelIdc: VkBool32,
    pub maxLevelIdc: StdVideoH265LevelIdc,
}
impl_default_zeroed_with_s_type!(VkVideoEncodeH265SessionCreateInfoKHR : VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_KHR);
impl_extends!(VkVideoEncodeH265SessionCreateInfoKHR : VkVideoSessionCreateInfoKHR);

/// `VkVideoEncodeH265SessionParametersAddInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVideoEncodeH265SessionParametersAddInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub stdVPSCount: uint32_t,
    pub pStdVPSs: *const StdVideoH265VideoParameterSet,
    pub stdSPSCount: uint32_t,
    pub pStdSPSs: *const StdVideoH265SequenceParameterSet,
    pub stdPPSCount: uint32_t,
    /// List of Picture Parameters associated with the spsStd, above
    pub pStdPPSs: *const StdVideoH265PictureParameterSet,
}
impl_default_zeroed_with_s_type!(VkVideoEncodeH265SessionParametersAddInfoKHR : VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR);
impl_extends!(VkVideoEncodeH265SessionParametersAddInfoKHR : VkVideoSessionParametersUpdateInfoKHR);

/// `VkVideoEncodeH265SessionParametersCreateInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVideoEncodeH265SessionParametersCreateInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub maxStdVPSCount: uint32_t,
    pub maxStdSPSCount: uint32_t,
    pub maxStdPPSCount: uint32_t,
    pub pParametersAddInfo: *const VkVideoEncodeH265SessionParametersAddInfoKHR,
}
impl_default_zeroed_with_s_type!(VkVideoEncodeH265SessionParametersCreateInfoKHR : VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR);
impl_extends!(VkVideoEncodeH265SessionParametersCreateInfoKHR : VkVideoSessionParametersCreateInfoKHR);

/// `VkVideoEncodeH265SessionParametersFeedbackInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVideoEncodeH265SessionParametersFeedbackInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub hasStdVPSOverrides: VkBool32,
    pub hasStdSPSOverrides: VkBool32,
    pub hasStdPPSOverrides: VkBool32,
}
impl_default_zeroed_with_s_type!(VkVideoEncodeH265SessionParametersFeedbackInfoKHR : VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_FEEDBACK_INFO_KHR);
impl_extends!(VkVideoEncodeH265SessionParametersFeedbackInfoKHR : VkVideoEncodeSessionParametersFeedbackInfoKHR);

/// `VkVideoEncodeH265SessionParametersGetInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVideoEncodeH265SessionParametersGetInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub writeStdVPS: VkBool32,
    pub writeStdSPS: VkBool32,
    pub writeStdPPS: VkBool32,
    pub stdVPSId: uint32_t,
    pub stdSPSId: uint32_t,
    pub stdPPSId: uint32_t,
}
impl_default_zeroed_with_s_type!(VkVideoEncodeH265SessionParametersGetInfoKHR : VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_GET_INFO_KHR);
impl_extends!(VkVideoEncodeH265SessionParametersGetInfoKHR : VkVideoEncodeSessionParametersGetInfoKHR);

flags!(VkVideoEncodeH265StdFlagsKHR);
from_into_transparent!(VkVideoEncodeH265StdFlagsKHR: i32);
/// `VkVideoEncodeH265StdFlagsKHR`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkVideoEncodeH265StdFlagsKHR(pub i32);

/// `1 << 0`  
pub const VK_VIDEO_ENCODE_H265_STD_SEPARATE_COLOR_PLANE_FLAG_SET_BIT_KHR: VkVideoEncodeH265StdFlagsKHR = VkVideoEncodeH265StdFlagsKHR(1 << 0);
/// `1 << 1`  
pub const VK_VIDEO_ENCODE_H265_STD_SAMPLE_ADAPTIVE_OFFSET_ENABLED_FLAG_SET_BIT_KHR: VkVideoEncodeH265StdFlagsKHR = VkVideoEncodeH265StdFlagsKHR(1 << 1);
/// `1 << 2`  
pub const VK_VIDEO_ENCODE_H265_STD_SCALING_LIST_DATA_PRESENT_FLAG_SET_BIT_KHR: VkVideoEncodeH265StdFlagsKHR = VkVideoEncodeH265StdFlagsKHR(1 << 2);
/// `1 << 3`  
pub const VK_VIDEO_ENCODE_H265_STD_PCM_ENABLED_FLAG_SET_BIT_KHR: VkVideoEncodeH265StdFlagsKHR = VkVideoEncodeH265StdFlagsKHR(1 << 3);
/// `1 << 4`  
pub const VK_VIDEO_ENCODE_H265_STD_SPS_TEMPORAL_MVP_ENABLED_FLAG_SET_BIT_KHR: VkVideoEncodeH265StdFlagsKHR = VkVideoEncodeH265StdFlagsKHR(1 << 4);
/// `1 << 5`  
pub const VK_VIDEO_ENCODE_H265_STD_INIT_QP_MINUS26_BIT_KHR: VkVideoEncodeH265StdFlagsKHR = VkVideoEncodeH265StdFlagsKHR(1 << 5);
/// `1 << 6`  
pub const VK_VIDEO_ENCODE_H265_STD_WEIGHTED_PRED_FLAG_SET_BIT_KHR: VkVideoEncodeH265StdFlagsKHR = VkVideoEncodeH265StdFlagsKHR(1 << 6);
/// `1 << 7`  
pub const VK_VIDEO_ENCODE_H265_STD_WEIGHTED_BIPRED_FLAG_SET_BIT_KHR: VkVideoEncodeH265StdFlagsKHR = VkVideoEncodeH265StdFlagsKHR(1 << 7);
/// `1 << 8`  
pub const VK_VIDEO_ENCODE_H265_STD_LOG2_PARALLEL_MERGE_LEVEL_MINUS2_BIT_KHR: VkVideoEncodeH265StdFlagsKHR = VkVideoEncodeH265StdFlagsKHR(1 << 8);
/// `1 << 9`  
pub const VK_VIDEO_ENCODE_H265_STD_SIGN_DATA_HIDING_ENABLED_FLAG_SET_BIT_KHR: VkVideoEncodeH265StdFlagsKHR = VkVideoEncodeH265StdFlagsKHR(1 << 9);
/// `1 << 10`  
pub const VK_VIDEO_ENCODE_H265_STD_TRANSFORM_SKIP_ENABLED_FLAG_SET_BIT_KHR: VkVideoEncodeH265StdFlagsKHR = VkVideoEncodeH265StdFlagsKHR(1 << 10);
/// `1 << 11`  
pub const VK_VIDEO_ENCODE_H265_STD_TRANSFORM_SKIP_ENABLED_FLAG_UNSET_BIT_KHR: VkVideoEncodeH265StdFlagsKHR = VkVideoEncodeH265StdFlagsKHR(1 << 11);
/// `1 << 12`  
pub const VK_VIDEO_ENCODE_H265_STD_PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT_FLAG_SET_BIT_KHR: VkVideoEncodeH265StdFlagsKHR = VkVideoEncodeH265StdFlagsKHR(1 << 12);
/// `1 << 13`  
pub const VK_VIDEO_ENCODE_H265_STD_TRANSQUANT_BYPASS_ENABLED_FLAG_SET_BIT_KHR: VkVideoEncodeH265StdFlagsKHR = VkVideoEncodeH265StdFlagsKHR(1 << 13);
/// `1 << 14`  
pub const VK_VIDEO_ENCODE_H265_STD_CONSTRAINED_INTRA_PRED_FLAG_SET_BIT_KHR: VkVideoEncodeH265StdFlagsKHR = VkVideoEncodeH265StdFlagsKHR(1 << 14);
/// `1 << 15`  
pub const VK_VIDEO_ENCODE_H265_STD_ENTROPY_CODING_SYNC_ENABLED_FLAG_SET_BIT_KHR: VkVideoEncodeH265StdFlagsKHR = VkVideoEncodeH265StdFlagsKHR(1 << 15);
/// `1 << 16`  
pub const VK_VIDEO_ENCODE_H265_STD_DEBLOCKING_FILTER_OVERRIDE_ENABLED_FLAG_SET_BIT_KHR: VkVideoEncodeH265StdFlagsKHR = VkVideoEncodeH265StdFlagsKHR(1 << 16);
/// `1 << 17`  
pub const VK_VIDEO_ENCODE_H265_STD_DEPENDENT_SLICE_SEGMENTS_ENABLED_FLAG_SET_BIT_KHR: VkVideoEncodeH265StdFlagsKHR = VkVideoEncodeH265StdFlagsKHR(1 << 17);
/// `1 << 18`  
pub const VK_VIDEO_ENCODE_H265_STD_DEPENDENT_SLICE_SEGMENT_FLAG_SET_BIT_KHR: VkVideoEncodeH265StdFlagsKHR = VkVideoEncodeH265StdFlagsKHR(1 << 18);
/// `1 << 19`  
pub const VK_VIDEO_ENCODE_H265_STD_SLICE_QP_DELTA_BIT_KHR: VkVideoEncodeH265StdFlagsKHR = VkVideoEncodeH265StdFlagsKHR(1 << 19);
/// `1 << 20`  
pub const VK_VIDEO_ENCODE_H265_STD_DIFFERENT_SLICE_QP_DELTA_BIT_KHR: VkVideoEncodeH265StdFlagsKHR = VkVideoEncodeH265StdFlagsKHR(1 << 20);

impl_flags_display!(VkVideoEncodeH265StdFlagsKHR { VK_VIDEO_ENCODE_H265_STD_SEPARATE_COLOR_PLANE_FLAG_SET_BIT_KHR, VK_VIDEO_ENCODE_H265_STD_SAMPLE_ADAPTIVE_OFFSET_ENABLED_FLAG_SET_BIT_KHR, VK_VIDEO_ENCODE_H265_STD_SCALING_LIST_DATA_PRESENT_FLAG_SET_BIT_KHR, VK_VIDEO_ENCODE_H265_STD_PCM_ENABLED_FLAG_SET_BIT_KHR, VK_VIDEO_ENCODE_H265_STD_SPS_TEMPORAL_MVP_ENABLED_FLAG_SET_BIT_KHR, VK_VIDEO_ENCODE_H265_STD_INIT_QP_MINUS26_BIT_KHR, VK_VIDEO_ENCODE_H265_STD_WEIGHTED_PRED_FLAG_SET_BIT_KHR, VK_VIDEO_ENCODE_H265_STD_WEIGHTED_BIPRED_FLAG_SET_BIT_KHR, VK_VIDEO_ENCODE_H265_STD_LOG2_PARALLEL_MERGE_LEVEL_MINUS2_BIT_KHR, VK_VIDEO_ENCODE_H265_STD_SIGN_DATA_HIDING_ENABLED_FLAG_SET_BIT_KHR, VK_VIDEO_ENCODE_H265_STD_TRANSFORM_SKIP_ENABLED_FLAG_SET_BIT_KHR, VK_VIDEO_ENCODE_H265_STD_TRANSFORM_SKIP_ENABLED_FLAG_UNSET_BIT_KHR, VK_VIDEO_ENCODE_H265_STD_PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT_FLAG_SET_BIT_KHR, VK_VIDEO_ENCODE_H265_STD_TRANSQUANT_BYPASS_ENABLED_FLAG_SET_BIT_KHR, VK_VIDEO_ENCODE_H265_STD_CONSTRAINED_INTRA_PRED_FLAG_SET_BIT_KHR, VK_VIDEO_ENCODE_H265_STD_ENTROPY_CODING_SYNC_ENABLED_FLAG_SET_BIT_KHR, VK_VIDEO_ENCODE_H265_STD_DEBLOCKING_FILTER_OVERRIDE_ENABLED_FLAG_SET_BIT_KHR, VK_VIDEO_ENCODE_H265_STD_DEPENDENT_SLICE_SEGMENTS_ENABLED_FLAG_SET_BIT_KHR, VK_VIDEO_ENCODE_H265_STD_DEPENDENT_SLICE_SEGMENT_FLAG_SET_BIT_KHR, VK_VIDEO_ENCODE_H265_STD_SLICE_QP_DELTA_BIT_KHR, VK_VIDEO_ENCODE_H265_STD_DIFFERENT_SLICE_QP_DELTA_BIT_KHR });

flags!(VkVideoEncodeH265TransformBlockSizeFlagsKHR);
from_into_transparent!(VkVideoEncodeH265TransformBlockSizeFlagsKHR: i32);
/// `VkVideoEncodeH265TransformBlockSizeFlagsKHR`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkVideoEncodeH265TransformBlockSizeFlagsKHR(pub i32);

/// `1 << 0`  
pub const VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_4_BIT_KHR: VkVideoEncodeH265TransformBlockSizeFlagsKHR = VkVideoEncodeH265TransformBlockSizeFlagsKHR(1 << 0);
/// `1 << 1`  
pub const VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_8_BIT_KHR: VkVideoEncodeH265TransformBlockSizeFlagsKHR = VkVideoEncodeH265TransformBlockSizeFlagsKHR(1 << 1);
/// `1 << 2`  
pub const VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_16_BIT_KHR: VkVideoEncodeH265TransformBlockSizeFlagsKHR = VkVideoEncodeH265TransformBlockSizeFlagsKHR(1 << 2);
/// `1 << 3`  
pub const VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_32_BIT_KHR: VkVideoEncodeH265TransformBlockSizeFlagsKHR = VkVideoEncodeH265TransformBlockSizeFlagsKHR(1 << 3);

impl_flags_display!(VkVideoEncodeH265TransformBlockSizeFlagsKHR { VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_4_BIT_KHR, VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_8_BIT_KHR, VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_16_BIT_KHR, VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_32_BIT_KHR });

/// `VkVideoEncodeInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVideoEncodeInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub flags: VkVideoEncodeFlagsKHR,
    pub dstBuffer: VkBuffer,
    pub dstBufferOffset: VkDeviceSize,
    pub dstBufferRange: VkDeviceSize,
    pub srcPictureResource: VkVideoPictureResourceInfoKHR,
    pub pSetupReferenceSlot: *const VkVideoReferenceSlotInfoKHR,
    pub referenceSlotCount: uint32_t,
    pub pReferenceSlots: *const VkVideoReferenceSlotInfoKHR,
    pub precedingExternallyEncodedBytes: uint32_t,
}
impl_default_zeroed_with_s_type!(VkVideoEncodeInfoKHR : VK_STRUCTURE_TYPE_VIDEO_ENCODE_INFO_KHR);

/// `VkVideoEncodeIntraRefreshCapabilitiesKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVideoEncodeIntraRefreshCapabilitiesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub intraRefreshModes: VkVideoEncodeIntraRefreshModeFlagsKHR,
    pub maxIntraRefreshCycleDuration: uint32_t,
    pub maxIntraRefreshActiveReferencePictures: uint32_t,
    pub partitionIndependentIntraRefreshRegions: VkBool32,
    pub nonRectangularIntraRefreshRegions: VkBool32,
}
impl_default_zeroed_with_s_type!(VkVideoEncodeIntraRefreshCapabilitiesKHR : VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_CAPABILITIES_KHR);
impl_extends!(VkVideoEncodeIntraRefreshCapabilitiesKHR : VkVideoCapabilitiesKHR);

/// `VkVideoEncodeIntraRefreshInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVideoEncodeIntraRefreshInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub intraRefreshCycleDuration: uint32_t,
    pub intraRefreshIndex: uint32_t,
}
impl_default_zeroed_with_s_type!(VkVideoEncodeIntraRefreshInfoKHR : VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_INFO_KHR);
impl_extends!(VkVideoEncodeIntraRefreshInfoKHR : VkVideoEncodeInfoKHR);

flags!(VkVideoEncodeIntraRefreshModeFlagsKHR);
from_into_transparent!(VkVideoEncodeIntraRefreshModeFlagsKHR: i32);
/// `VkVideoEncodeIntraRefreshModeFlagsKHR`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkVideoEncodeIntraRefreshModeFlagsKHR(pub i32);

/// `0`  
pub const VK_VIDEO_ENCODE_INTRA_REFRESH_MODE_NONE_KHR: VkVideoEncodeIntraRefreshModeFlagsKHR = VkVideoEncodeIntraRefreshModeFlagsKHR(0);
/// `1 << 0`  
pub const VK_VIDEO_ENCODE_INTRA_REFRESH_MODE_PER_PICTURE_PARTITION_BIT_KHR: VkVideoEncodeIntraRefreshModeFlagsKHR = VkVideoEncodeIntraRefreshModeFlagsKHR(1 << 0);
/// `1 << 1`  
pub const VK_VIDEO_ENCODE_INTRA_REFRESH_MODE_BLOCK_BASED_BIT_KHR: VkVideoEncodeIntraRefreshModeFlagsKHR = VkVideoEncodeIntraRefreshModeFlagsKHR(1 << 1);
/// `1 << 2`  
pub const VK_VIDEO_ENCODE_INTRA_REFRESH_MODE_BLOCK_ROW_BASED_BIT_KHR: VkVideoEncodeIntraRefreshModeFlagsKHR = VkVideoEncodeIntraRefreshModeFlagsKHR(1 << 2);
/// `1 << 3`  
pub const VK_VIDEO_ENCODE_INTRA_REFRESH_MODE_BLOCK_COLUMN_BASED_BIT_KHR: VkVideoEncodeIntraRefreshModeFlagsKHR = VkVideoEncodeIntraRefreshModeFlagsKHR(1 << 3);

impl_flags_display!(VkVideoEncodeIntraRefreshModeFlagsKHR { VK_VIDEO_ENCODE_INTRA_REFRESH_MODE_NONE_KHR, VK_VIDEO_ENCODE_INTRA_REFRESH_MODE_PER_PICTURE_PARTITION_BIT_KHR, VK_VIDEO_ENCODE_INTRA_REFRESH_MODE_BLOCK_BASED_BIT_KHR, VK_VIDEO_ENCODE_INTRA_REFRESH_MODE_BLOCK_ROW_BASED_BIT_KHR, VK_VIDEO_ENCODE_INTRA_REFRESH_MODE_BLOCK_COLUMN_BASED_BIT_KHR });

/// `VkVideoEncodeProfileRgbConversionInfoVALVE`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVideoEncodeProfileRgbConversionInfoVALVE {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub performEncodeRgbConversion: VkBool32,
}
impl_default_zeroed_with_s_type!(VkVideoEncodeProfileRgbConversionInfoVALVE : VK_STRUCTURE_TYPE_VIDEO_ENCODE_PROFILE_RGB_CONVERSION_INFO_VALVE);
impl_extends!(VkVideoEncodeProfileRgbConversionInfoVALVE : VkVideoProfileInfoKHR);

/// `VkVideoEncodeQualityLevelInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVideoEncodeQualityLevelInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub qualityLevel: uint32_t,
}
impl_default_zeroed_with_s_type!(VkVideoEncodeQualityLevelInfoKHR : VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR);
impl_extends!(VkVideoEncodeQualityLevelInfoKHR : VkVideoCodingControlInfoKHR, VkVideoSessionParametersCreateInfoKHR);

/// `VkVideoEncodeQualityLevelPropertiesKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVideoEncodeQualityLevelPropertiesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub preferredRateControlMode: VkVideoEncodeRateControlModeFlagsKHR,
    pub preferredRateControlLayerCount: uint32_t,
}
impl_default_zeroed_with_s_type!(VkVideoEncodeQualityLevelPropertiesKHR : VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_PROPERTIES_KHR);

/// `VkVideoEncodeQuantizationMapCapabilitiesKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVideoEncodeQuantizationMapCapabilitiesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub maxQuantizationMapExtent: VkExtent2D,
}
impl_default_zeroed_with_s_type!(VkVideoEncodeQuantizationMapCapabilitiesKHR : VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR);
impl_extends!(VkVideoEncodeQuantizationMapCapabilitiesKHR : VkVideoCapabilitiesKHR);

/// `VkVideoEncodeQuantizationMapInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVideoEncodeQuantizationMapInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub quantizationMap: VkImageView,
    pub quantizationMapExtent: VkExtent2D,
}
impl_default_zeroed_with_s_type!(VkVideoEncodeQuantizationMapInfoKHR : VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_INFO_KHR);
impl_extends!(VkVideoEncodeQuantizationMapInfoKHR : VkVideoEncodeInfoKHR);

/// `VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub quantizationMapTexelSize: VkExtent2D,
}
impl_default_zeroed_with_s_type!(VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR : VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_SESSION_PARAMETERS_CREATE_INFO_KHR);
impl_extends!(VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR : VkVideoSessionParametersCreateInfoKHR);

flags!(VkVideoEncodeRateControlFlagsKHR);
from_into_transparent!(VkVideoEncodeRateControlFlagsKHR: i32);
/// `VkVideoEncodeRateControlFlagsKHR`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkVideoEncodeRateControlFlagsKHR(pub i32);

impl_flags_display!(VkVideoEncodeRateControlFlagsKHR {  });

/// `VkVideoEncodeRateControlInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVideoEncodeRateControlInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub flags: VkVideoEncodeRateControlFlagsKHR,
    pub rateControlMode: VkVideoEncodeRateControlModeFlagsKHR,
    pub layerCount: uint32_t,
    pub pLayers: *const VkVideoEncodeRateControlLayerInfoKHR,
    pub virtualBufferSizeInMs: uint32_t,
    pub initialVirtualBufferSizeInMs: uint32_t,
}
impl_default_zeroed_with_s_type!(VkVideoEncodeRateControlInfoKHR : VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR);
impl_extends!(VkVideoEncodeRateControlInfoKHR : VkVideoCodingControlInfoKHR, VkVideoBeginCodingInfoKHR);

/// `VkVideoEncodeRateControlLayerInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVideoEncodeRateControlLayerInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub averageBitrate: uint64_t,
    pub maxBitrate: uint64_t,
    pub frameRateNumerator: uint32_t,
    pub frameRateDenominator: uint32_t,
}
impl_default_zeroed_with_s_type!(VkVideoEncodeRateControlLayerInfoKHR : VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO_KHR);

flags!(VkVideoEncodeRateControlModeFlagsKHR);
from_into_transparent!(VkVideoEncodeRateControlModeFlagsKHR: i32);
/// `VkVideoEncodeRateControlModeFlagsKHR`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkVideoEncodeRateControlModeFlagsKHR(pub i32);

/// `0`  
pub const VK_VIDEO_ENCODE_RATE_CONTROL_MODE_DEFAULT_KHR: VkVideoEncodeRateControlModeFlagsKHR = VkVideoEncodeRateControlModeFlagsKHR(0);
/// `1 << 0`  
pub const VK_VIDEO_ENCODE_RATE_CONTROL_MODE_DISABLED_BIT_KHR: VkVideoEncodeRateControlModeFlagsKHR = VkVideoEncodeRateControlModeFlagsKHR(1 << 0);
/// `1 << 1`  
pub const VK_VIDEO_ENCODE_RATE_CONTROL_MODE_CBR_BIT_KHR: VkVideoEncodeRateControlModeFlagsKHR = VkVideoEncodeRateControlModeFlagsKHR(1 << 1);
/// `1 << 2`  
pub const VK_VIDEO_ENCODE_RATE_CONTROL_MODE_VBR_BIT_KHR: VkVideoEncodeRateControlModeFlagsKHR = VkVideoEncodeRateControlModeFlagsKHR(1 << 2);

impl_flags_display!(VkVideoEncodeRateControlModeFlagsKHR { VK_VIDEO_ENCODE_RATE_CONTROL_MODE_DEFAULT_KHR, VK_VIDEO_ENCODE_RATE_CONTROL_MODE_DISABLED_BIT_KHR, VK_VIDEO_ENCODE_RATE_CONTROL_MODE_CBR_BIT_KHR, VK_VIDEO_ENCODE_RATE_CONTROL_MODE_VBR_BIT_KHR });

flags!(VkVideoEncodeRgbChromaOffsetFlagsVALVE);
from_into_transparent!(VkVideoEncodeRgbChromaOffsetFlagsVALVE: i32);
/// `VkVideoEncodeRgbChromaOffsetFlagsVALVE`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkVideoEncodeRgbChromaOffsetFlagsVALVE(pub i32);

/// `1 << 0`  
pub const VK_VIDEO_ENCODE_RGB_CHROMA_OFFSET_COSITED_EVEN_BIT_VALVE: VkVideoEncodeRgbChromaOffsetFlagsVALVE = VkVideoEncodeRgbChromaOffsetFlagsVALVE(1 << 0);
/// `1 << 1`  
pub const VK_VIDEO_ENCODE_RGB_CHROMA_OFFSET_MIDPOINT_BIT_VALVE: VkVideoEncodeRgbChromaOffsetFlagsVALVE = VkVideoEncodeRgbChromaOffsetFlagsVALVE(1 << 1);

impl_flags_display!(VkVideoEncodeRgbChromaOffsetFlagsVALVE { VK_VIDEO_ENCODE_RGB_CHROMA_OFFSET_COSITED_EVEN_BIT_VALVE, VK_VIDEO_ENCODE_RGB_CHROMA_OFFSET_MIDPOINT_BIT_VALVE });

/// `VkVideoEncodeRgbConversionCapabilitiesVALVE`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVideoEncodeRgbConversionCapabilitiesVALVE {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub rgbModels: VkVideoEncodeRgbModelConversionFlagsVALVE,
    pub rgbRanges: VkVideoEncodeRgbRangeCompressionFlagsVALVE,
    pub xChromaOffsets: VkVideoEncodeRgbChromaOffsetFlagsVALVE,
    pub yChromaOffsets: VkVideoEncodeRgbChromaOffsetFlagsVALVE,
}
impl_default_zeroed_with_s_type!(VkVideoEncodeRgbConversionCapabilitiesVALVE : VK_STRUCTURE_TYPE_VIDEO_ENCODE_RGB_CONVERSION_CAPABILITIES_VALVE);
impl_extends!(VkVideoEncodeRgbConversionCapabilitiesVALVE : VkVideoCapabilitiesKHR);

flags!(VkVideoEncodeRgbModelConversionFlagsVALVE);
from_into_transparent!(VkVideoEncodeRgbModelConversionFlagsVALVE: i32);
/// `VkVideoEncodeRgbModelConversionFlagsVALVE`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkVideoEncodeRgbModelConversionFlagsVALVE(pub i32);

/// `1 << 0`  
pub const VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_RGB_IDENTITY_BIT_VALVE: VkVideoEncodeRgbModelConversionFlagsVALVE = VkVideoEncodeRgbModelConversionFlagsVALVE(1 << 0);
/// `1 << 1`  
pub const VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_IDENTITY_BIT_VALVE: VkVideoEncodeRgbModelConversionFlagsVALVE = VkVideoEncodeRgbModelConversionFlagsVALVE(1 << 1);
/// `1 << 2`  
pub const VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_709_BIT_VALVE: VkVideoEncodeRgbModelConversionFlagsVALVE = VkVideoEncodeRgbModelConversionFlagsVALVE(1 << 2);
/// `1 << 3`  
pub const VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_601_BIT_VALVE: VkVideoEncodeRgbModelConversionFlagsVALVE = VkVideoEncodeRgbModelConversionFlagsVALVE(1 << 3);
/// `1 << 4`  
pub const VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_2020_BIT_VALVE: VkVideoEncodeRgbModelConversionFlagsVALVE = VkVideoEncodeRgbModelConversionFlagsVALVE(1 << 4);

impl_flags_display!(VkVideoEncodeRgbModelConversionFlagsVALVE { VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_RGB_IDENTITY_BIT_VALVE, VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_IDENTITY_BIT_VALVE, VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_709_BIT_VALVE, VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_601_BIT_VALVE, VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_2020_BIT_VALVE });

flags!(VkVideoEncodeRgbRangeCompressionFlagsVALVE);
from_into_transparent!(VkVideoEncodeRgbRangeCompressionFlagsVALVE: i32);
/// `VkVideoEncodeRgbRangeCompressionFlagsVALVE`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkVideoEncodeRgbRangeCompressionFlagsVALVE(pub i32);

/// `1 << 0`  
pub const VK_VIDEO_ENCODE_RGB_RANGE_COMPRESSION_FULL_RANGE_BIT_VALVE: VkVideoEncodeRgbRangeCompressionFlagsVALVE = VkVideoEncodeRgbRangeCompressionFlagsVALVE(1 << 0);
/// `1 << 1`  
pub const VK_VIDEO_ENCODE_RGB_RANGE_COMPRESSION_NARROW_RANGE_BIT_VALVE: VkVideoEncodeRgbRangeCompressionFlagsVALVE = VkVideoEncodeRgbRangeCompressionFlagsVALVE(1 << 1);

impl_flags_display!(VkVideoEncodeRgbRangeCompressionFlagsVALVE { VK_VIDEO_ENCODE_RGB_RANGE_COMPRESSION_FULL_RANGE_BIT_VALVE, VK_VIDEO_ENCODE_RGB_RANGE_COMPRESSION_NARROW_RANGE_BIT_VALVE });

/// `VkVideoEncodeSessionIntraRefreshCreateInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVideoEncodeSessionIntraRefreshCreateInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub intraRefreshMode: VkVideoEncodeIntraRefreshModeFlagsKHR,
}
impl_default_zeroed_with_s_type!(VkVideoEncodeSessionIntraRefreshCreateInfoKHR : VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_INTRA_REFRESH_CREATE_INFO_KHR);
impl_extends!(VkVideoEncodeSessionIntraRefreshCreateInfoKHR : VkVideoSessionCreateInfoKHR);

/// `VkVideoEncodeSessionParametersFeedbackInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVideoEncodeSessionParametersFeedbackInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub hasOverrides: VkBool32,
}
impl_default_zeroed_with_s_type!(VkVideoEncodeSessionParametersFeedbackInfoKHR : VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_PARAMETERS_FEEDBACK_INFO_KHR);

/// `VkVideoEncodeSessionParametersGetInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVideoEncodeSessionParametersGetInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub videoSessionParameters: VkVideoSessionParametersKHR,
}
impl_default_zeroed_with_s_type!(VkVideoEncodeSessionParametersGetInfoKHR : VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_PARAMETERS_GET_INFO_KHR);

/// `VkVideoEncodeSessionRgbConversionCreateInfoVALVE`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVideoEncodeSessionRgbConversionCreateInfoVALVE {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub rgbModel: VkVideoEncodeRgbModelConversionFlagsVALVE,
    pub rgbRange: VkVideoEncodeRgbRangeCompressionFlagsVALVE,
    pub xChromaOffset: VkVideoEncodeRgbChromaOffsetFlagsVALVE,
    pub yChromaOffset: VkVideoEncodeRgbChromaOffsetFlagsVALVE,
}
impl_default_zeroed_with_s_type!(VkVideoEncodeSessionRgbConversionCreateInfoVALVE : VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_RGB_CONVERSION_CREATE_INFO_VALVE);
impl_extends!(VkVideoEncodeSessionRgbConversionCreateInfoVALVE : VkVideoSessionCreateInfoKHR);

from_into_transparent!(VkVideoEncodeTuningModeKHR: i32);
/// `VkVideoEncodeTuningModeKHR`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkVideoEncodeTuningModeKHR(pub i32);

/// `0`  
pub const VK_VIDEO_ENCODE_TUNING_MODE_DEFAULT_KHR: VkVideoEncodeTuningModeKHR = VkVideoEncodeTuningModeKHR(0);
/// `1`  
pub const VK_VIDEO_ENCODE_TUNING_MODE_HIGH_QUALITY_KHR: VkVideoEncodeTuningModeKHR = VkVideoEncodeTuningModeKHR(1);
/// `2`  
pub const VK_VIDEO_ENCODE_TUNING_MODE_LOW_LATENCY_KHR: VkVideoEncodeTuningModeKHR = VkVideoEncodeTuningModeKHR(2);
/// `3`  
pub const VK_VIDEO_ENCODE_TUNING_MODE_ULTRA_LOW_LATENCY_KHR: VkVideoEncodeTuningModeKHR = VkVideoEncodeTuningModeKHR(3);
/// `4`  
pub const VK_VIDEO_ENCODE_TUNING_MODE_LOSSLESS_KHR: VkVideoEncodeTuningModeKHR = VkVideoEncodeTuningModeKHR(4);

impl_enum_display!(VkVideoEncodeTuningModeKHR { VK_VIDEO_ENCODE_TUNING_MODE_DEFAULT_KHR, VK_VIDEO_ENCODE_TUNING_MODE_HIGH_QUALITY_KHR, VK_VIDEO_ENCODE_TUNING_MODE_LOW_LATENCY_KHR, VK_VIDEO_ENCODE_TUNING_MODE_ULTRA_LOW_LATENCY_KHR, VK_VIDEO_ENCODE_TUNING_MODE_LOSSLESS_KHR });

flags!(VkVideoEncodeUsageFlagsKHR);
from_into_transparent!(VkVideoEncodeUsageFlagsKHR: i32);
/// `VkVideoEncodeUsageFlagsKHR`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkVideoEncodeUsageFlagsKHR(pub i32);

/// `0`  
pub const VK_VIDEO_ENCODE_USAGE_DEFAULT_KHR: VkVideoEncodeUsageFlagsKHR = VkVideoEncodeUsageFlagsKHR(0);
/// `1 << 0`  
pub const VK_VIDEO_ENCODE_USAGE_TRANSCODING_BIT_KHR: VkVideoEncodeUsageFlagsKHR = VkVideoEncodeUsageFlagsKHR(1 << 0);
/// `1 << 1`  
pub const VK_VIDEO_ENCODE_USAGE_STREAMING_BIT_KHR: VkVideoEncodeUsageFlagsKHR = VkVideoEncodeUsageFlagsKHR(1 << 1);
/// `1 << 2`  
pub const VK_VIDEO_ENCODE_USAGE_RECORDING_BIT_KHR: VkVideoEncodeUsageFlagsKHR = VkVideoEncodeUsageFlagsKHR(1 << 2);
/// `1 << 3`  
pub const VK_VIDEO_ENCODE_USAGE_CONFERENCING_BIT_KHR: VkVideoEncodeUsageFlagsKHR = VkVideoEncodeUsageFlagsKHR(1 << 3);

impl_flags_display!(VkVideoEncodeUsageFlagsKHR { VK_VIDEO_ENCODE_USAGE_DEFAULT_KHR, VK_VIDEO_ENCODE_USAGE_TRANSCODING_BIT_KHR, VK_VIDEO_ENCODE_USAGE_STREAMING_BIT_KHR, VK_VIDEO_ENCODE_USAGE_RECORDING_BIT_KHR, VK_VIDEO_ENCODE_USAGE_CONFERENCING_BIT_KHR });

/// `VkVideoEncodeUsageInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVideoEncodeUsageInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub videoUsageHints: VkVideoEncodeUsageFlagsKHR,
    pub videoContentHints: VkVideoEncodeContentFlagsKHR,
    pub tuningMode: VkVideoEncodeTuningModeKHR,
}
impl_default_zeroed_with_s_type!(VkVideoEncodeUsageInfoKHR : VK_STRUCTURE_TYPE_VIDEO_ENCODE_USAGE_INFO_KHR);
impl_extends!(VkVideoEncodeUsageInfoKHR : VkVideoProfileInfoKHR, VkQueryPoolCreateInfo);

flags!(VkVideoEndCodingFlagsKHR);
from_into_transparent!(VkVideoEndCodingFlagsKHR: i32);
/// `VkVideoEndCodingFlagsKHR`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkVideoEndCodingFlagsKHR(pub i32);

impl_flags_display!(VkVideoEndCodingFlagsKHR {  });

/// `VkVideoEndCodingInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVideoEndCodingInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub flags: VkVideoEndCodingFlagsKHR,
}
impl_default_zeroed_with_s_type!(VkVideoEndCodingInfoKHR : VK_STRUCTURE_TYPE_VIDEO_END_CODING_INFO_KHR);

/// `VkVideoFormatAV1QuantizationMapPropertiesKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVideoFormatAV1QuantizationMapPropertiesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub compatibleSuperblockSizes: VkVideoEncodeAV1SuperblockSizeFlagsKHR,
}
impl_default_zeroed_with_s_type!(VkVideoFormatAV1QuantizationMapPropertiesKHR : VK_STRUCTURE_TYPE_VIDEO_FORMAT_AV1_QUANTIZATION_MAP_PROPERTIES_KHR);
impl_extends!(VkVideoFormatAV1QuantizationMapPropertiesKHR : VkVideoFormatPropertiesKHR);

/// `VkVideoFormatH265QuantizationMapPropertiesKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVideoFormatH265QuantizationMapPropertiesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub compatibleCtbSizes: VkVideoEncodeH265CtbSizeFlagsKHR,
}
impl_default_zeroed_with_s_type!(VkVideoFormatH265QuantizationMapPropertiesKHR : VK_STRUCTURE_TYPE_VIDEO_FORMAT_H265_QUANTIZATION_MAP_PROPERTIES_KHR);
impl_extends!(VkVideoFormatH265QuantizationMapPropertiesKHR : VkVideoFormatPropertiesKHR);

/// `VkVideoFormatPropertiesKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVideoFormatPropertiesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub format: VkFormat,
    pub componentMapping: VkComponentMapping,
    pub imageCreateFlags: VkImageCreateFlags,
    pub imageType: VkImageType,
    pub imageTiling: VkImageTiling,
    pub imageUsageFlags: VkImageUsageFlags,
}
impl_default_zeroed_with_s_type!(VkVideoFormatPropertiesKHR : VK_STRUCTURE_TYPE_VIDEO_FORMAT_PROPERTIES_KHR);

/// `VkVideoFormatQuantizationMapPropertiesKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVideoFormatQuantizationMapPropertiesKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub quantizationMapTexelSize: VkExtent2D,
}
impl_default_zeroed_with_s_type!(VkVideoFormatQuantizationMapPropertiesKHR : VK_STRUCTURE_TYPE_VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES_KHR);
impl_extends!(VkVideoFormatQuantizationMapPropertiesKHR : VkVideoFormatPropertiesKHR);

/// `VkVideoInlineQueryInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVideoInlineQueryInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub queryPool: VkQueryPool,
    pub firstQuery: uint32_t,
    pub queryCount: uint32_t,
}
impl_default_zeroed_with_s_type!(VkVideoInlineQueryInfoKHR : VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR);
impl_extends!(VkVideoInlineQueryInfoKHR : VkVideoDecodeInfoKHR, VkVideoEncodeInfoKHR);

/// `VkVideoPictureResourceInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVideoPictureResourceInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    /// The offset to be used for the picture resource, currently only used in field mode
    pub codedOffset: VkOffset2D,
    /// The extent to be used for the picture resource
    pub codedExtent: VkExtent2D,
    /// The first array layer to be accessed for the Decode or Encode Operations
    pub baseArrayLayer: uint32_t,
    /// The ImageView binding of the resource
    pub imageViewBinding: VkImageView,
}
impl_default_zeroed_with_s_type!(VkVideoPictureResourceInfoKHR : VK_STRUCTURE_TYPE_VIDEO_PICTURE_RESOURCE_INFO_KHR);

/// `VkVideoProfileInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVideoProfileInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub videoCodecOperation: VkVideoCodecOperationFlagsKHR,
    pub chromaSubsampling: VkVideoChromaSubsamplingFlagsKHR,
    pub lumaBitDepth: VkVideoComponentBitDepthFlagsKHR,
    pub chromaBitDepth: VkVideoComponentBitDepthFlagsKHR,
}
impl_default_zeroed_with_s_type!(VkVideoProfileInfoKHR : VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR);
impl_extends!(VkVideoProfileInfoKHR : VkQueryPoolCreateInfo);

/// `VkVideoProfileListInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVideoProfileListInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub profileCount: uint32_t,
    pub pProfiles: *const VkVideoProfileInfoKHR,
}
impl_default_zeroed_with_s_type!(VkVideoProfileListInfoKHR : VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR);
impl_extends!(VkVideoProfileListInfoKHR : VkPhysicalDeviceImageFormatInfo2, VkPhysicalDeviceVideoFormatInfoKHR, VkImageCreateInfo, VkBufferCreateInfo);

/// `VkVideoReferenceIntraRefreshInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVideoReferenceIntraRefreshInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub dirtyIntraRefreshRegions: uint32_t,
}
impl_default_zeroed_with_s_type!(VkVideoReferenceIntraRefreshInfoKHR : VK_STRUCTURE_TYPE_VIDEO_REFERENCE_INTRA_REFRESH_INFO_KHR);
impl_extends!(VkVideoReferenceIntraRefreshInfoKHR : VkVideoReferenceSlotInfoKHR);

/// `VkVideoReferenceSlotInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVideoReferenceSlotInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    /// The reference slot index
    pub slotIndex: int32_t,
    /// The reference picture resource
    pub pPictureResource: *const VkVideoPictureResourceInfoKHR,
}
impl_default_zeroed_with_s_type!(VkVideoReferenceSlotInfoKHR : VK_STRUCTURE_TYPE_VIDEO_REFERENCE_SLOT_INFO_KHR);

flags!(VkVideoSessionCreateFlagsKHR);
from_into_transparent!(VkVideoSessionCreateFlagsKHR: i32);
/// `VkVideoSessionCreateFlagsKHR`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkVideoSessionCreateFlagsKHR(pub i32);

/// `1 << 0`  
pub const VK_VIDEO_SESSION_CREATE_PROTECTED_CONTENT_BIT_KHR: VkVideoSessionCreateFlagsKHR = VkVideoSessionCreateFlagsKHR(1 << 0);
/// `1 << 1`  
pub const VK_VIDEO_SESSION_CREATE_ALLOW_ENCODE_PARAMETER_OPTIMIZATIONS_BIT_KHR: VkVideoSessionCreateFlagsKHR = VkVideoSessionCreateFlagsKHR(1 << 1);
/// `1 << 2`  
pub const VK_VIDEO_SESSION_CREATE_INLINE_QUERIES_BIT_KHR: VkVideoSessionCreateFlagsKHR = VkVideoSessionCreateFlagsKHR(1 << 2);
/// `1 << 3`  
pub const VK_VIDEO_SESSION_CREATE_ALLOW_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR: VkVideoSessionCreateFlagsKHR = VkVideoSessionCreateFlagsKHR(1 << 3);
/// `1 << 4`  
pub const VK_VIDEO_SESSION_CREATE_ALLOW_ENCODE_EMPHASIS_MAP_BIT_KHR: VkVideoSessionCreateFlagsKHR = VkVideoSessionCreateFlagsKHR(1 << 4);
/// `1 << 5`  
pub const VK_VIDEO_SESSION_CREATE_INLINE_SESSION_PARAMETERS_BIT_KHR: VkVideoSessionCreateFlagsKHR = VkVideoSessionCreateFlagsKHR(1 << 5);

impl_flags_display!(VkVideoSessionCreateFlagsKHR { VK_VIDEO_SESSION_CREATE_PROTECTED_CONTENT_BIT_KHR, VK_VIDEO_SESSION_CREATE_ALLOW_ENCODE_PARAMETER_OPTIMIZATIONS_BIT_KHR, VK_VIDEO_SESSION_CREATE_INLINE_QUERIES_BIT_KHR, VK_VIDEO_SESSION_CREATE_ALLOW_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR, VK_VIDEO_SESSION_CREATE_ALLOW_ENCODE_EMPHASIS_MAP_BIT_KHR, VK_VIDEO_SESSION_CREATE_INLINE_SESSION_PARAMETERS_BIT_KHR });

/// `VkVideoSessionCreateInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVideoSessionCreateInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub queueFamilyIndex: uint32_t,
    pub flags: VkVideoSessionCreateFlagsKHR,
    pub pVideoProfile: *const VkVideoProfileInfoKHR,
    pub pictureFormat: VkFormat,
    pub maxCodedExtent: VkExtent2D,
    pub referencePictureFormat: VkFormat,
    pub maxDpbSlots: uint32_t,
    pub maxActiveReferencePictures: uint32_t,
    pub pStdHeaderVersion: *const VkExtensionProperties,
}
impl_default_zeroed_with_s_type!(VkVideoSessionCreateInfoKHR : VK_STRUCTURE_TYPE_VIDEO_SESSION_CREATE_INFO_KHR);

/// `VkVideoSessionKHR` : `VkDevice`
#[repr(transparent)]
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkVideoSessionKHR(pub u64);
from_into_transparent!(VkVideoSessionKHR: u64);
impl_handle!(VkVideoSessionKHR: VK_OBJECT_TYPE_VIDEO_SESSION_KHR; SubHandle = VkDevice);

/// `VkVideoSessionMemoryRequirementsKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVideoSessionMemoryRequirementsKHR {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub memoryBindIndex: uint32_t,
    pub memoryRequirements: VkMemoryRequirements,
}
impl_default_zeroed_with_s_type!(VkVideoSessionMemoryRequirementsKHR : VK_STRUCTURE_TYPE_VIDEO_SESSION_MEMORY_REQUIREMENTS_KHR);

flags!(VkVideoSessionParametersCreateFlagsKHR);
from_into_transparent!(VkVideoSessionParametersCreateFlagsKHR: i32);
/// `VkVideoSessionParametersCreateFlagsKHR`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkVideoSessionParametersCreateFlagsKHR(pub i32);

/// `1 << 0`  
pub const VK_VIDEO_SESSION_PARAMETERS_CREATE_QUANTIZATION_MAP_COMPATIBLE_BIT_KHR: VkVideoSessionParametersCreateFlagsKHR = VkVideoSessionParametersCreateFlagsKHR(1 << 0);

impl_flags_display!(VkVideoSessionParametersCreateFlagsKHR { VK_VIDEO_SESSION_PARAMETERS_CREATE_QUANTIZATION_MAP_COMPATIBLE_BIT_KHR });

/// `VkVideoSessionParametersCreateInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVideoSessionParametersCreateInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub flags: VkVideoSessionParametersCreateFlagsKHR,
    pub videoSessionParametersTemplate: VkVideoSessionParametersKHR,
    pub videoSession: VkVideoSessionKHR,
}
impl_default_zeroed_with_s_type!(VkVideoSessionParametersCreateInfoKHR : VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR);

/// `VkVideoSessionParametersKHR` : `VkDevice`
#[repr(transparent)]
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkVideoSessionParametersKHR(pub u64);
from_into_transparent!(VkVideoSessionParametersKHR: u64);
impl_handle!(VkVideoSessionParametersKHR: VK_OBJECT_TYPE_VIDEO_SESSION_PARAMETERS_KHR; SubHandle = VkDevice);

/// `VkVideoSessionParametersUpdateInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkVideoSessionParametersUpdateInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub updateSequenceCount: uint32_t,
}
impl_default_zeroed_with_s_type!(VkVideoSessionParametersUpdateInfoKHR : VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR);

/// `VkViewport`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkViewport {
    pub x: float,
    pub y: float,
    pub width: float,
    pub height: float,
    pub minDepth: float,
    pub maxDepth: float,
}
impl_default_zeroed!(VkViewport);

from_into_transparent!(VkViewportCoordinateSwizzleNV: i32);
/// `VkViewportCoordinateSwizzleNV`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkViewportCoordinateSwizzleNV(pub i32);

/// `0`  
pub const VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV: VkViewportCoordinateSwizzleNV = VkViewportCoordinateSwizzleNV(0);
/// `1`  
pub const VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_X_NV: VkViewportCoordinateSwizzleNV = VkViewportCoordinateSwizzleNV(1);
/// `2`  
pub const VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Y_NV: VkViewportCoordinateSwizzleNV = VkViewportCoordinateSwizzleNV(2);
/// `3`  
pub const VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Y_NV: VkViewportCoordinateSwizzleNV = VkViewportCoordinateSwizzleNV(3);
/// `4`  
pub const VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Z_NV: VkViewportCoordinateSwizzleNV = VkViewportCoordinateSwizzleNV(4);
/// `5`  
pub const VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Z_NV: VkViewportCoordinateSwizzleNV = VkViewportCoordinateSwizzleNV(5);
/// `6`  
pub const VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_W_NV: VkViewportCoordinateSwizzleNV = VkViewportCoordinateSwizzleNV(6);
/// `7`  
pub const VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV: VkViewportCoordinateSwizzleNV = VkViewportCoordinateSwizzleNV(7);

impl_enum_display!(VkViewportCoordinateSwizzleNV { VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV, VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_X_NV, VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Y_NV, VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Y_NV, VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Z_NV, VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Z_NV, VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_W_NV, VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV });

/// `VkViewportSwizzleNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkViewportSwizzleNV {
    pub x: VkViewportCoordinateSwizzleNV,
    pub y: VkViewportCoordinateSwizzleNV,
    pub z: VkViewportCoordinateSwizzleNV,
    pub w: VkViewportCoordinateSwizzleNV,
}
impl_default_zeroed!(VkViewportSwizzleNV);

/// `VkViewportWScalingNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkViewportWScalingNV {
    pub xcoeff: float,
    pub ycoeff: float,
}
impl_default_zeroed!(VkViewportWScalingNV);

flags!(VkWaylandSurfaceCreateFlagsKHR);
from_into_transparent!(VkWaylandSurfaceCreateFlagsKHR: i32);
/// `VkWaylandSurfaceCreateFlagsKHR`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkWaylandSurfaceCreateFlagsKHR(pub i32);

/// `1 << 0`  
pub const VK_WAYLAND_SURFACE_CREATE_DISABLE_COLOR_MANAGEMENT: VkWaylandSurfaceCreateFlagsKHR = VkWaylandSurfaceCreateFlagsKHR(1 << 0);

impl_flags_display!(VkWaylandSurfaceCreateFlagsKHR { VK_WAYLAND_SURFACE_CREATE_DISABLE_COLOR_MANAGEMENT });

/// `VkWaylandSurfaceCreateInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkWaylandSurfaceCreateInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub flags: VkWaylandSurfaceCreateFlagsKHR,
    pub display: *mut wl_display,
    pub surface: *mut wl_surface,
}
impl_default_zeroed_with_s_type!(VkWaylandSurfaceCreateInfoKHR : VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR);

/// `VkWin32KeyedMutexAcquireReleaseInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkWin32KeyedMutexAcquireReleaseInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub acquireCount: uint32_t,
    pub pAcquireSyncs: *const VkDeviceMemory,
    pub pAcquireKeys: *const uint64_t,
    pub pAcquireTimeouts: *const uint32_t,
    pub releaseCount: uint32_t,
    pub pReleaseSyncs: *const VkDeviceMemory,
    pub pReleaseKeys: *const uint64_t,
}
impl_default_zeroed_with_s_type!(VkWin32KeyedMutexAcquireReleaseInfoKHR : VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR);
impl_extends!(VkWin32KeyedMutexAcquireReleaseInfoKHR : VkSubmitInfo, VkSubmitInfo2);

/// `VkWin32KeyedMutexAcquireReleaseInfoNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkWin32KeyedMutexAcquireReleaseInfoNV {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub acquireCount: uint32_t,
    pub pAcquireSyncs: *const VkDeviceMemory,
    pub pAcquireKeys: *const uint64_t,
    pub pAcquireTimeoutMilliseconds: *const uint32_t,
    pub releaseCount: uint32_t,
    pub pReleaseSyncs: *const VkDeviceMemory,
    pub pReleaseKeys: *const uint64_t,
}
impl_default_zeroed_with_s_type!(VkWin32KeyedMutexAcquireReleaseInfoNV : VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV);
impl_extends!(VkWin32KeyedMutexAcquireReleaseInfoNV : VkSubmitInfo, VkSubmitInfo2);

flags!(VkWin32SurfaceCreateFlagsKHR);
from_into_transparent!(VkWin32SurfaceCreateFlagsKHR: i32);
/// `VkWin32SurfaceCreateFlagsKHR`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkWin32SurfaceCreateFlagsKHR(pub i32);

impl_flags_display!(VkWin32SurfaceCreateFlagsKHR {  });

/// `VkWin32SurfaceCreateInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkWin32SurfaceCreateInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub flags: VkWin32SurfaceCreateFlagsKHR,
    pub hinstance: HINSTANCE,
    pub hwnd: HWND,
}
impl_default_zeroed_with_s_type!(VkWin32SurfaceCreateInfoKHR : VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR);

/// `VkWriteDescriptorSet`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkWriteDescriptorSet {
    pub sType: VkStructureType,
    pub pNext: *const void,
    /// Destination descriptor set
    pub dstSet: VkDescriptorSet,
    /// Binding within the destination descriptor set to write
    pub dstBinding: uint32_t,
    /// Array element within the destination binding to write
    pub dstArrayElement: uint32_t,
    /// Number of descriptors to write (determines the size of the array pointed by pDescriptors)
    pub descriptorCount: uint32_t,
    /// Descriptor type to write (determines which members of the array pointed by pDescriptors are going to be used)
    pub descriptorType: VkDescriptorType,
    /// Sampler, image view, and layout for SAMPLER, COMBINED_IMAGE_SAMPLER, {SAMPLED,STORAGE}_IMAGE, and INPUT_ATTACHMENT descriptor types.
    pub pImageInfo: *const VkDescriptorImageInfo,
    /// Raw buffer, size, and offset for {UNIFORM,STORAGE}_BUFFER[_DYNAMIC] descriptor types.
    pub pBufferInfo: *const VkDescriptorBufferInfo,
    /// Buffer view to write to the descriptor for {UNIFORM,STORAGE}_TEXEL_BUFFER descriptor types.
    pub pTexelBufferView: *const VkBufferView,
}
impl_default_zeroed_with_s_type!(VkWriteDescriptorSet : VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET);

/// `VkWriteDescriptorSetAccelerationStructureKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkWriteDescriptorSetAccelerationStructureKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub accelerationStructureCount: uint32_t,
    pub pAccelerationStructures: *const VkAccelerationStructureKHR,
}
impl_default_zeroed_with_s_type!(VkWriteDescriptorSetAccelerationStructureKHR : VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR);
impl_extends!(VkWriteDescriptorSetAccelerationStructureKHR : VkWriteDescriptorSet);

/// `VkWriteDescriptorSetAccelerationStructureNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkWriteDescriptorSetAccelerationStructureNV {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub accelerationStructureCount: uint32_t,
    pub pAccelerationStructures: *const VkAccelerationStructureNV,
}
impl_default_zeroed_with_s_type!(VkWriteDescriptorSetAccelerationStructureNV : VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV);
impl_extends!(VkWriteDescriptorSetAccelerationStructureNV : VkWriteDescriptorSet);

/// `VkWriteDescriptorSetInlineUniformBlock`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkWriteDescriptorSetInlineUniformBlock {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub dataSize: uint32_t,
    pub pData: *const void,
}
impl_default_zeroed_with_s_type!(VkWriteDescriptorSetInlineUniformBlock : VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK);
impl_extends!(VkWriteDescriptorSetInlineUniformBlock : VkWriteDescriptorSet);

/// `VkWriteDescriptorSetInlineUniformBlock`
pub type VkWriteDescriptorSetInlineUniformBlockEXT = VkWriteDescriptorSetInlineUniformBlock;

/// `VkWriteDescriptorSetPartitionedAccelerationStructureNV`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkWriteDescriptorSetPartitionedAccelerationStructureNV {
    pub sType: VkStructureType,
    pub pNext: *mut void,
    pub accelerationStructureCount: uint32_t,
    pub pAccelerationStructures: *const VkDeviceAddress,
}
impl_default_zeroed_with_s_type!(VkWriteDescriptorSetPartitionedAccelerationStructureNV : VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_PARTITIONED_ACCELERATION_STRUCTURE_NV);
impl_extends!(VkWriteDescriptorSetPartitionedAccelerationStructureNV : VkWriteDescriptorSet);

/// `VkWriteDescriptorSetTensorARM`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkWriteDescriptorSetTensorARM {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub tensorViewCount: uint32_t,
    pub pTensorViews: *const VkTensorViewARM,
}
impl_default_zeroed_with_s_type!(VkWriteDescriptorSetTensorARM : VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_TENSOR_ARM);
impl_extends!(VkWriteDescriptorSetTensorARM : VkWriteDescriptorSet);

/// `VkWriteIndirectExecutionSetPipelineEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkWriteIndirectExecutionSetPipelineEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub index: uint32_t,
    pub pipeline: VkPipeline,
}
impl_default_zeroed_with_s_type!(VkWriteIndirectExecutionSetPipelineEXT : VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_PIPELINE_EXT);

/// `VkWriteIndirectExecutionSetShaderEXT`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkWriteIndirectExecutionSetShaderEXT {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub index: uint32_t,
    pub shader: VkShaderEXT,
}
impl_default_zeroed_with_s_type!(VkWriteIndirectExecutionSetShaderEXT : VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_SHADER_EXT);

/// `VkXYColorEXT`
/// 
/// Chromaticity coordinate
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkXYColorEXT {
    pub x: float,
    pub y: float,
}
impl_default_zeroed!(VkXYColorEXT);

flags!(VkXcbSurfaceCreateFlagsKHR);
from_into_transparent!(VkXcbSurfaceCreateFlagsKHR: i32);
/// `VkXcbSurfaceCreateFlagsKHR`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkXcbSurfaceCreateFlagsKHR(pub i32);

impl_flags_display!(VkXcbSurfaceCreateFlagsKHR {  });

/// `VkXcbSurfaceCreateInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkXcbSurfaceCreateInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub flags: VkXcbSurfaceCreateFlagsKHR,
    pub connection: *mut xcb_connection_t,
    pub window: xcb_window_t,
}
impl_default_zeroed_with_s_type!(VkXcbSurfaceCreateInfoKHR : VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR);

flags!(VkXlibSurfaceCreateFlagsKHR);
from_into_transparent!(VkXlibSurfaceCreateFlagsKHR: i32);
/// `VkXlibSurfaceCreateFlagsKHR`
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct VkXlibSurfaceCreateFlagsKHR(pub i32);

impl_flags_display!(VkXlibSurfaceCreateFlagsKHR {  });

/// `VkXlibSurfaceCreateInfoKHR`
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct VkXlibSurfaceCreateInfoKHR {
    pub sType: VkStructureType,
    pub pNext: *const void,
    pub flags: VkXlibSurfaceCreateFlagsKHR,
    pub dpy: *mut Display,
    pub window: Window,
}
impl_default_zeroed_with_s_type!(VkXlibSurfaceCreateInfoKHR : VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR);

/// `vkAcquireDrmDisplayEXT`
pub type PFN_vkAcquireDrmDisplayEXT = Option<FN_vkAcquireDrmDisplayEXT>;

/// `vkAcquireDrmDisplayEXT`
pub type FN_vkAcquireDrmDisplayEXT = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, drmFd: int32_t, display: VkDisplayKHR) -> VkResult;


/// `vkAcquireFullScreenExclusiveModeEXT`
pub type PFN_vkAcquireFullScreenExclusiveModeEXT = Option<FN_vkAcquireFullScreenExclusiveModeEXT>;

/// `vkAcquireFullScreenExclusiveModeEXT`
pub type FN_vkAcquireFullScreenExclusiveModeEXT = unsafe extern "system" fn(device: VkDevice, swapchain: VkSwapchainKHR) -> VkResult;


/// `vkAcquireImageANDROID`
pub type PFN_vkAcquireImageANDROID = Option<FN_vkAcquireImageANDROID>;

/// `vkAcquireImageANDROID`
pub type FN_vkAcquireImageANDROID = unsafe extern "system" fn(device: VkDevice, image: VkImage, nativeFenceFd: int, semaphore: VkSemaphore, fence: VkFence) -> VkResult;


/// `vkAcquireImageOHOS`
pub type PFN_vkAcquireImageOHOS = Option<FN_vkAcquireImageOHOS>;

/// `vkAcquireImageOHOS`
pub type FN_vkAcquireImageOHOS = unsafe extern "system" fn(device: VkDevice, image: VkImage, nativeFenceFd: int32_t, semaphore: VkSemaphore, fence: VkFence) -> VkResult;


/// `vkAcquireNextImage2KHR`
pub type PFN_vkAcquireNextImage2KHR = Option<FN_vkAcquireNextImage2KHR>;

/// `vkAcquireNextImage2KHR`
pub type FN_vkAcquireNextImage2KHR = unsafe extern "system" fn(device: VkDevice, pAcquireInfo: *const VkAcquireNextImageInfoKHR, pImageIndex: *mut uint32_t) -> VkResult;


/// `vkAcquireNextImageKHR`
pub type PFN_vkAcquireNextImageKHR = Option<FN_vkAcquireNextImageKHR>;

/// `vkAcquireNextImageKHR`
pub type FN_vkAcquireNextImageKHR = unsafe extern "system" fn(device: VkDevice, swapchain: VkSwapchainKHR, timeout: uint64_t, semaphore: VkSemaphore, fence: VkFence, pImageIndex: *mut uint32_t) -> VkResult;


/// `vkAcquirePerformanceConfigurationINTEL`
pub type PFN_vkAcquirePerformanceConfigurationINTEL = Option<FN_vkAcquirePerformanceConfigurationINTEL>;

/// `vkAcquirePerformanceConfigurationINTEL`
pub type FN_vkAcquirePerformanceConfigurationINTEL = unsafe extern "system" fn(device: VkDevice, pAcquireInfo: *const VkPerformanceConfigurationAcquireInfoINTEL, pConfiguration: *mut VkPerformanceConfigurationINTEL) -> VkResult;


/// `vkAcquireProfilingLockKHR`
pub type PFN_vkAcquireProfilingLockKHR = Option<FN_vkAcquireProfilingLockKHR>;

/// `vkAcquireProfilingLockKHR`
pub type FN_vkAcquireProfilingLockKHR = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkAcquireProfilingLockInfoKHR) -> VkResult;


/// `vkAcquireWinrtDisplayNV`
pub type PFN_vkAcquireWinrtDisplayNV = Option<FN_vkAcquireWinrtDisplayNV>;

/// `vkAcquireWinrtDisplayNV`
pub type FN_vkAcquireWinrtDisplayNV = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, display: VkDisplayKHR) -> VkResult;


/// `vkAcquireXlibDisplayEXT`
pub type PFN_vkAcquireXlibDisplayEXT = Option<FN_vkAcquireXlibDisplayEXT>;

/// `vkAcquireXlibDisplayEXT`
pub type FN_vkAcquireXlibDisplayEXT = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, dpy: *mut Display, display: VkDisplayKHR) -> VkResult;


/// `vkAllocateCommandBuffers`
pub type PFN_vkAllocateCommandBuffers = Option<FN_vkAllocateCommandBuffers>;

/// `vkAllocateCommandBuffers`
pub type FN_vkAllocateCommandBuffers = unsafe extern "system" fn(device: VkDevice, pAllocateInfo: *const VkCommandBufferAllocateInfo, pCommandBuffers: *mut VkCommandBuffer) -> VkResult;


/// `vkAllocateDescriptorSets`
pub type PFN_vkAllocateDescriptorSets = Option<FN_vkAllocateDescriptorSets>;

/// `vkAllocateDescriptorSets`
pub type FN_vkAllocateDescriptorSets = unsafe extern "system" fn(device: VkDevice, pAllocateInfo: *const VkDescriptorSetAllocateInfo, pDescriptorSets: *mut VkDescriptorSet) -> VkResult;


/// `vkAllocateMemory`
pub type PFN_vkAllocateMemory = Option<FN_vkAllocateMemory>;

/// `vkAllocateMemory`
pub type FN_vkAllocateMemory = unsafe extern "system" fn(device: VkDevice, pAllocateInfo: *const VkMemoryAllocateInfo, pAllocator: *const VkAllocationCallbacks, pMemory: *mut VkDeviceMemory) -> VkResult;


/// `vkAntiLagUpdateAMD`
pub type PFN_vkAntiLagUpdateAMD = Option<FN_vkAntiLagUpdateAMD>;

/// `vkAntiLagUpdateAMD`
pub type FN_vkAntiLagUpdateAMD = unsafe extern "system" fn(device: VkDevice, pData: *const VkAntiLagDataAMD) -> ();


/// `vkBeginCommandBuffer`
pub type PFN_vkBeginCommandBuffer = Option<FN_vkBeginCommandBuffer>;

/// `vkBeginCommandBuffer`
pub type FN_vkBeginCommandBuffer = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pBeginInfo: *const VkCommandBufferBeginInfo) -> VkResult;


/// `vkBindAccelerationStructureMemoryNV`
pub type PFN_vkBindAccelerationStructureMemoryNV = Option<FN_vkBindAccelerationStructureMemoryNV>;

/// `vkBindAccelerationStructureMemoryNV`
pub type FN_vkBindAccelerationStructureMemoryNV = unsafe extern "system" fn(device: VkDevice, bindInfoCount: uint32_t, pBindInfos: *const VkBindAccelerationStructureMemoryInfoNV) -> VkResult;


/// `vkBindBufferMemory`
pub type PFN_vkBindBufferMemory = Option<FN_vkBindBufferMemory>;

/// `vkBindBufferMemory`
pub type FN_vkBindBufferMemory = unsafe extern "system" fn(device: VkDevice, buffer: VkBuffer, memory: VkDeviceMemory, memoryOffset: VkDeviceSize) -> VkResult;


/// `vkBindBufferMemory2`
pub type PFN_vkBindBufferMemory2 = Option<FN_vkBindBufferMemory2>;

/// `vkBindBufferMemory2`
pub type FN_vkBindBufferMemory2 = unsafe extern "system" fn(device: VkDevice, bindInfoCount: uint32_t, pBindInfos: *const VkBindBufferMemoryInfo) -> VkResult;


/// `vkBindBufferMemory2KHR` = `vkBindBufferMemory2`
pub type PFN_vkBindBufferMemory2KHR = PFN_vkBindBufferMemory2;

/// `vkBindBufferMemory2KHR` = `vkBindBufferMemory2`
pub type FN_vkBindBufferMemory2KHR = FN_vkBindBufferMemory2;

/// `vkBindDataGraphPipelineSessionMemoryARM`
pub type PFN_vkBindDataGraphPipelineSessionMemoryARM = Option<FN_vkBindDataGraphPipelineSessionMemoryARM>;

/// `vkBindDataGraphPipelineSessionMemoryARM`
pub type FN_vkBindDataGraphPipelineSessionMemoryARM = unsafe extern "system" fn(device: VkDevice, bindInfoCount: uint32_t, pBindInfos: *const VkBindDataGraphPipelineSessionMemoryInfoARM) -> VkResult;


/// `vkBindImageMemory`
pub type PFN_vkBindImageMemory = Option<FN_vkBindImageMemory>;

/// `vkBindImageMemory`
pub type FN_vkBindImageMemory = unsafe extern "system" fn(device: VkDevice, image: VkImage, memory: VkDeviceMemory, memoryOffset: VkDeviceSize) -> VkResult;


/// `vkBindImageMemory2`
pub type PFN_vkBindImageMemory2 = Option<FN_vkBindImageMemory2>;

/// `vkBindImageMemory2`
pub type FN_vkBindImageMemory2 = unsafe extern "system" fn(device: VkDevice, bindInfoCount: uint32_t, pBindInfos: *const VkBindImageMemoryInfo) -> VkResult;


/// `vkBindImageMemory2KHR` = `vkBindImageMemory2`
pub type PFN_vkBindImageMemory2KHR = PFN_vkBindImageMemory2;

/// `vkBindImageMemory2KHR` = `vkBindImageMemory2`
pub type FN_vkBindImageMemory2KHR = FN_vkBindImageMemory2;

/// `vkBindOpticalFlowSessionImageNV`
pub type PFN_vkBindOpticalFlowSessionImageNV = Option<FN_vkBindOpticalFlowSessionImageNV>;

/// `vkBindOpticalFlowSessionImageNV`
pub type FN_vkBindOpticalFlowSessionImageNV = unsafe extern "system" fn(device: VkDevice, session: VkOpticalFlowSessionNV, bindingPoint: VkOpticalFlowSessionBindingPointNV, view: VkImageView, layout: VkImageLayout) -> VkResult;


/// `vkBindTensorMemoryARM`
pub type PFN_vkBindTensorMemoryARM = Option<FN_vkBindTensorMemoryARM>;

/// `vkBindTensorMemoryARM`
pub type FN_vkBindTensorMemoryARM = unsafe extern "system" fn(device: VkDevice, bindInfoCount: uint32_t, pBindInfos: *const VkBindTensorMemoryInfoARM) -> VkResult;


/// `vkBindVideoSessionMemoryKHR`
pub type PFN_vkBindVideoSessionMemoryKHR = Option<FN_vkBindVideoSessionMemoryKHR>;

/// `vkBindVideoSessionMemoryKHR`
pub type FN_vkBindVideoSessionMemoryKHR = unsafe extern "system" fn(device: VkDevice, videoSession: VkVideoSessionKHR, bindSessionMemoryInfoCount: uint32_t, pBindSessionMemoryInfos: *const VkBindVideoSessionMemoryInfoKHR) -> VkResult;


/// `vkBuildAccelerationStructuresKHR`
pub type PFN_vkBuildAccelerationStructuresKHR = Option<FN_vkBuildAccelerationStructuresKHR>;

/// `vkBuildAccelerationStructuresKHR`
pub type FN_vkBuildAccelerationStructuresKHR = unsafe extern "system" fn(device: VkDevice, deferredOperation: VkDeferredOperationKHR, infoCount: uint32_t, pInfos: *const VkAccelerationStructureBuildGeometryInfoKHR, ppBuildRangeInfos: *const *const VkAccelerationStructureBuildRangeInfoKHR) -> VkResult;


/// `vkBuildMicromapsEXT`
pub type PFN_vkBuildMicromapsEXT = Option<FN_vkBuildMicromapsEXT>;

/// `vkBuildMicromapsEXT`
pub type FN_vkBuildMicromapsEXT = unsafe extern "system" fn(device: VkDevice, deferredOperation: VkDeferredOperationKHR, infoCount: uint32_t, pInfos: *const VkMicromapBuildInfoEXT) -> VkResult;


/// `vkClearShaderInstrumentationMetricsARM`
pub type PFN_vkClearShaderInstrumentationMetricsARM = Option<FN_vkClearShaderInstrumentationMetricsARM>;

/// `vkClearShaderInstrumentationMetricsARM`
pub type FN_vkClearShaderInstrumentationMetricsARM = unsafe extern "system" fn(device: VkDevice, instrumentation: VkShaderInstrumentationARM) -> ();


/// `vkCmdBeginConditionalRenderingEXT`
pub type PFN_vkCmdBeginConditionalRenderingEXT = Option<FN_vkCmdBeginConditionalRenderingEXT>;

/// `vkCmdBeginConditionalRenderingEXT`
pub type FN_vkCmdBeginConditionalRenderingEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pConditionalRenderingBegin: *const VkConditionalRenderingBeginInfoEXT) -> ();


/// `vkCmdBeginCustomResolveEXT`
pub type PFN_vkCmdBeginCustomResolveEXT = Option<FN_vkCmdBeginCustomResolveEXT>;

/// `vkCmdBeginCustomResolveEXT`
pub type FN_vkCmdBeginCustomResolveEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pBeginCustomResolveInfo: *const VkBeginCustomResolveInfoEXT) -> ();


/// `vkCmdBeginDebugUtilsLabelEXT`
pub type PFN_vkCmdBeginDebugUtilsLabelEXT = Option<FN_vkCmdBeginDebugUtilsLabelEXT>;

/// `vkCmdBeginDebugUtilsLabelEXT`
pub type FN_vkCmdBeginDebugUtilsLabelEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pLabelInfo: *const VkDebugUtilsLabelEXT) -> ();


/// `vkCmdBeginPerTileExecutionQCOM`
pub type PFN_vkCmdBeginPerTileExecutionQCOM = Option<FN_vkCmdBeginPerTileExecutionQCOM>;

/// `vkCmdBeginPerTileExecutionQCOM`
pub type FN_vkCmdBeginPerTileExecutionQCOM = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pPerTileBeginInfo: *const VkPerTileBeginInfoQCOM) -> ();


/// `vkCmdBeginQuery`
pub type PFN_vkCmdBeginQuery = Option<FN_vkCmdBeginQuery>;

/// `vkCmdBeginQuery`
pub type FN_vkCmdBeginQuery = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, query: uint32_t, flags: VkQueryControlFlags) -> ();


/// `vkCmdBeginQueryIndexedEXT`
pub type PFN_vkCmdBeginQueryIndexedEXT = Option<FN_vkCmdBeginQueryIndexedEXT>;

/// `vkCmdBeginQueryIndexedEXT`
pub type FN_vkCmdBeginQueryIndexedEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, query: uint32_t, flags: VkQueryControlFlags, index: uint32_t) -> ();


/// `vkCmdBeginRendering`
pub type PFN_vkCmdBeginRendering = Option<FN_vkCmdBeginRendering>;

/// `vkCmdBeginRendering`
pub type FN_vkCmdBeginRendering = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pRenderingInfo: *const VkRenderingInfo) -> ();


/// `vkCmdBeginRenderingKHR` = `vkCmdBeginRendering`
pub type PFN_vkCmdBeginRenderingKHR = PFN_vkCmdBeginRendering;

/// `vkCmdBeginRenderingKHR` = `vkCmdBeginRendering`
pub type FN_vkCmdBeginRenderingKHR = FN_vkCmdBeginRendering;

/// `vkCmdBeginRenderPass`
pub type PFN_vkCmdBeginRenderPass = Option<FN_vkCmdBeginRenderPass>;

/// `vkCmdBeginRenderPass`
pub type FN_vkCmdBeginRenderPass = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pRenderPassBegin: *const VkRenderPassBeginInfo, contents: VkSubpassContents) -> ();


/// `vkCmdBeginRenderPass2`
pub type PFN_vkCmdBeginRenderPass2 = Option<FN_vkCmdBeginRenderPass2>;

/// `vkCmdBeginRenderPass2`
pub type FN_vkCmdBeginRenderPass2 = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pRenderPassBegin: *const VkRenderPassBeginInfo, pSubpassBeginInfo: *const VkSubpassBeginInfo) -> ();


/// `vkCmdBeginRenderPass2KHR` = `vkCmdBeginRenderPass2`
pub type PFN_vkCmdBeginRenderPass2KHR = PFN_vkCmdBeginRenderPass2;

/// `vkCmdBeginRenderPass2KHR` = `vkCmdBeginRenderPass2`
pub type FN_vkCmdBeginRenderPass2KHR = FN_vkCmdBeginRenderPass2;

/// `vkCmdBeginShaderInstrumentationARM`
pub type PFN_vkCmdBeginShaderInstrumentationARM = Option<FN_vkCmdBeginShaderInstrumentationARM>;

/// `vkCmdBeginShaderInstrumentationARM`
pub type FN_vkCmdBeginShaderInstrumentationARM = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, instrumentation: VkShaderInstrumentationARM) -> ();


/// `vkCmdBeginTransformFeedbackEXT`
pub type PFN_vkCmdBeginTransformFeedbackEXT = Option<FN_vkCmdBeginTransformFeedbackEXT>;

/// `vkCmdBeginTransformFeedbackEXT`
pub type FN_vkCmdBeginTransformFeedbackEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, firstCounterBuffer: uint32_t, counterBufferCount: uint32_t, pCounterBuffers: *const VkBuffer, pCounterBufferOffsets: *const VkDeviceSize) -> ();


/// `vkCmdBeginVideoCodingKHR`
pub type PFN_vkCmdBeginVideoCodingKHR = Option<FN_vkCmdBeginVideoCodingKHR>;

/// `vkCmdBeginVideoCodingKHR`
pub type FN_vkCmdBeginVideoCodingKHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pBeginInfo: *const VkVideoBeginCodingInfoKHR) -> ();


/// `vkCmdBindDescriptorBufferEmbeddedSamplers2EXT`
pub type PFN_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT = Option<FN_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT>;

/// `vkCmdBindDescriptorBufferEmbeddedSamplers2EXT`
pub type FN_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pBindDescriptorBufferEmbeddedSamplersInfo: *const VkBindDescriptorBufferEmbeddedSamplersInfoEXT) -> ();


/// `vkCmdBindDescriptorBufferEmbeddedSamplersEXT`
pub type PFN_vkCmdBindDescriptorBufferEmbeddedSamplersEXT = Option<FN_vkCmdBindDescriptorBufferEmbeddedSamplersEXT>;

/// `vkCmdBindDescriptorBufferEmbeddedSamplersEXT`
pub type FN_vkCmdBindDescriptorBufferEmbeddedSamplersEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, layout: VkPipelineLayout, set: uint32_t) -> ();


/// `vkCmdBindDescriptorBuffersEXT`
pub type PFN_vkCmdBindDescriptorBuffersEXT = Option<FN_vkCmdBindDescriptorBuffersEXT>;

/// `vkCmdBindDescriptorBuffersEXT`
pub type FN_vkCmdBindDescriptorBuffersEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, bufferCount: uint32_t, pBindingInfos: *const VkDescriptorBufferBindingInfoEXT) -> ();


/// `vkCmdBindDescriptorSets`
pub type PFN_vkCmdBindDescriptorSets = Option<FN_vkCmdBindDescriptorSets>;

/// `vkCmdBindDescriptorSets`
pub type FN_vkCmdBindDescriptorSets = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, layout: VkPipelineLayout, firstSet: uint32_t, descriptorSetCount: uint32_t, pDescriptorSets: *const VkDescriptorSet, dynamicOffsetCount: uint32_t, pDynamicOffsets: *const uint32_t) -> ();


/// `vkCmdBindDescriptorSets2`
pub type PFN_vkCmdBindDescriptorSets2 = Option<FN_vkCmdBindDescriptorSets2>;

/// `vkCmdBindDescriptorSets2`
pub type FN_vkCmdBindDescriptorSets2 = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pBindDescriptorSetsInfo: *const VkBindDescriptorSetsInfo) -> ();


/// `vkCmdBindDescriptorSets2KHR` = `vkCmdBindDescriptorSets2`
pub type PFN_vkCmdBindDescriptorSets2KHR = PFN_vkCmdBindDescriptorSets2;

/// `vkCmdBindDescriptorSets2KHR` = `vkCmdBindDescriptorSets2`
pub type FN_vkCmdBindDescriptorSets2KHR = FN_vkCmdBindDescriptorSets2;

/// `vkCmdBindIndexBuffer`
pub type PFN_vkCmdBindIndexBuffer = Option<FN_vkCmdBindIndexBuffer>;

/// `vkCmdBindIndexBuffer`
pub type FN_vkCmdBindIndexBuffer = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, indexType: VkIndexType) -> ();


/// `vkCmdBindIndexBuffer2`
pub type PFN_vkCmdBindIndexBuffer2 = Option<FN_vkCmdBindIndexBuffer2>;

/// `vkCmdBindIndexBuffer2`
pub type FN_vkCmdBindIndexBuffer2 = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, size: VkDeviceSize, indexType: VkIndexType) -> ();


/// `vkCmdBindIndexBuffer2KHR` = `vkCmdBindIndexBuffer2`
pub type PFN_vkCmdBindIndexBuffer2KHR = PFN_vkCmdBindIndexBuffer2;

/// `vkCmdBindIndexBuffer2KHR` = `vkCmdBindIndexBuffer2`
pub type FN_vkCmdBindIndexBuffer2KHR = FN_vkCmdBindIndexBuffer2;

/// `vkCmdBindInvocationMaskHUAWEI`
pub type PFN_vkCmdBindInvocationMaskHUAWEI = Option<FN_vkCmdBindInvocationMaskHUAWEI>;

/// `vkCmdBindInvocationMaskHUAWEI`
pub type FN_vkCmdBindInvocationMaskHUAWEI = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, imageView: VkImageView, imageLayout: VkImageLayout) -> ();


/// `vkCmdBindPipeline`
pub type PFN_vkCmdBindPipeline = Option<FN_vkCmdBindPipeline>;

/// `vkCmdBindPipeline`
pub type FN_vkCmdBindPipeline = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, pipeline: VkPipeline) -> ();


/// `vkCmdBindPipelineShaderGroupNV`
pub type PFN_vkCmdBindPipelineShaderGroupNV = Option<FN_vkCmdBindPipelineShaderGroupNV>;

/// `vkCmdBindPipelineShaderGroupNV`
pub type FN_vkCmdBindPipelineShaderGroupNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, pipeline: VkPipeline, groupIndex: uint32_t) -> ();


/// `vkCmdBindResourceHeapEXT`
pub type PFN_vkCmdBindResourceHeapEXT = Option<FN_vkCmdBindResourceHeapEXT>;

/// `vkCmdBindResourceHeapEXT`
pub type FN_vkCmdBindResourceHeapEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pBindInfo: *const VkBindHeapInfoEXT) -> ();


/// `vkCmdBindSamplerHeapEXT`
pub type PFN_vkCmdBindSamplerHeapEXT = Option<FN_vkCmdBindSamplerHeapEXT>;

/// `vkCmdBindSamplerHeapEXT`
pub type FN_vkCmdBindSamplerHeapEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pBindInfo: *const VkBindHeapInfoEXT) -> ();


/// `vkCmdBindShadersEXT`
pub type PFN_vkCmdBindShadersEXT = Option<FN_vkCmdBindShadersEXT>;

/// `vkCmdBindShadersEXT`
pub type FN_vkCmdBindShadersEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, stageCount: uint32_t, pStages: *const VkShaderStageFlags, pShaders: *const VkShaderEXT) -> ();


/// `vkCmdBindShadingRateImageNV`
pub type PFN_vkCmdBindShadingRateImageNV = Option<FN_vkCmdBindShadingRateImageNV>;

/// `vkCmdBindShadingRateImageNV`
pub type FN_vkCmdBindShadingRateImageNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, imageView: VkImageView, imageLayout: VkImageLayout) -> ();


/// `vkCmdBindTileMemoryQCOM`
pub type PFN_vkCmdBindTileMemoryQCOM = Option<FN_vkCmdBindTileMemoryQCOM>;

/// `vkCmdBindTileMemoryQCOM`
pub type FN_vkCmdBindTileMemoryQCOM = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pTileMemoryBindInfo: *const VkTileMemoryBindInfoQCOM) -> ();


/// `vkCmdBindTransformFeedbackBuffersEXT`
pub type PFN_vkCmdBindTransformFeedbackBuffersEXT = Option<FN_vkCmdBindTransformFeedbackBuffersEXT>;

/// `vkCmdBindTransformFeedbackBuffersEXT`
pub type FN_vkCmdBindTransformFeedbackBuffersEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, firstBinding: uint32_t, bindingCount: uint32_t, pBuffers: *const VkBuffer, pOffsets: *const VkDeviceSize, pSizes: *const VkDeviceSize) -> ();


/// `vkCmdBindVertexBuffers`
pub type PFN_vkCmdBindVertexBuffers = Option<FN_vkCmdBindVertexBuffers>;

/// `vkCmdBindVertexBuffers`
pub type FN_vkCmdBindVertexBuffers = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, firstBinding: uint32_t, bindingCount: uint32_t, pBuffers: *const VkBuffer, pOffsets: *const VkDeviceSize) -> ();


/// `vkCmdBindVertexBuffers2`
pub type PFN_vkCmdBindVertexBuffers2 = Option<FN_vkCmdBindVertexBuffers2>;

/// `vkCmdBindVertexBuffers2`
pub type FN_vkCmdBindVertexBuffers2 = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, firstBinding: uint32_t, bindingCount: uint32_t, pBuffers: *const VkBuffer, pOffsets: *const VkDeviceSize, pSizes: *const VkDeviceSize, pStrides: *const VkDeviceSize) -> ();


/// `vkCmdBindVertexBuffers2EXT` = `vkCmdBindVertexBuffers2`
pub type PFN_vkCmdBindVertexBuffers2EXT = PFN_vkCmdBindVertexBuffers2;

/// `vkCmdBindVertexBuffers2EXT` = `vkCmdBindVertexBuffers2`
pub type FN_vkCmdBindVertexBuffers2EXT = FN_vkCmdBindVertexBuffers2;

/// `vkCmdBlitImage`
pub type PFN_vkCmdBlitImage = Option<FN_vkCmdBlitImage>;

/// `vkCmdBlitImage`
pub type FN_vkCmdBlitImage = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, srcImage: VkImage, srcImageLayout: VkImageLayout, dstImage: VkImage, dstImageLayout: VkImageLayout, regionCount: uint32_t, pRegions: *const VkImageBlit, filter: VkFilter) -> ();


/// `vkCmdBlitImage2`
pub type PFN_vkCmdBlitImage2 = Option<FN_vkCmdBlitImage2>;

/// `vkCmdBlitImage2`
pub type FN_vkCmdBlitImage2 = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pBlitImageInfo: *const VkBlitImageInfo2) -> ();


/// `vkCmdBlitImage2KHR` = `vkCmdBlitImage2`
pub type PFN_vkCmdBlitImage2KHR = PFN_vkCmdBlitImage2;

/// `vkCmdBlitImage2KHR` = `vkCmdBlitImage2`
pub type FN_vkCmdBlitImage2KHR = FN_vkCmdBlitImage2;

/// `vkCmdBuildAccelerationStructureNV`
pub type PFN_vkCmdBuildAccelerationStructureNV = Option<FN_vkCmdBuildAccelerationStructureNV>;

/// `vkCmdBuildAccelerationStructureNV`
pub type FN_vkCmdBuildAccelerationStructureNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pInfo: *const VkAccelerationStructureInfoNV, instanceData: VkBuffer, instanceOffset: VkDeviceSize, update: VkBool32, dst: VkAccelerationStructureNV, src: VkAccelerationStructureNV, scratch: VkBuffer, scratchOffset: VkDeviceSize) -> ();


/// `vkCmdBuildAccelerationStructuresIndirectKHR`
pub type PFN_vkCmdBuildAccelerationStructuresIndirectKHR = Option<FN_vkCmdBuildAccelerationStructuresIndirectKHR>;

/// `vkCmdBuildAccelerationStructuresIndirectKHR`
pub type FN_vkCmdBuildAccelerationStructuresIndirectKHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, infoCount: uint32_t, pInfos: *const VkAccelerationStructureBuildGeometryInfoKHR, pIndirectDeviceAddresses: *const VkDeviceAddress, pIndirectStrides: *const uint32_t, ppMaxPrimitiveCounts: *const *const uint32_t) -> ();


/// `vkCmdBuildAccelerationStructuresKHR`
pub type PFN_vkCmdBuildAccelerationStructuresKHR = Option<FN_vkCmdBuildAccelerationStructuresKHR>;

/// `vkCmdBuildAccelerationStructuresKHR`
pub type FN_vkCmdBuildAccelerationStructuresKHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, infoCount: uint32_t, pInfos: *const VkAccelerationStructureBuildGeometryInfoKHR, ppBuildRangeInfos: *const *const VkAccelerationStructureBuildRangeInfoKHR) -> ();


/// `vkCmdBuildClusterAccelerationStructureIndirectNV`
pub type PFN_vkCmdBuildClusterAccelerationStructureIndirectNV = Option<FN_vkCmdBuildClusterAccelerationStructureIndirectNV>;

/// `vkCmdBuildClusterAccelerationStructureIndirectNV`
pub type FN_vkCmdBuildClusterAccelerationStructureIndirectNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pCommandInfos: *const VkClusterAccelerationStructureCommandsInfoNV) -> ();


/// `vkCmdBuildMicromapsEXT`
pub type PFN_vkCmdBuildMicromapsEXT = Option<FN_vkCmdBuildMicromapsEXT>;

/// `vkCmdBuildMicromapsEXT`
pub type FN_vkCmdBuildMicromapsEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, infoCount: uint32_t, pInfos: *const VkMicromapBuildInfoEXT) -> ();


/// `vkCmdBuildPartitionedAccelerationStructuresNV`
pub type PFN_vkCmdBuildPartitionedAccelerationStructuresNV = Option<FN_vkCmdBuildPartitionedAccelerationStructuresNV>;

/// `vkCmdBuildPartitionedAccelerationStructuresNV`
pub type FN_vkCmdBuildPartitionedAccelerationStructuresNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pBuildInfo: *const VkBuildPartitionedAccelerationStructureInfoNV) -> ();


/// `vkCmdClearAttachments`
pub type PFN_vkCmdClearAttachments = Option<FN_vkCmdClearAttachments>;

/// `vkCmdClearAttachments`
pub type FN_vkCmdClearAttachments = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, attachmentCount: uint32_t, pAttachments: *const VkClearAttachment, rectCount: uint32_t, pRects: *const VkClearRect) -> ();


/// `vkCmdClearColorImage`
pub type PFN_vkCmdClearColorImage = Option<FN_vkCmdClearColorImage>;

/// `vkCmdClearColorImage`
pub type FN_vkCmdClearColorImage = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, image: VkImage, imageLayout: VkImageLayout, pColor: *const VkClearColorValue, rangeCount: uint32_t, pRanges: *const VkImageSubresourceRange) -> ();


/// `vkCmdClearDepthStencilImage`
pub type PFN_vkCmdClearDepthStencilImage = Option<FN_vkCmdClearDepthStencilImage>;

/// `vkCmdClearDepthStencilImage`
pub type FN_vkCmdClearDepthStencilImage = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, image: VkImage, imageLayout: VkImageLayout, pDepthStencil: *const VkClearDepthStencilValue, rangeCount: uint32_t, pRanges: *const VkImageSubresourceRange) -> ();


/// `vkCmdControlVideoCodingKHR`
pub type PFN_vkCmdControlVideoCodingKHR = Option<FN_vkCmdControlVideoCodingKHR>;

/// `vkCmdControlVideoCodingKHR`
pub type FN_vkCmdControlVideoCodingKHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pCodingControlInfo: *const VkVideoCodingControlInfoKHR) -> ();


/// `vkCmdConvertCooperativeVectorMatrixNV`
pub type PFN_vkCmdConvertCooperativeVectorMatrixNV = Option<FN_vkCmdConvertCooperativeVectorMatrixNV>;

/// `vkCmdConvertCooperativeVectorMatrixNV`
pub type FN_vkCmdConvertCooperativeVectorMatrixNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, infoCount: uint32_t, pInfos: *const VkConvertCooperativeVectorMatrixInfoNV) -> ();


/// `vkCmdCopyAccelerationStructureKHR`
pub type PFN_vkCmdCopyAccelerationStructureKHR = Option<FN_vkCmdCopyAccelerationStructureKHR>;

/// `vkCmdCopyAccelerationStructureKHR`
pub type FN_vkCmdCopyAccelerationStructureKHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pInfo: *const VkCopyAccelerationStructureInfoKHR) -> ();


/// `vkCmdCopyAccelerationStructureNV`
pub type PFN_vkCmdCopyAccelerationStructureNV = Option<FN_vkCmdCopyAccelerationStructureNV>;

/// `vkCmdCopyAccelerationStructureNV`
pub type FN_vkCmdCopyAccelerationStructureNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, dst: VkAccelerationStructureNV, src: VkAccelerationStructureNV, mode: VkCopyAccelerationStructureModeKHR) -> ();


/// `vkCmdCopyAccelerationStructureToMemoryKHR`
pub type PFN_vkCmdCopyAccelerationStructureToMemoryKHR = Option<FN_vkCmdCopyAccelerationStructureToMemoryKHR>;

/// `vkCmdCopyAccelerationStructureToMemoryKHR`
pub type FN_vkCmdCopyAccelerationStructureToMemoryKHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pInfo: *const VkCopyAccelerationStructureToMemoryInfoKHR) -> ();


/// `vkCmdCopyBuffer`
pub type PFN_vkCmdCopyBuffer = Option<FN_vkCmdCopyBuffer>;

/// `vkCmdCopyBuffer`
pub type FN_vkCmdCopyBuffer = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, srcBuffer: VkBuffer, dstBuffer: VkBuffer, regionCount: uint32_t, pRegions: *const VkBufferCopy) -> ();


/// `vkCmdCopyBuffer2`
pub type PFN_vkCmdCopyBuffer2 = Option<FN_vkCmdCopyBuffer2>;

/// `vkCmdCopyBuffer2`
pub type FN_vkCmdCopyBuffer2 = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pCopyBufferInfo: *const VkCopyBufferInfo2) -> ();


/// `vkCmdCopyBuffer2KHR` = `vkCmdCopyBuffer2`
pub type PFN_vkCmdCopyBuffer2KHR = PFN_vkCmdCopyBuffer2;

/// `vkCmdCopyBuffer2KHR` = `vkCmdCopyBuffer2`
pub type FN_vkCmdCopyBuffer2KHR = FN_vkCmdCopyBuffer2;

/// `vkCmdCopyBufferToImage`
pub type PFN_vkCmdCopyBufferToImage = Option<FN_vkCmdCopyBufferToImage>;

/// `vkCmdCopyBufferToImage`
pub type FN_vkCmdCopyBufferToImage = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, srcBuffer: VkBuffer, dstImage: VkImage, dstImageLayout: VkImageLayout, regionCount: uint32_t, pRegions: *const VkBufferImageCopy) -> ();


/// `vkCmdCopyBufferToImage2`
pub type PFN_vkCmdCopyBufferToImage2 = Option<FN_vkCmdCopyBufferToImage2>;

/// `vkCmdCopyBufferToImage2`
pub type FN_vkCmdCopyBufferToImage2 = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pCopyBufferToImageInfo: *const VkCopyBufferToImageInfo2) -> ();


/// `vkCmdCopyBufferToImage2KHR` = `vkCmdCopyBufferToImage2`
pub type PFN_vkCmdCopyBufferToImage2KHR = PFN_vkCmdCopyBufferToImage2;

/// `vkCmdCopyBufferToImage2KHR` = `vkCmdCopyBufferToImage2`
pub type FN_vkCmdCopyBufferToImage2KHR = FN_vkCmdCopyBufferToImage2;

/// `vkCmdCopyImage`
pub type PFN_vkCmdCopyImage = Option<FN_vkCmdCopyImage>;

/// `vkCmdCopyImage`
pub type FN_vkCmdCopyImage = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, srcImage: VkImage, srcImageLayout: VkImageLayout, dstImage: VkImage, dstImageLayout: VkImageLayout, regionCount: uint32_t, pRegions: *const VkImageCopy) -> ();


/// `vkCmdCopyImage2`
pub type PFN_vkCmdCopyImage2 = Option<FN_vkCmdCopyImage2>;

/// `vkCmdCopyImage2`
pub type FN_vkCmdCopyImage2 = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pCopyImageInfo: *const VkCopyImageInfo2) -> ();


/// `vkCmdCopyImage2KHR` = `vkCmdCopyImage2`
pub type PFN_vkCmdCopyImage2KHR = PFN_vkCmdCopyImage2;

/// `vkCmdCopyImage2KHR` = `vkCmdCopyImage2`
pub type FN_vkCmdCopyImage2KHR = FN_vkCmdCopyImage2;

/// `vkCmdCopyImageToBuffer`
pub type PFN_vkCmdCopyImageToBuffer = Option<FN_vkCmdCopyImageToBuffer>;

/// `vkCmdCopyImageToBuffer`
pub type FN_vkCmdCopyImageToBuffer = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, srcImage: VkImage, srcImageLayout: VkImageLayout, dstBuffer: VkBuffer, regionCount: uint32_t, pRegions: *const VkBufferImageCopy) -> ();


/// `vkCmdCopyImageToBuffer2`
pub type PFN_vkCmdCopyImageToBuffer2 = Option<FN_vkCmdCopyImageToBuffer2>;

/// `vkCmdCopyImageToBuffer2`
pub type FN_vkCmdCopyImageToBuffer2 = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pCopyImageToBufferInfo: *const VkCopyImageToBufferInfo2) -> ();


/// `vkCmdCopyImageToBuffer2KHR` = `vkCmdCopyImageToBuffer2`
pub type PFN_vkCmdCopyImageToBuffer2KHR = PFN_vkCmdCopyImageToBuffer2;

/// `vkCmdCopyImageToBuffer2KHR` = `vkCmdCopyImageToBuffer2`
pub type FN_vkCmdCopyImageToBuffer2KHR = FN_vkCmdCopyImageToBuffer2;

/// `vkCmdCopyMemoryIndirectKHR`
pub type PFN_vkCmdCopyMemoryIndirectKHR = Option<FN_vkCmdCopyMemoryIndirectKHR>;

/// `vkCmdCopyMemoryIndirectKHR`
pub type FN_vkCmdCopyMemoryIndirectKHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pCopyMemoryIndirectInfo: *const VkCopyMemoryIndirectInfoKHR) -> ();


/// `vkCmdCopyMemoryIndirectNV`
pub type PFN_vkCmdCopyMemoryIndirectNV = Option<FN_vkCmdCopyMemoryIndirectNV>;

/// `vkCmdCopyMemoryIndirectNV`
pub type FN_vkCmdCopyMemoryIndirectNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, copyBufferAddress: VkDeviceAddress, copyCount: uint32_t, stride: uint32_t) -> ();


/// `vkCmdCopyMemoryToAccelerationStructureKHR`
pub type PFN_vkCmdCopyMemoryToAccelerationStructureKHR = Option<FN_vkCmdCopyMemoryToAccelerationStructureKHR>;

/// `vkCmdCopyMemoryToAccelerationStructureKHR`
pub type FN_vkCmdCopyMemoryToAccelerationStructureKHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pInfo: *const VkCopyMemoryToAccelerationStructureInfoKHR) -> ();


/// `vkCmdCopyMemoryToImageIndirectKHR`
pub type PFN_vkCmdCopyMemoryToImageIndirectKHR = Option<FN_vkCmdCopyMemoryToImageIndirectKHR>;

/// `vkCmdCopyMemoryToImageIndirectKHR`
pub type FN_vkCmdCopyMemoryToImageIndirectKHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pCopyMemoryToImageIndirectInfo: *const VkCopyMemoryToImageIndirectInfoKHR) -> ();


/// `vkCmdCopyMemoryToImageIndirectNV`
pub type PFN_vkCmdCopyMemoryToImageIndirectNV = Option<FN_vkCmdCopyMemoryToImageIndirectNV>;

/// `vkCmdCopyMemoryToImageIndirectNV`
pub type FN_vkCmdCopyMemoryToImageIndirectNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, copyBufferAddress: VkDeviceAddress, copyCount: uint32_t, stride: uint32_t, dstImage: VkImage, dstImageLayout: VkImageLayout, pImageSubresources: *const VkImageSubresourceLayers) -> ();


/// `vkCmdCopyMemoryToMicromapEXT`
pub type PFN_vkCmdCopyMemoryToMicromapEXT = Option<FN_vkCmdCopyMemoryToMicromapEXT>;

/// `vkCmdCopyMemoryToMicromapEXT`
pub type FN_vkCmdCopyMemoryToMicromapEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pInfo: *const VkCopyMemoryToMicromapInfoEXT) -> ();


/// `vkCmdCopyMicromapEXT`
pub type PFN_vkCmdCopyMicromapEXT = Option<FN_vkCmdCopyMicromapEXT>;

/// `vkCmdCopyMicromapEXT`
pub type FN_vkCmdCopyMicromapEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pInfo: *const VkCopyMicromapInfoEXT) -> ();


/// `vkCmdCopyMicromapToMemoryEXT`
pub type PFN_vkCmdCopyMicromapToMemoryEXT = Option<FN_vkCmdCopyMicromapToMemoryEXT>;

/// `vkCmdCopyMicromapToMemoryEXT`
pub type FN_vkCmdCopyMicromapToMemoryEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pInfo: *const VkCopyMicromapToMemoryInfoEXT) -> ();


/// `vkCmdCopyQueryPoolResults`
pub type PFN_vkCmdCopyQueryPoolResults = Option<FN_vkCmdCopyQueryPoolResults>;

/// `vkCmdCopyQueryPoolResults`
pub type FN_vkCmdCopyQueryPoolResults = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, firstQuery: uint32_t, queryCount: uint32_t, dstBuffer: VkBuffer, dstOffset: VkDeviceSize, stride: VkDeviceSize, flags: VkQueryResultFlags) -> ();


/// `vkCmdCopyTensorARM`
pub type PFN_vkCmdCopyTensorARM = Option<FN_vkCmdCopyTensorARM>;

/// `vkCmdCopyTensorARM`
pub type FN_vkCmdCopyTensorARM = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pCopyTensorInfo: *const VkCopyTensorInfoARM) -> ();


/// `vkCmdCudaLaunchKernelNV`
pub type PFN_vkCmdCudaLaunchKernelNV = Option<FN_vkCmdCudaLaunchKernelNV>;

/// `vkCmdCudaLaunchKernelNV`
pub type FN_vkCmdCudaLaunchKernelNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pLaunchInfo: *const VkCudaLaunchInfoNV) -> ();


/// `vkCmdCuLaunchKernelNVX`
pub type PFN_vkCmdCuLaunchKernelNVX = Option<FN_vkCmdCuLaunchKernelNVX>;

/// `vkCmdCuLaunchKernelNVX`
pub type FN_vkCmdCuLaunchKernelNVX = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pLaunchInfo: *const VkCuLaunchInfoNVX) -> ();


/// `vkCmdDebugMarkerBeginEXT`
pub type PFN_vkCmdDebugMarkerBeginEXT = Option<FN_vkCmdDebugMarkerBeginEXT>;

/// `vkCmdDebugMarkerBeginEXT`
pub type FN_vkCmdDebugMarkerBeginEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pMarkerInfo: *const VkDebugMarkerMarkerInfoEXT) -> ();


/// `vkCmdDebugMarkerEndEXT`
pub type PFN_vkCmdDebugMarkerEndEXT = Option<FN_vkCmdDebugMarkerEndEXT>;

/// `vkCmdDebugMarkerEndEXT`
pub type FN_vkCmdDebugMarkerEndEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer) -> ();


/// `vkCmdDebugMarkerInsertEXT`
pub type PFN_vkCmdDebugMarkerInsertEXT = Option<FN_vkCmdDebugMarkerInsertEXT>;

/// `vkCmdDebugMarkerInsertEXT`
pub type FN_vkCmdDebugMarkerInsertEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pMarkerInfo: *const VkDebugMarkerMarkerInfoEXT) -> ();


/// `vkCmdDecodeVideoKHR`
pub type PFN_vkCmdDecodeVideoKHR = Option<FN_vkCmdDecodeVideoKHR>;

/// `vkCmdDecodeVideoKHR`
pub type FN_vkCmdDecodeVideoKHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pDecodeInfo: *const VkVideoDecodeInfoKHR) -> ();


/// `vkCmdDecompressMemoryEXT`
pub type PFN_vkCmdDecompressMemoryEXT = Option<FN_vkCmdDecompressMemoryEXT>;

/// `vkCmdDecompressMemoryEXT`
pub type FN_vkCmdDecompressMemoryEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pDecompressMemoryInfoEXT: *const VkDecompressMemoryInfoEXT) -> ();


/// `vkCmdDecompressMemoryIndirectCountEXT`
pub type PFN_vkCmdDecompressMemoryIndirectCountEXT = Option<FN_vkCmdDecompressMemoryIndirectCountEXT>;

/// `vkCmdDecompressMemoryIndirectCountEXT`
pub type FN_vkCmdDecompressMemoryIndirectCountEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, decompressionMethod: VkMemoryDecompressionMethodFlagsEXT, indirectCommandsAddress: VkDeviceAddress, indirectCommandsCountAddress: VkDeviceAddress, maxDecompressionCount: uint32_t, stride: uint32_t) -> ();


/// `vkCmdDecompressMemoryIndirectCountNV`
pub type PFN_vkCmdDecompressMemoryIndirectCountNV = Option<FN_vkCmdDecompressMemoryIndirectCountNV>;

/// `vkCmdDecompressMemoryIndirectCountNV`
pub type FN_vkCmdDecompressMemoryIndirectCountNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, indirectCommandsAddress: VkDeviceAddress, indirectCommandsCountAddress: VkDeviceAddress, stride: uint32_t) -> ();


/// `vkCmdDecompressMemoryNV`
pub type PFN_vkCmdDecompressMemoryNV = Option<FN_vkCmdDecompressMemoryNV>;

/// `vkCmdDecompressMemoryNV`
pub type FN_vkCmdDecompressMemoryNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, decompressRegionCount: uint32_t, pDecompressMemoryRegions: *const VkDecompressMemoryRegionNV) -> ();


/// `vkCmdDispatch`
pub type PFN_vkCmdDispatch = Option<FN_vkCmdDispatch>;

/// `vkCmdDispatch`
pub type FN_vkCmdDispatch = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, groupCountX: uint32_t, groupCountY: uint32_t, groupCountZ: uint32_t) -> ();


/// `vkCmdDispatchBase`
pub type PFN_vkCmdDispatchBase = Option<FN_vkCmdDispatchBase>;

/// `vkCmdDispatchBase`
pub type FN_vkCmdDispatchBase = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, baseGroupX: uint32_t, baseGroupY: uint32_t, baseGroupZ: uint32_t, groupCountX: uint32_t, groupCountY: uint32_t, groupCountZ: uint32_t) -> ();


/// `vkCmdDispatchBaseKHR` = `vkCmdDispatchBase`
pub type PFN_vkCmdDispatchBaseKHR = PFN_vkCmdDispatchBase;

/// `vkCmdDispatchBaseKHR` = `vkCmdDispatchBase`
pub type FN_vkCmdDispatchBaseKHR = FN_vkCmdDispatchBase;

/// `vkCmdDispatchDataGraphARM`
pub type PFN_vkCmdDispatchDataGraphARM = Option<FN_vkCmdDispatchDataGraphARM>;

/// `vkCmdDispatchDataGraphARM`
pub type FN_vkCmdDispatchDataGraphARM = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, session: VkDataGraphPipelineSessionARM, pInfo: *const VkDataGraphPipelineDispatchInfoARM) -> ();


/// `vkCmdDispatchGraphAMDX`
pub type PFN_vkCmdDispatchGraphAMDX = Option<FN_vkCmdDispatchGraphAMDX>;

/// `vkCmdDispatchGraphAMDX`
pub type FN_vkCmdDispatchGraphAMDX = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, scratch: VkDeviceAddress, scratchSize: VkDeviceSize, pCountInfo: *const VkDispatchGraphCountInfoAMDX) -> ();


/// `vkCmdDispatchGraphIndirectAMDX`
pub type PFN_vkCmdDispatchGraphIndirectAMDX = Option<FN_vkCmdDispatchGraphIndirectAMDX>;

/// `vkCmdDispatchGraphIndirectAMDX`
pub type FN_vkCmdDispatchGraphIndirectAMDX = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, scratch: VkDeviceAddress, scratchSize: VkDeviceSize, pCountInfo: *const VkDispatchGraphCountInfoAMDX) -> ();


/// `vkCmdDispatchGraphIndirectCountAMDX`
pub type PFN_vkCmdDispatchGraphIndirectCountAMDX = Option<FN_vkCmdDispatchGraphIndirectCountAMDX>;

/// `vkCmdDispatchGraphIndirectCountAMDX`
pub type FN_vkCmdDispatchGraphIndirectCountAMDX = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, scratch: VkDeviceAddress, scratchSize: VkDeviceSize, countInfo: VkDeviceAddress) -> ();


/// `vkCmdDispatchIndirect`
pub type PFN_vkCmdDispatchIndirect = Option<FN_vkCmdDispatchIndirect>;

/// `vkCmdDispatchIndirect`
pub type FN_vkCmdDispatchIndirect = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize) -> ();


/// `vkCmdDispatchTileQCOM`
pub type PFN_vkCmdDispatchTileQCOM = Option<FN_vkCmdDispatchTileQCOM>;

/// `vkCmdDispatchTileQCOM`
pub type FN_vkCmdDispatchTileQCOM = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pDispatchTileInfo: *const VkDispatchTileInfoQCOM) -> ();


/// `vkCmdDraw`
pub type PFN_vkCmdDraw = Option<FN_vkCmdDraw>;

/// `vkCmdDraw`
pub type FN_vkCmdDraw = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, vertexCount: uint32_t, instanceCount: uint32_t, firstVertex: uint32_t, firstInstance: uint32_t) -> ();


/// `vkCmdDrawClusterHUAWEI`
pub type PFN_vkCmdDrawClusterHUAWEI = Option<FN_vkCmdDrawClusterHUAWEI>;

/// `vkCmdDrawClusterHUAWEI`
pub type FN_vkCmdDrawClusterHUAWEI = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, groupCountX: uint32_t, groupCountY: uint32_t, groupCountZ: uint32_t) -> ();


/// `vkCmdDrawClusterIndirectHUAWEI`
pub type PFN_vkCmdDrawClusterIndirectHUAWEI = Option<FN_vkCmdDrawClusterIndirectHUAWEI>;

/// `vkCmdDrawClusterIndirectHUAWEI`
pub type FN_vkCmdDrawClusterIndirectHUAWEI = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize) -> ();


/// `vkCmdDrawIndexed`
pub type PFN_vkCmdDrawIndexed = Option<FN_vkCmdDrawIndexed>;

/// `vkCmdDrawIndexed`
pub type FN_vkCmdDrawIndexed = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, indexCount: uint32_t, instanceCount: uint32_t, firstIndex: uint32_t, vertexOffset: int32_t, firstInstance: uint32_t) -> ();


/// `vkCmdDrawIndexedIndirect`
pub type PFN_vkCmdDrawIndexedIndirect = Option<FN_vkCmdDrawIndexedIndirect>;

/// `vkCmdDrawIndexedIndirect`
pub type FN_vkCmdDrawIndexedIndirect = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, drawCount: uint32_t, stride: uint32_t) -> ();


/// `vkCmdDrawIndexedIndirectCount`
pub type PFN_vkCmdDrawIndexedIndirectCount = Option<FN_vkCmdDrawIndexedIndirectCount>;

/// `vkCmdDrawIndexedIndirectCount`
pub type FN_vkCmdDrawIndexedIndirectCount = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, countBuffer: VkBuffer, countBufferOffset: VkDeviceSize, maxDrawCount: uint32_t, stride: uint32_t) -> ();


/// `vkCmdDrawIndexedIndirectCountAMD` = `vkCmdDrawIndexedIndirectCount`
pub type PFN_vkCmdDrawIndexedIndirectCountAMD = PFN_vkCmdDrawIndexedIndirectCount;

/// `vkCmdDrawIndexedIndirectCountAMD` = `vkCmdDrawIndexedIndirectCount`
pub type FN_vkCmdDrawIndexedIndirectCountAMD = FN_vkCmdDrawIndexedIndirectCount;

/// `vkCmdDrawIndexedIndirectCountKHR` = `vkCmdDrawIndexedIndirectCount`
pub type PFN_vkCmdDrawIndexedIndirectCountKHR = PFN_vkCmdDrawIndexedIndirectCount;

/// `vkCmdDrawIndexedIndirectCountKHR` = `vkCmdDrawIndexedIndirectCount`
pub type FN_vkCmdDrawIndexedIndirectCountKHR = FN_vkCmdDrawIndexedIndirectCount;

/// `vkCmdDrawIndirect`
pub type PFN_vkCmdDrawIndirect = Option<FN_vkCmdDrawIndirect>;

/// `vkCmdDrawIndirect`
pub type FN_vkCmdDrawIndirect = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, drawCount: uint32_t, stride: uint32_t) -> ();


/// `vkCmdDrawIndirectByteCountEXT`
pub type PFN_vkCmdDrawIndirectByteCountEXT = Option<FN_vkCmdDrawIndirectByteCountEXT>;

/// `vkCmdDrawIndirectByteCountEXT`
pub type FN_vkCmdDrawIndirectByteCountEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, instanceCount: uint32_t, firstInstance: uint32_t, counterBuffer: VkBuffer, counterBufferOffset: VkDeviceSize, counterOffset: uint32_t, vertexStride: uint32_t) -> ();


/// `vkCmdDrawIndirectCount`
pub type PFN_vkCmdDrawIndirectCount = Option<FN_vkCmdDrawIndirectCount>;

/// `vkCmdDrawIndirectCount`
pub type FN_vkCmdDrawIndirectCount = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, countBuffer: VkBuffer, countBufferOffset: VkDeviceSize, maxDrawCount: uint32_t, stride: uint32_t) -> ();


/// `vkCmdDrawIndirectCountAMD` = `vkCmdDrawIndirectCount`
pub type PFN_vkCmdDrawIndirectCountAMD = PFN_vkCmdDrawIndirectCount;

/// `vkCmdDrawIndirectCountAMD` = `vkCmdDrawIndirectCount`
pub type FN_vkCmdDrawIndirectCountAMD = FN_vkCmdDrawIndirectCount;

/// `vkCmdDrawIndirectCountKHR` = `vkCmdDrawIndirectCount`
pub type PFN_vkCmdDrawIndirectCountKHR = PFN_vkCmdDrawIndirectCount;

/// `vkCmdDrawIndirectCountKHR` = `vkCmdDrawIndirectCount`
pub type FN_vkCmdDrawIndirectCountKHR = FN_vkCmdDrawIndirectCount;

/// `vkCmdDrawMeshTasksEXT`
pub type PFN_vkCmdDrawMeshTasksEXT = Option<FN_vkCmdDrawMeshTasksEXT>;

/// `vkCmdDrawMeshTasksEXT`
pub type FN_vkCmdDrawMeshTasksEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, groupCountX: uint32_t, groupCountY: uint32_t, groupCountZ: uint32_t) -> ();


/// `vkCmdDrawMeshTasksIndirectCountEXT`
pub type PFN_vkCmdDrawMeshTasksIndirectCountEXT = Option<FN_vkCmdDrawMeshTasksIndirectCountEXT>;

/// `vkCmdDrawMeshTasksIndirectCountEXT`
pub type FN_vkCmdDrawMeshTasksIndirectCountEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, countBuffer: VkBuffer, countBufferOffset: VkDeviceSize, maxDrawCount: uint32_t, stride: uint32_t) -> ();


/// `vkCmdDrawMeshTasksIndirectCountNV`
pub type PFN_vkCmdDrawMeshTasksIndirectCountNV = Option<FN_vkCmdDrawMeshTasksIndirectCountNV>;

/// `vkCmdDrawMeshTasksIndirectCountNV`
pub type FN_vkCmdDrawMeshTasksIndirectCountNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, countBuffer: VkBuffer, countBufferOffset: VkDeviceSize, maxDrawCount: uint32_t, stride: uint32_t) -> ();


/// `vkCmdDrawMeshTasksIndirectEXT`
pub type PFN_vkCmdDrawMeshTasksIndirectEXT = Option<FN_vkCmdDrawMeshTasksIndirectEXT>;

/// `vkCmdDrawMeshTasksIndirectEXT`
pub type FN_vkCmdDrawMeshTasksIndirectEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, drawCount: uint32_t, stride: uint32_t) -> ();


/// `vkCmdDrawMeshTasksIndirectNV`
pub type PFN_vkCmdDrawMeshTasksIndirectNV = Option<FN_vkCmdDrawMeshTasksIndirectNV>;

/// `vkCmdDrawMeshTasksIndirectNV`
pub type FN_vkCmdDrawMeshTasksIndirectNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, drawCount: uint32_t, stride: uint32_t) -> ();


/// `vkCmdDrawMeshTasksNV`
pub type PFN_vkCmdDrawMeshTasksNV = Option<FN_vkCmdDrawMeshTasksNV>;

/// `vkCmdDrawMeshTasksNV`
pub type FN_vkCmdDrawMeshTasksNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, taskCount: uint32_t, firstTask: uint32_t) -> ();


/// `vkCmdDrawMultiEXT`
pub type PFN_vkCmdDrawMultiEXT = Option<FN_vkCmdDrawMultiEXT>;

/// `vkCmdDrawMultiEXT`
pub type FN_vkCmdDrawMultiEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, drawCount: uint32_t, pVertexInfo: *const VkMultiDrawInfoEXT, instanceCount: uint32_t, firstInstance: uint32_t, stride: uint32_t) -> ();


/// `vkCmdDrawMultiIndexedEXT`
pub type PFN_vkCmdDrawMultiIndexedEXT = Option<FN_vkCmdDrawMultiIndexedEXT>;

/// `vkCmdDrawMultiIndexedEXT`
pub type FN_vkCmdDrawMultiIndexedEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, drawCount: uint32_t, pIndexInfo: *const VkMultiDrawIndexedInfoEXT, instanceCount: uint32_t, firstInstance: uint32_t, stride: uint32_t, pVertexOffset: *const int32_t) -> ();


/// `vkCmdEncodeVideoKHR`
pub type PFN_vkCmdEncodeVideoKHR = Option<FN_vkCmdEncodeVideoKHR>;

/// `vkCmdEncodeVideoKHR`
pub type FN_vkCmdEncodeVideoKHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pEncodeInfo: *const VkVideoEncodeInfoKHR) -> ();


/// `vkCmdEndConditionalRenderingEXT`
pub type PFN_vkCmdEndConditionalRenderingEXT = Option<FN_vkCmdEndConditionalRenderingEXT>;

/// `vkCmdEndConditionalRenderingEXT`
pub type FN_vkCmdEndConditionalRenderingEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer) -> ();


/// `vkCmdEndDebugUtilsLabelEXT`
pub type PFN_vkCmdEndDebugUtilsLabelEXT = Option<FN_vkCmdEndDebugUtilsLabelEXT>;

/// `vkCmdEndDebugUtilsLabelEXT`
pub type FN_vkCmdEndDebugUtilsLabelEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer) -> ();


/// `vkCmdEndPerTileExecutionQCOM`
pub type PFN_vkCmdEndPerTileExecutionQCOM = Option<FN_vkCmdEndPerTileExecutionQCOM>;

/// `vkCmdEndPerTileExecutionQCOM`
pub type FN_vkCmdEndPerTileExecutionQCOM = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pPerTileEndInfo: *const VkPerTileEndInfoQCOM) -> ();


/// `vkCmdEndQuery`
pub type PFN_vkCmdEndQuery = Option<FN_vkCmdEndQuery>;

/// `vkCmdEndQuery`
pub type FN_vkCmdEndQuery = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, query: uint32_t) -> ();


/// `vkCmdEndQueryIndexedEXT`
pub type PFN_vkCmdEndQueryIndexedEXT = Option<FN_vkCmdEndQueryIndexedEXT>;

/// `vkCmdEndQueryIndexedEXT`
pub type FN_vkCmdEndQueryIndexedEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, query: uint32_t, index: uint32_t) -> ();


/// `vkCmdEndRendering`
pub type PFN_vkCmdEndRendering = Option<FN_vkCmdEndRendering>;

/// `vkCmdEndRendering`
pub type FN_vkCmdEndRendering = unsafe extern "system" fn(commandBuffer: VkCommandBuffer) -> ();


/// `vkCmdEndRendering2EXT` = `vkCmdEndRendering2KHR`
pub type PFN_vkCmdEndRendering2EXT = PFN_vkCmdEndRendering2KHR;

/// `vkCmdEndRendering2EXT` = `vkCmdEndRendering2KHR`
pub type FN_vkCmdEndRendering2EXT = FN_vkCmdEndRendering2KHR;

/// `vkCmdEndRendering2KHR`
pub type PFN_vkCmdEndRendering2KHR = Option<FN_vkCmdEndRendering2KHR>;

/// `vkCmdEndRendering2KHR`
pub type FN_vkCmdEndRendering2KHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pRenderingEndInfo: *const VkRenderingEndInfoKHR) -> ();


/// `vkCmdEndRenderingKHR` = `vkCmdEndRendering`
pub type PFN_vkCmdEndRenderingKHR = PFN_vkCmdEndRendering;

/// `vkCmdEndRenderingKHR` = `vkCmdEndRendering`
pub type FN_vkCmdEndRenderingKHR = FN_vkCmdEndRendering;

/// `vkCmdEndRenderPass`
pub type PFN_vkCmdEndRenderPass = Option<FN_vkCmdEndRenderPass>;

/// `vkCmdEndRenderPass`
pub type FN_vkCmdEndRenderPass = unsafe extern "system" fn(commandBuffer: VkCommandBuffer) -> ();


/// `vkCmdEndRenderPass2`
pub type PFN_vkCmdEndRenderPass2 = Option<FN_vkCmdEndRenderPass2>;

/// `vkCmdEndRenderPass2`
pub type FN_vkCmdEndRenderPass2 = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pSubpassEndInfo: *const VkSubpassEndInfo) -> ();


/// `vkCmdEndRenderPass2KHR` = `vkCmdEndRenderPass2`
pub type PFN_vkCmdEndRenderPass2KHR = PFN_vkCmdEndRenderPass2;

/// `vkCmdEndRenderPass2KHR` = `vkCmdEndRenderPass2`
pub type FN_vkCmdEndRenderPass2KHR = FN_vkCmdEndRenderPass2;

/// `vkCmdEndShaderInstrumentationARM`
pub type PFN_vkCmdEndShaderInstrumentationARM = Option<FN_vkCmdEndShaderInstrumentationARM>;

/// `vkCmdEndShaderInstrumentationARM`
pub type FN_vkCmdEndShaderInstrumentationARM = unsafe extern "system" fn(commandBuffer: VkCommandBuffer) -> ();


/// `vkCmdEndTransformFeedbackEXT`
pub type PFN_vkCmdEndTransformFeedbackEXT = Option<FN_vkCmdEndTransformFeedbackEXT>;

/// `vkCmdEndTransformFeedbackEXT`
pub type FN_vkCmdEndTransformFeedbackEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, firstCounterBuffer: uint32_t, counterBufferCount: uint32_t, pCounterBuffers: *const VkBuffer, pCounterBufferOffsets: *const VkDeviceSize) -> ();


/// `vkCmdEndVideoCodingKHR`
pub type PFN_vkCmdEndVideoCodingKHR = Option<FN_vkCmdEndVideoCodingKHR>;

/// `vkCmdEndVideoCodingKHR`
pub type FN_vkCmdEndVideoCodingKHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pEndCodingInfo: *const VkVideoEndCodingInfoKHR) -> ();


/// `vkCmdExecuteCommands`
pub type PFN_vkCmdExecuteCommands = Option<FN_vkCmdExecuteCommands>;

/// `vkCmdExecuteCommands`
pub type FN_vkCmdExecuteCommands = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, commandBufferCount: uint32_t, pCommandBuffers: *const VkCommandBuffer) -> ();


/// `vkCmdExecuteGeneratedCommandsEXT`
pub type PFN_vkCmdExecuteGeneratedCommandsEXT = Option<FN_vkCmdExecuteGeneratedCommandsEXT>;

/// `vkCmdExecuteGeneratedCommandsEXT`
pub type FN_vkCmdExecuteGeneratedCommandsEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, isPreprocessed: VkBool32, pGeneratedCommandsInfo: *const VkGeneratedCommandsInfoEXT) -> ();


/// `vkCmdExecuteGeneratedCommandsNV`
pub type PFN_vkCmdExecuteGeneratedCommandsNV = Option<FN_vkCmdExecuteGeneratedCommandsNV>;

/// `vkCmdExecuteGeneratedCommandsNV`
pub type FN_vkCmdExecuteGeneratedCommandsNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, isPreprocessed: VkBool32, pGeneratedCommandsInfo: *const VkGeneratedCommandsInfoNV) -> ();


/// `vkCmdFillBuffer`
/// 
/// transfer support is only available when VK_KHR_maintenance1 is enabled, as documented in valid usage language in the specification
pub type PFN_vkCmdFillBuffer = Option<FN_vkCmdFillBuffer>;

/// `vkCmdFillBuffer`
/// 
/// transfer support is only available when VK_KHR_maintenance1 is enabled, as documented in valid usage language in the specification
pub type FN_vkCmdFillBuffer = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, dstBuffer: VkBuffer, dstOffset: VkDeviceSize, size: VkDeviceSize, data: uint32_t) -> ();


/// `vkCmdInitializeGraphScratchMemoryAMDX`
pub type PFN_vkCmdInitializeGraphScratchMemoryAMDX = Option<FN_vkCmdInitializeGraphScratchMemoryAMDX>;

/// `vkCmdInitializeGraphScratchMemoryAMDX`
pub type FN_vkCmdInitializeGraphScratchMemoryAMDX = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, executionGraph: VkPipeline, scratch: VkDeviceAddress, scratchSize: VkDeviceSize) -> ();


/// `vkCmdInsertDebugUtilsLabelEXT`
pub type PFN_vkCmdInsertDebugUtilsLabelEXT = Option<FN_vkCmdInsertDebugUtilsLabelEXT>;

/// `vkCmdInsertDebugUtilsLabelEXT`
pub type FN_vkCmdInsertDebugUtilsLabelEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pLabelInfo: *const VkDebugUtilsLabelEXT) -> ();


/// `vkCmdNextSubpass`
pub type PFN_vkCmdNextSubpass = Option<FN_vkCmdNextSubpass>;

/// `vkCmdNextSubpass`
pub type FN_vkCmdNextSubpass = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, contents: VkSubpassContents) -> ();


/// `vkCmdNextSubpass2`
pub type PFN_vkCmdNextSubpass2 = Option<FN_vkCmdNextSubpass2>;

/// `vkCmdNextSubpass2`
pub type FN_vkCmdNextSubpass2 = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pSubpassBeginInfo: *const VkSubpassBeginInfo, pSubpassEndInfo: *const VkSubpassEndInfo) -> ();


/// `vkCmdNextSubpass2KHR` = `vkCmdNextSubpass2`
pub type PFN_vkCmdNextSubpass2KHR = PFN_vkCmdNextSubpass2;

/// `vkCmdNextSubpass2KHR` = `vkCmdNextSubpass2`
pub type FN_vkCmdNextSubpass2KHR = FN_vkCmdNextSubpass2;

/// `vkCmdOpticalFlowExecuteNV`
pub type PFN_vkCmdOpticalFlowExecuteNV = Option<FN_vkCmdOpticalFlowExecuteNV>;

/// `vkCmdOpticalFlowExecuteNV`
pub type FN_vkCmdOpticalFlowExecuteNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, session: VkOpticalFlowSessionNV, pExecuteInfo: *const VkOpticalFlowExecuteInfoNV) -> ();


/// `vkCmdPipelineBarrier`
pub type PFN_vkCmdPipelineBarrier = Option<FN_vkCmdPipelineBarrier>;

/// `vkCmdPipelineBarrier`
pub type FN_vkCmdPipelineBarrier = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, srcStageMask: VkPipelineStageFlags, dstStageMask: VkPipelineStageFlags, dependencyFlags: VkDependencyFlags, memoryBarrierCount: uint32_t, pMemoryBarriers: *const VkMemoryBarrier, bufferMemoryBarrierCount: uint32_t, pBufferMemoryBarriers: *const VkBufferMemoryBarrier, imageMemoryBarrierCount: uint32_t, pImageMemoryBarriers: *const VkImageMemoryBarrier) -> ();


/// `vkCmdPipelineBarrier2`
pub type PFN_vkCmdPipelineBarrier2 = Option<FN_vkCmdPipelineBarrier2>;

/// `vkCmdPipelineBarrier2`
pub type FN_vkCmdPipelineBarrier2 = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pDependencyInfo: *const VkDependencyInfo) -> ();


/// `vkCmdPipelineBarrier2KHR` = `vkCmdPipelineBarrier2`
pub type PFN_vkCmdPipelineBarrier2KHR = PFN_vkCmdPipelineBarrier2;

/// `vkCmdPipelineBarrier2KHR` = `vkCmdPipelineBarrier2`
pub type FN_vkCmdPipelineBarrier2KHR = FN_vkCmdPipelineBarrier2;

/// `vkCmdPreprocessGeneratedCommandsEXT`
pub type PFN_vkCmdPreprocessGeneratedCommandsEXT = Option<FN_vkCmdPreprocessGeneratedCommandsEXT>;

/// `vkCmdPreprocessGeneratedCommandsEXT`
pub type FN_vkCmdPreprocessGeneratedCommandsEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pGeneratedCommandsInfo: *const VkGeneratedCommandsInfoEXT, stateCommandBuffer: VkCommandBuffer) -> ();


/// `vkCmdPreprocessGeneratedCommandsNV`
pub type PFN_vkCmdPreprocessGeneratedCommandsNV = Option<FN_vkCmdPreprocessGeneratedCommandsNV>;

/// `vkCmdPreprocessGeneratedCommandsNV`
pub type FN_vkCmdPreprocessGeneratedCommandsNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pGeneratedCommandsInfo: *const VkGeneratedCommandsInfoNV) -> ();


/// `vkCmdPushConstants`
pub type PFN_vkCmdPushConstants = Option<FN_vkCmdPushConstants>;

/// `vkCmdPushConstants`
pub type FN_vkCmdPushConstants = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, layout: VkPipelineLayout, stageFlags: VkShaderStageFlags, offset: uint32_t, size: uint32_t, pValues: *const void) -> ();


/// `vkCmdPushConstants2`
pub type PFN_vkCmdPushConstants2 = Option<FN_vkCmdPushConstants2>;

/// `vkCmdPushConstants2`
pub type FN_vkCmdPushConstants2 = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pPushConstantsInfo: *const VkPushConstantsInfo) -> ();


/// `vkCmdPushConstants2KHR` = `vkCmdPushConstants2`
pub type PFN_vkCmdPushConstants2KHR = PFN_vkCmdPushConstants2;

/// `vkCmdPushConstants2KHR` = `vkCmdPushConstants2`
pub type FN_vkCmdPushConstants2KHR = FN_vkCmdPushConstants2;

/// `vkCmdPushDataEXT`
pub type PFN_vkCmdPushDataEXT = Option<FN_vkCmdPushDataEXT>;

/// `vkCmdPushDataEXT`
pub type FN_vkCmdPushDataEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pPushDataInfo: *const VkPushDataInfoEXT) -> ();


/// `vkCmdPushDescriptorSet`
pub type PFN_vkCmdPushDescriptorSet = Option<FN_vkCmdPushDescriptorSet>;

/// `vkCmdPushDescriptorSet`
pub type FN_vkCmdPushDescriptorSet = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, layout: VkPipelineLayout, set: uint32_t, descriptorWriteCount: uint32_t, pDescriptorWrites: *const VkWriteDescriptorSet) -> ();


/// `vkCmdPushDescriptorSet2`
pub type PFN_vkCmdPushDescriptorSet2 = Option<FN_vkCmdPushDescriptorSet2>;

/// `vkCmdPushDescriptorSet2`
pub type FN_vkCmdPushDescriptorSet2 = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pPushDescriptorSetInfo: *const VkPushDescriptorSetInfo) -> ();


/// `vkCmdPushDescriptorSet2KHR` = `vkCmdPushDescriptorSet2`
pub type PFN_vkCmdPushDescriptorSet2KHR = PFN_vkCmdPushDescriptorSet2;

/// `vkCmdPushDescriptorSet2KHR` = `vkCmdPushDescriptorSet2`
pub type FN_vkCmdPushDescriptorSet2KHR = FN_vkCmdPushDescriptorSet2;

/// `vkCmdPushDescriptorSetKHR` = `vkCmdPushDescriptorSet`
pub type PFN_vkCmdPushDescriptorSetKHR = PFN_vkCmdPushDescriptorSet;

/// `vkCmdPushDescriptorSetKHR` = `vkCmdPushDescriptorSet`
pub type FN_vkCmdPushDescriptorSetKHR = FN_vkCmdPushDescriptorSet;

/// `vkCmdPushDescriptorSetWithTemplate`
pub type PFN_vkCmdPushDescriptorSetWithTemplate = Option<FN_vkCmdPushDescriptorSetWithTemplate>;

/// `vkCmdPushDescriptorSetWithTemplate`
pub type FN_vkCmdPushDescriptorSetWithTemplate = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, descriptorUpdateTemplate: VkDescriptorUpdateTemplate, layout: VkPipelineLayout, set: uint32_t, pData: *const void) -> ();


/// `vkCmdPushDescriptorSetWithTemplate2`
pub type PFN_vkCmdPushDescriptorSetWithTemplate2 = Option<FN_vkCmdPushDescriptorSetWithTemplate2>;

/// `vkCmdPushDescriptorSetWithTemplate2`
pub type FN_vkCmdPushDescriptorSetWithTemplate2 = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pPushDescriptorSetWithTemplateInfo: *const VkPushDescriptorSetWithTemplateInfo) -> ();


/// `vkCmdPushDescriptorSetWithTemplate2KHR` = `vkCmdPushDescriptorSetWithTemplate2`
pub type PFN_vkCmdPushDescriptorSetWithTemplate2KHR = PFN_vkCmdPushDescriptorSetWithTemplate2;

/// `vkCmdPushDescriptorSetWithTemplate2KHR` = `vkCmdPushDescriptorSetWithTemplate2`
pub type FN_vkCmdPushDescriptorSetWithTemplate2KHR = FN_vkCmdPushDescriptorSetWithTemplate2;

/// `vkCmdPushDescriptorSetWithTemplateKHR` = `vkCmdPushDescriptorSetWithTemplate`
pub type PFN_vkCmdPushDescriptorSetWithTemplateKHR = PFN_vkCmdPushDescriptorSetWithTemplate;

/// `vkCmdPushDescriptorSetWithTemplateKHR` = `vkCmdPushDescriptorSetWithTemplate`
pub type FN_vkCmdPushDescriptorSetWithTemplateKHR = FN_vkCmdPushDescriptorSetWithTemplate;

/// `vkCmdRefreshObjectsKHR`
pub type PFN_vkCmdRefreshObjectsKHR = Option<FN_vkCmdRefreshObjectsKHR>;

/// `vkCmdRefreshObjectsKHR`
pub type FN_vkCmdRefreshObjectsKHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pRefreshObjects: *const VkRefreshObjectListKHR) -> ();


/// `vkCmdResetEvent`
pub type PFN_vkCmdResetEvent = Option<FN_vkCmdResetEvent>;

/// `vkCmdResetEvent`
pub type FN_vkCmdResetEvent = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, event: VkEvent, stageMask: VkPipelineStageFlags) -> ();


/// `vkCmdResetEvent2`
pub type PFN_vkCmdResetEvent2 = Option<FN_vkCmdResetEvent2>;

/// `vkCmdResetEvent2`
pub type FN_vkCmdResetEvent2 = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, event: VkEvent, stageMask: VkPipelineStageFlags2) -> ();


/// `vkCmdResetEvent2KHR` = `vkCmdResetEvent2`
pub type PFN_vkCmdResetEvent2KHR = PFN_vkCmdResetEvent2;

/// `vkCmdResetEvent2KHR` = `vkCmdResetEvent2`
pub type FN_vkCmdResetEvent2KHR = FN_vkCmdResetEvent2;

/// `vkCmdResetQueryPool`
pub type PFN_vkCmdResetQueryPool = Option<FN_vkCmdResetQueryPool>;

/// `vkCmdResetQueryPool`
pub type FN_vkCmdResetQueryPool = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, firstQuery: uint32_t, queryCount: uint32_t) -> ();


/// `vkCmdResolveImage`
pub type PFN_vkCmdResolveImage = Option<FN_vkCmdResolveImage>;

/// `vkCmdResolveImage`
pub type FN_vkCmdResolveImage = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, srcImage: VkImage, srcImageLayout: VkImageLayout, dstImage: VkImage, dstImageLayout: VkImageLayout, regionCount: uint32_t, pRegions: *const VkImageResolve) -> ();


/// `vkCmdResolveImage2`
pub type PFN_vkCmdResolveImage2 = Option<FN_vkCmdResolveImage2>;

/// `vkCmdResolveImage2`
pub type FN_vkCmdResolveImage2 = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pResolveImageInfo: *const VkResolveImageInfo2) -> ();


/// `vkCmdResolveImage2KHR` = `vkCmdResolveImage2`
pub type PFN_vkCmdResolveImage2KHR = PFN_vkCmdResolveImage2;

/// `vkCmdResolveImage2KHR` = `vkCmdResolveImage2`
pub type FN_vkCmdResolveImage2KHR = FN_vkCmdResolveImage2;

/// `vkCmdSetAlphaToCoverageEnableEXT`
pub type PFN_vkCmdSetAlphaToCoverageEnableEXT = Option<FN_vkCmdSetAlphaToCoverageEnableEXT>;

/// `vkCmdSetAlphaToCoverageEnableEXT`
pub type FN_vkCmdSetAlphaToCoverageEnableEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, alphaToCoverageEnable: VkBool32) -> ();


/// `vkCmdSetAlphaToOneEnableEXT`
pub type PFN_vkCmdSetAlphaToOneEnableEXT = Option<FN_vkCmdSetAlphaToOneEnableEXT>;

/// `vkCmdSetAlphaToOneEnableEXT`
pub type FN_vkCmdSetAlphaToOneEnableEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, alphaToOneEnable: VkBool32) -> ();


/// `vkCmdSetAttachmentFeedbackLoopEnableEXT`
pub type PFN_vkCmdSetAttachmentFeedbackLoopEnableEXT = Option<FN_vkCmdSetAttachmentFeedbackLoopEnableEXT>;

/// `vkCmdSetAttachmentFeedbackLoopEnableEXT`
pub type FN_vkCmdSetAttachmentFeedbackLoopEnableEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, aspectMask: VkImageAspectFlags) -> ();


/// `vkCmdSetBlendConstants`
pub type PFN_vkCmdSetBlendConstants = Option<FN_vkCmdSetBlendConstants>;

/// `vkCmdSetBlendConstants`
pub type FN_vkCmdSetBlendConstants = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, blendConstants: *const float) -> ();


/// `vkCmdSetCheckpointNV`
pub type PFN_vkCmdSetCheckpointNV = Option<FN_vkCmdSetCheckpointNV>;

/// `vkCmdSetCheckpointNV`
pub type FN_vkCmdSetCheckpointNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pCheckpointMarker: *const void) -> ();


/// `vkCmdSetCoarseSampleOrderNV`
pub type PFN_vkCmdSetCoarseSampleOrderNV = Option<FN_vkCmdSetCoarseSampleOrderNV>;

/// `vkCmdSetCoarseSampleOrderNV`
pub type FN_vkCmdSetCoarseSampleOrderNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, sampleOrderType: VkCoarseSampleOrderTypeNV, customSampleOrderCount: uint32_t, pCustomSampleOrders: *const VkCoarseSampleOrderCustomNV) -> ();


/// `vkCmdSetColorBlendAdvancedEXT`
pub type PFN_vkCmdSetColorBlendAdvancedEXT = Option<FN_vkCmdSetColorBlendAdvancedEXT>;

/// `vkCmdSetColorBlendAdvancedEXT`
pub type FN_vkCmdSetColorBlendAdvancedEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, firstAttachment: uint32_t, attachmentCount: uint32_t, pColorBlendAdvanced: *const VkColorBlendAdvancedEXT) -> ();


/// `vkCmdSetColorBlendEnableEXT`
pub type PFN_vkCmdSetColorBlendEnableEXT = Option<FN_vkCmdSetColorBlendEnableEXT>;

/// `vkCmdSetColorBlendEnableEXT`
pub type FN_vkCmdSetColorBlendEnableEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, firstAttachment: uint32_t, attachmentCount: uint32_t, pColorBlendEnables: *const VkBool32) -> ();


/// `vkCmdSetColorBlendEquationEXT`
pub type PFN_vkCmdSetColorBlendEquationEXT = Option<FN_vkCmdSetColorBlendEquationEXT>;

/// `vkCmdSetColorBlendEquationEXT`
pub type FN_vkCmdSetColorBlendEquationEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, firstAttachment: uint32_t, attachmentCount: uint32_t, pColorBlendEquations: *const VkColorBlendEquationEXT) -> ();


/// `vkCmdSetColorWriteEnableEXT`
pub type PFN_vkCmdSetColorWriteEnableEXT = Option<FN_vkCmdSetColorWriteEnableEXT>;

/// `vkCmdSetColorWriteEnableEXT`
pub type FN_vkCmdSetColorWriteEnableEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, attachmentCount: uint32_t, pColorWriteEnables: *const VkBool32) -> ();


/// `vkCmdSetColorWriteMaskEXT`
pub type PFN_vkCmdSetColorWriteMaskEXT = Option<FN_vkCmdSetColorWriteMaskEXT>;

/// `vkCmdSetColorWriteMaskEXT`
pub type FN_vkCmdSetColorWriteMaskEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, firstAttachment: uint32_t, attachmentCount: uint32_t, pColorWriteMasks: *const VkColorComponentFlags) -> ();


/// `vkCmdSetComputeOccupancyPriorityNV`
pub type PFN_vkCmdSetComputeOccupancyPriorityNV = Option<FN_vkCmdSetComputeOccupancyPriorityNV>;

/// `vkCmdSetComputeOccupancyPriorityNV`
pub type FN_vkCmdSetComputeOccupancyPriorityNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pParameters: *const VkComputeOccupancyPriorityParametersNV) -> ();


/// `vkCmdSetConservativeRasterizationModeEXT`
pub type PFN_vkCmdSetConservativeRasterizationModeEXT = Option<FN_vkCmdSetConservativeRasterizationModeEXT>;

/// `vkCmdSetConservativeRasterizationModeEXT`
pub type FN_vkCmdSetConservativeRasterizationModeEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, conservativeRasterizationMode: VkConservativeRasterizationModeEXT) -> ();


/// `vkCmdSetCoverageModulationModeNV`
pub type PFN_vkCmdSetCoverageModulationModeNV = Option<FN_vkCmdSetCoverageModulationModeNV>;

/// `vkCmdSetCoverageModulationModeNV`
pub type FN_vkCmdSetCoverageModulationModeNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, coverageModulationMode: VkCoverageModulationModeNV) -> ();


/// `vkCmdSetCoverageModulationTableEnableNV`
pub type PFN_vkCmdSetCoverageModulationTableEnableNV = Option<FN_vkCmdSetCoverageModulationTableEnableNV>;

/// `vkCmdSetCoverageModulationTableEnableNV`
pub type FN_vkCmdSetCoverageModulationTableEnableNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, coverageModulationTableEnable: VkBool32) -> ();


/// `vkCmdSetCoverageModulationTableNV`
pub type PFN_vkCmdSetCoverageModulationTableNV = Option<FN_vkCmdSetCoverageModulationTableNV>;

/// `vkCmdSetCoverageModulationTableNV`
pub type FN_vkCmdSetCoverageModulationTableNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, coverageModulationTableCount: uint32_t, pCoverageModulationTable: *const float) -> ();


/// `vkCmdSetCoverageReductionModeNV`
pub type PFN_vkCmdSetCoverageReductionModeNV = Option<FN_vkCmdSetCoverageReductionModeNV>;

/// `vkCmdSetCoverageReductionModeNV`
pub type FN_vkCmdSetCoverageReductionModeNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, coverageReductionMode: VkCoverageReductionModeNV) -> ();


/// `vkCmdSetCoverageToColorEnableNV`
pub type PFN_vkCmdSetCoverageToColorEnableNV = Option<FN_vkCmdSetCoverageToColorEnableNV>;

/// `vkCmdSetCoverageToColorEnableNV`
pub type FN_vkCmdSetCoverageToColorEnableNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, coverageToColorEnable: VkBool32) -> ();


/// `vkCmdSetCoverageToColorLocationNV`
pub type PFN_vkCmdSetCoverageToColorLocationNV = Option<FN_vkCmdSetCoverageToColorLocationNV>;

/// `vkCmdSetCoverageToColorLocationNV`
pub type FN_vkCmdSetCoverageToColorLocationNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, coverageToColorLocation: uint32_t) -> ();


/// `vkCmdSetCullMode`
pub type PFN_vkCmdSetCullMode = Option<FN_vkCmdSetCullMode>;

/// `vkCmdSetCullMode`
pub type FN_vkCmdSetCullMode = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, cullMode: VkCullModeFlags) -> ();


/// `vkCmdSetCullModeEXT` = `vkCmdSetCullMode`
pub type PFN_vkCmdSetCullModeEXT = PFN_vkCmdSetCullMode;

/// `vkCmdSetCullModeEXT` = `vkCmdSetCullMode`
pub type FN_vkCmdSetCullModeEXT = FN_vkCmdSetCullMode;

/// `vkCmdSetDepthBias`
pub type PFN_vkCmdSetDepthBias = Option<FN_vkCmdSetDepthBias>;

/// `vkCmdSetDepthBias`
pub type FN_vkCmdSetDepthBias = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, depthBiasConstantFactor: float, depthBiasClamp: float, depthBiasSlopeFactor: float) -> ();


/// `vkCmdSetDepthBias2EXT`
pub type PFN_vkCmdSetDepthBias2EXT = Option<FN_vkCmdSetDepthBias2EXT>;

/// `vkCmdSetDepthBias2EXT`
pub type FN_vkCmdSetDepthBias2EXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pDepthBiasInfo: *const VkDepthBiasInfoEXT) -> ();


/// `vkCmdSetDepthBiasEnable`
pub type PFN_vkCmdSetDepthBiasEnable = Option<FN_vkCmdSetDepthBiasEnable>;

/// `vkCmdSetDepthBiasEnable`
pub type FN_vkCmdSetDepthBiasEnable = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, depthBiasEnable: VkBool32) -> ();


/// `vkCmdSetDepthBiasEnableEXT` = `vkCmdSetDepthBiasEnable`
pub type PFN_vkCmdSetDepthBiasEnableEXT = PFN_vkCmdSetDepthBiasEnable;

/// `vkCmdSetDepthBiasEnableEXT` = `vkCmdSetDepthBiasEnable`
pub type FN_vkCmdSetDepthBiasEnableEXT = FN_vkCmdSetDepthBiasEnable;

/// `vkCmdSetDepthBounds`
pub type PFN_vkCmdSetDepthBounds = Option<FN_vkCmdSetDepthBounds>;

/// `vkCmdSetDepthBounds`
pub type FN_vkCmdSetDepthBounds = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, minDepthBounds: float, maxDepthBounds: float) -> ();


/// `vkCmdSetDepthBoundsTestEnable`
pub type PFN_vkCmdSetDepthBoundsTestEnable = Option<FN_vkCmdSetDepthBoundsTestEnable>;

/// `vkCmdSetDepthBoundsTestEnable`
pub type FN_vkCmdSetDepthBoundsTestEnable = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, depthBoundsTestEnable: VkBool32) -> ();


/// `vkCmdSetDepthBoundsTestEnableEXT` = `vkCmdSetDepthBoundsTestEnable`
pub type PFN_vkCmdSetDepthBoundsTestEnableEXT = PFN_vkCmdSetDepthBoundsTestEnable;

/// `vkCmdSetDepthBoundsTestEnableEXT` = `vkCmdSetDepthBoundsTestEnable`
pub type FN_vkCmdSetDepthBoundsTestEnableEXT = FN_vkCmdSetDepthBoundsTestEnable;

/// `vkCmdSetDepthClampEnableEXT`
pub type PFN_vkCmdSetDepthClampEnableEXT = Option<FN_vkCmdSetDepthClampEnableEXT>;

/// `vkCmdSetDepthClampEnableEXT`
pub type FN_vkCmdSetDepthClampEnableEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, depthClampEnable: VkBool32) -> ();


/// `vkCmdSetDepthClampRangeEXT`
pub type PFN_vkCmdSetDepthClampRangeEXT = Option<FN_vkCmdSetDepthClampRangeEXT>;

/// `vkCmdSetDepthClampRangeEXT`
pub type FN_vkCmdSetDepthClampRangeEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, depthClampMode: VkDepthClampModeEXT, pDepthClampRange: *const VkDepthClampRangeEXT) -> ();


/// `vkCmdSetDepthClipEnableEXT`
pub type PFN_vkCmdSetDepthClipEnableEXT = Option<FN_vkCmdSetDepthClipEnableEXT>;

/// `vkCmdSetDepthClipEnableEXT`
pub type FN_vkCmdSetDepthClipEnableEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, depthClipEnable: VkBool32) -> ();


/// `vkCmdSetDepthClipNegativeOneToOneEXT`
pub type PFN_vkCmdSetDepthClipNegativeOneToOneEXT = Option<FN_vkCmdSetDepthClipNegativeOneToOneEXT>;

/// `vkCmdSetDepthClipNegativeOneToOneEXT`
pub type FN_vkCmdSetDepthClipNegativeOneToOneEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, negativeOneToOne: VkBool32) -> ();


/// `vkCmdSetDepthCompareOp`
pub type PFN_vkCmdSetDepthCompareOp = Option<FN_vkCmdSetDepthCompareOp>;

/// `vkCmdSetDepthCompareOp`
pub type FN_vkCmdSetDepthCompareOp = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, depthCompareOp: VkCompareOp) -> ();


/// `vkCmdSetDepthCompareOpEXT` = `vkCmdSetDepthCompareOp`
pub type PFN_vkCmdSetDepthCompareOpEXT = PFN_vkCmdSetDepthCompareOp;

/// `vkCmdSetDepthCompareOpEXT` = `vkCmdSetDepthCompareOp`
pub type FN_vkCmdSetDepthCompareOpEXT = FN_vkCmdSetDepthCompareOp;

/// `vkCmdSetDepthTestEnable`
pub type PFN_vkCmdSetDepthTestEnable = Option<FN_vkCmdSetDepthTestEnable>;

/// `vkCmdSetDepthTestEnable`
pub type FN_vkCmdSetDepthTestEnable = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, depthTestEnable: VkBool32) -> ();


/// `vkCmdSetDepthTestEnableEXT` = `vkCmdSetDepthTestEnable`
pub type PFN_vkCmdSetDepthTestEnableEXT = PFN_vkCmdSetDepthTestEnable;

/// `vkCmdSetDepthTestEnableEXT` = `vkCmdSetDepthTestEnable`
pub type FN_vkCmdSetDepthTestEnableEXT = FN_vkCmdSetDepthTestEnable;

/// `vkCmdSetDepthWriteEnable`
pub type PFN_vkCmdSetDepthWriteEnable = Option<FN_vkCmdSetDepthWriteEnable>;

/// `vkCmdSetDepthWriteEnable`
pub type FN_vkCmdSetDepthWriteEnable = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, depthWriteEnable: VkBool32) -> ();


/// `vkCmdSetDepthWriteEnableEXT` = `vkCmdSetDepthWriteEnable`
pub type PFN_vkCmdSetDepthWriteEnableEXT = PFN_vkCmdSetDepthWriteEnable;

/// `vkCmdSetDepthWriteEnableEXT` = `vkCmdSetDepthWriteEnable`
pub type FN_vkCmdSetDepthWriteEnableEXT = FN_vkCmdSetDepthWriteEnable;

/// `vkCmdSetDescriptorBufferOffsets2EXT`
pub type PFN_vkCmdSetDescriptorBufferOffsets2EXT = Option<FN_vkCmdSetDescriptorBufferOffsets2EXT>;

/// `vkCmdSetDescriptorBufferOffsets2EXT`
pub type FN_vkCmdSetDescriptorBufferOffsets2EXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pSetDescriptorBufferOffsetsInfo: *const VkSetDescriptorBufferOffsetsInfoEXT) -> ();


/// `vkCmdSetDescriptorBufferOffsetsEXT`
pub type PFN_vkCmdSetDescriptorBufferOffsetsEXT = Option<FN_vkCmdSetDescriptorBufferOffsetsEXT>;

/// `vkCmdSetDescriptorBufferOffsetsEXT`
pub type FN_vkCmdSetDescriptorBufferOffsetsEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, layout: VkPipelineLayout, firstSet: uint32_t, setCount: uint32_t, pBufferIndices: *const uint32_t, pOffsets: *const VkDeviceSize) -> ();


/// `vkCmdSetDeviceMask`
pub type PFN_vkCmdSetDeviceMask = Option<FN_vkCmdSetDeviceMask>;

/// `vkCmdSetDeviceMask`
pub type FN_vkCmdSetDeviceMask = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, deviceMask: uint32_t) -> ();


/// `vkCmdSetDeviceMaskKHR` = `vkCmdSetDeviceMask`
pub type PFN_vkCmdSetDeviceMaskKHR = PFN_vkCmdSetDeviceMask;

/// `vkCmdSetDeviceMaskKHR` = `vkCmdSetDeviceMask`
pub type FN_vkCmdSetDeviceMaskKHR = FN_vkCmdSetDeviceMask;

/// `vkCmdSetDiscardRectangleEnableEXT`
pub type PFN_vkCmdSetDiscardRectangleEnableEXT = Option<FN_vkCmdSetDiscardRectangleEnableEXT>;

/// `vkCmdSetDiscardRectangleEnableEXT`
pub type FN_vkCmdSetDiscardRectangleEnableEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, discardRectangleEnable: VkBool32) -> ();


/// `vkCmdSetDiscardRectangleEXT`
pub type PFN_vkCmdSetDiscardRectangleEXT = Option<FN_vkCmdSetDiscardRectangleEXT>;

/// `vkCmdSetDiscardRectangleEXT`
pub type FN_vkCmdSetDiscardRectangleEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, firstDiscardRectangle: uint32_t, discardRectangleCount: uint32_t, pDiscardRectangles: *const VkRect2D) -> ();


/// `vkCmdSetDiscardRectangleModeEXT`
pub type PFN_vkCmdSetDiscardRectangleModeEXT = Option<FN_vkCmdSetDiscardRectangleModeEXT>;

/// `vkCmdSetDiscardRectangleModeEXT`
pub type FN_vkCmdSetDiscardRectangleModeEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, discardRectangleMode: VkDiscardRectangleModeEXT) -> ();


/// `vkCmdSetEvent`
pub type PFN_vkCmdSetEvent = Option<FN_vkCmdSetEvent>;

/// `vkCmdSetEvent`
pub type FN_vkCmdSetEvent = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, event: VkEvent, stageMask: VkPipelineStageFlags) -> ();


/// `vkCmdSetEvent2`
pub type PFN_vkCmdSetEvent2 = Option<FN_vkCmdSetEvent2>;

/// `vkCmdSetEvent2`
pub type FN_vkCmdSetEvent2 = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, event: VkEvent, pDependencyInfo: *const VkDependencyInfo) -> ();


/// `vkCmdSetEvent2KHR` = `vkCmdSetEvent2`
pub type PFN_vkCmdSetEvent2KHR = PFN_vkCmdSetEvent2;

/// `vkCmdSetEvent2KHR` = `vkCmdSetEvent2`
pub type FN_vkCmdSetEvent2KHR = FN_vkCmdSetEvent2;

/// `vkCmdSetExclusiveScissorEnableNV`
pub type PFN_vkCmdSetExclusiveScissorEnableNV = Option<FN_vkCmdSetExclusiveScissorEnableNV>;

/// `vkCmdSetExclusiveScissorEnableNV`
pub type FN_vkCmdSetExclusiveScissorEnableNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, firstExclusiveScissor: uint32_t, exclusiveScissorCount: uint32_t, pExclusiveScissorEnables: *const VkBool32) -> ();


/// `vkCmdSetExclusiveScissorNV`
pub type PFN_vkCmdSetExclusiveScissorNV = Option<FN_vkCmdSetExclusiveScissorNV>;

/// `vkCmdSetExclusiveScissorNV`
pub type FN_vkCmdSetExclusiveScissorNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, firstExclusiveScissor: uint32_t, exclusiveScissorCount: uint32_t, pExclusiveScissors: *const VkRect2D) -> ();


/// `vkCmdSetExtraPrimitiveOverestimationSizeEXT`
pub type PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT = Option<FN_vkCmdSetExtraPrimitiveOverestimationSizeEXT>;

/// `vkCmdSetExtraPrimitiveOverestimationSizeEXT`
pub type FN_vkCmdSetExtraPrimitiveOverestimationSizeEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, extraPrimitiveOverestimationSize: float) -> ();


/// `vkCmdSetFragmentShadingRateEnumNV`
pub type PFN_vkCmdSetFragmentShadingRateEnumNV = Option<FN_vkCmdSetFragmentShadingRateEnumNV>;

/// `vkCmdSetFragmentShadingRateEnumNV`
pub type FN_vkCmdSetFragmentShadingRateEnumNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, shadingRate: VkFragmentShadingRateNV, combinerOps: *const VkFragmentShadingRateCombinerOpKHR) -> ();


/// `vkCmdSetFragmentShadingRateKHR`
pub type PFN_vkCmdSetFragmentShadingRateKHR = Option<FN_vkCmdSetFragmentShadingRateKHR>;

/// `vkCmdSetFragmentShadingRateKHR`
pub type FN_vkCmdSetFragmentShadingRateKHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pFragmentSize: *const VkExtent2D, combinerOps: *const VkFragmentShadingRateCombinerOpKHR) -> ();


/// `vkCmdSetFrontFace`
pub type PFN_vkCmdSetFrontFace = Option<FN_vkCmdSetFrontFace>;

/// `vkCmdSetFrontFace`
pub type FN_vkCmdSetFrontFace = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, frontFace: VkFrontFace) -> ();


/// `vkCmdSetFrontFaceEXT` = `vkCmdSetFrontFace`
pub type PFN_vkCmdSetFrontFaceEXT = PFN_vkCmdSetFrontFace;

/// `vkCmdSetFrontFaceEXT` = `vkCmdSetFrontFace`
pub type FN_vkCmdSetFrontFaceEXT = FN_vkCmdSetFrontFace;

/// `vkCmdSetLineRasterizationModeEXT`
pub type PFN_vkCmdSetLineRasterizationModeEXT = Option<FN_vkCmdSetLineRasterizationModeEXT>;

/// `vkCmdSetLineRasterizationModeEXT`
pub type FN_vkCmdSetLineRasterizationModeEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, lineRasterizationMode: VkLineRasterizationModeEXT) -> ();


/// `vkCmdSetLineStipple`
pub type PFN_vkCmdSetLineStipple = Option<FN_vkCmdSetLineStipple>;

/// `vkCmdSetLineStipple`
pub type FN_vkCmdSetLineStipple = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, lineStippleFactor: uint32_t, lineStipplePattern: uint16_t) -> ();


/// `vkCmdSetLineStippleEnableEXT`
pub type PFN_vkCmdSetLineStippleEnableEXT = Option<FN_vkCmdSetLineStippleEnableEXT>;

/// `vkCmdSetLineStippleEnableEXT`
pub type FN_vkCmdSetLineStippleEnableEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, stippledLineEnable: VkBool32) -> ();


/// `vkCmdSetLineStippleEXT` = `vkCmdSetLineStipple`
pub type PFN_vkCmdSetLineStippleEXT = PFN_vkCmdSetLineStipple;

/// `vkCmdSetLineStippleEXT` = `vkCmdSetLineStipple`
pub type FN_vkCmdSetLineStippleEXT = FN_vkCmdSetLineStipple;

/// `vkCmdSetLineStippleKHR` = `vkCmdSetLineStipple`
pub type PFN_vkCmdSetLineStippleKHR = PFN_vkCmdSetLineStipple;

/// `vkCmdSetLineStippleKHR` = `vkCmdSetLineStipple`
pub type FN_vkCmdSetLineStippleKHR = FN_vkCmdSetLineStipple;

/// `vkCmdSetLineWidth`
pub type PFN_vkCmdSetLineWidth = Option<FN_vkCmdSetLineWidth>;

/// `vkCmdSetLineWidth`
pub type FN_vkCmdSetLineWidth = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, lineWidth: float) -> ();


/// `vkCmdSetLogicOpEnableEXT`
pub type PFN_vkCmdSetLogicOpEnableEXT = Option<FN_vkCmdSetLogicOpEnableEXT>;

/// `vkCmdSetLogicOpEnableEXT`
pub type FN_vkCmdSetLogicOpEnableEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, logicOpEnable: VkBool32) -> ();


/// `vkCmdSetLogicOpEXT`
pub type PFN_vkCmdSetLogicOpEXT = Option<FN_vkCmdSetLogicOpEXT>;

/// `vkCmdSetLogicOpEXT`
pub type FN_vkCmdSetLogicOpEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, logicOp: VkLogicOp) -> ();


/// `vkCmdSetPatchControlPointsEXT`
pub type PFN_vkCmdSetPatchControlPointsEXT = Option<FN_vkCmdSetPatchControlPointsEXT>;

/// `vkCmdSetPatchControlPointsEXT`
pub type FN_vkCmdSetPatchControlPointsEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, patchControlPoints: uint32_t) -> ();


/// `vkCmdSetPerformanceMarkerINTEL`
pub type PFN_vkCmdSetPerformanceMarkerINTEL = Option<FN_vkCmdSetPerformanceMarkerINTEL>;

/// `vkCmdSetPerformanceMarkerINTEL`
pub type FN_vkCmdSetPerformanceMarkerINTEL = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pMarkerInfo: *const VkPerformanceMarkerInfoINTEL) -> VkResult;


/// `vkCmdSetPerformanceOverrideINTEL`
pub type PFN_vkCmdSetPerformanceOverrideINTEL = Option<FN_vkCmdSetPerformanceOverrideINTEL>;

/// `vkCmdSetPerformanceOverrideINTEL`
pub type FN_vkCmdSetPerformanceOverrideINTEL = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pOverrideInfo: *const VkPerformanceOverrideInfoINTEL) -> VkResult;


/// `vkCmdSetPerformanceStreamMarkerINTEL`
pub type PFN_vkCmdSetPerformanceStreamMarkerINTEL = Option<FN_vkCmdSetPerformanceStreamMarkerINTEL>;

/// `vkCmdSetPerformanceStreamMarkerINTEL`
pub type FN_vkCmdSetPerformanceStreamMarkerINTEL = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pMarkerInfo: *const VkPerformanceStreamMarkerInfoINTEL) -> VkResult;


/// `vkCmdSetPolygonModeEXT`
pub type PFN_vkCmdSetPolygonModeEXT = Option<FN_vkCmdSetPolygonModeEXT>;

/// `vkCmdSetPolygonModeEXT`
pub type FN_vkCmdSetPolygonModeEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, polygonMode: VkPolygonMode) -> ();


/// `vkCmdSetPrimitiveRestartEnable`
pub type PFN_vkCmdSetPrimitiveRestartEnable = Option<FN_vkCmdSetPrimitiveRestartEnable>;

/// `vkCmdSetPrimitiveRestartEnable`
pub type FN_vkCmdSetPrimitiveRestartEnable = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, primitiveRestartEnable: VkBool32) -> ();


/// `vkCmdSetPrimitiveRestartEnableEXT` = `vkCmdSetPrimitiveRestartEnable`
pub type PFN_vkCmdSetPrimitiveRestartEnableEXT = PFN_vkCmdSetPrimitiveRestartEnable;

/// `vkCmdSetPrimitiveRestartEnableEXT` = `vkCmdSetPrimitiveRestartEnable`
pub type FN_vkCmdSetPrimitiveRestartEnableEXT = FN_vkCmdSetPrimitiveRestartEnable;

/// `vkCmdSetPrimitiveTopology`
pub type PFN_vkCmdSetPrimitiveTopology = Option<FN_vkCmdSetPrimitiveTopology>;

/// `vkCmdSetPrimitiveTopology`
pub type FN_vkCmdSetPrimitiveTopology = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, primitiveTopology: VkPrimitiveTopology) -> ();


/// `vkCmdSetPrimitiveTopologyEXT` = `vkCmdSetPrimitiveTopology`
pub type PFN_vkCmdSetPrimitiveTopologyEXT = PFN_vkCmdSetPrimitiveTopology;

/// `vkCmdSetPrimitiveTopologyEXT` = `vkCmdSetPrimitiveTopology`
pub type FN_vkCmdSetPrimitiveTopologyEXT = FN_vkCmdSetPrimitiveTopology;

/// `vkCmdSetProvokingVertexModeEXT`
pub type PFN_vkCmdSetProvokingVertexModeEXT = Option<FN_vkCmdSetProvokingVertexModeEXT>;

/// `vkCmdSetProvokingVertexModeEXT`
pub type FN_vkCmdSetProvokingVertexModeEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, provokingVertexMode: VkProvokingVertexModeEXT) -> ();


/// `vkCmdSetRasterizationSamplesEXT`
pub type PFN_vkCmdSetRasterizationSamplesEXT = Option<FN_vkCmdSetRasterizationSamplesEXT>;

/// `vkCmdSetRasterizationSamplesEXT`
pub type FN_vkCmdSetRasterizationSamplesEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, rasterizationSamples: VkSampleCountFlags) -> ();


/// `vkCmdSetRasterizationStreamEXT`
pub type PFN_vkCmdSetRasterizationStreamEXT = Option<FN_vkCmdSetRasterizationStreamEXT>;

/// `vkCmdSetRasterizationStreamEXT`
pub type FN_vkCmdSetRasterizationStreamEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, rasterizationStream: uint32_t) -> ();


/// `vkCmdSetRasterizerDiscardEnable`
pub type PFN_vkCmdSetRasterizerDiscardEnable = Option<FN_vkCmdSetRasterizerDiscardEnable>;

/// `vkCmdSetRasterizerDiscardEnable`
pub type FN_vkCmdSetRasterizerDiscardEnable = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, rasterizerDiscardEnable: VkBool32) -> ();


/// `vkCmdSetRasterizerDiscardEnableEXT` = `vkCmdSetRasterizerDiscardEnable`
pub type PFN_vkCmdSetRasterizerDiscardEnableEXT = PFN_vkCmdSetRasterizerDiscardEnable;

/// `vkCmdSetRasterizerDiscardEnableEXT` = `vkCmdSetRasterizerDiscardEnable`
pub type FN_vkCmdSetRasterizerDiscardEnableEXT = FN_vkCmdSetRasterizerDiscardEnable;

/// `vkCmdSetRayTracingPipelineStackSizeKHR`
pub type PFN_vkCmdSetRayTracingPipelineStackSizeKHR = Option<FN_vkCmdSetRayTracingPipelineStackSizeKHR>;

/// `vkCmdSetRayTracingPipelineStackSizeKHR`
pub type FN_vkCmdSetRayTracingPipelineStackSizeKHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pipelineStackSize: uint32_t) -> ();


/// `vkCmdSetRenderingAttachmentLocations`
pub type PFN_vkCmdSetRenderingAttachmentLocations = Option<FN_vkCmdSetRenderingAttachmentLocations>;

/// `vkCmdSetRenderingAttachmentLocations`
pub type FN_vkCmdSetRenderingAttachmentLocations = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pLocationInfo: *const VkRenderingAttachmentLocationInfo) -> ();


/// `vkCmdSetRenderingAttachmentLocationsKHR` = `vkCmdSetRenderingAttachmentLocations`
pub type PFN_vkCmdSetRenderingAttachmentLocationsKHR = PFN_vkCmdSetRenderingAttachmentLocations;

/// `vkCmdSetRenderingAttachmentLocationsKHR` = `vkCmdSetRenderingAttachmentLocations`
pub type FN_vkCmdSetRenderingAttachmentLocationsKHR = FN_vkCmdSetRenderingAttachmentLocations;

/// `vkCmdSetRenderingInputAttachmentIndices`
pub type PFN_vkCmdSetRenderingInputAttachmentIndices = Option<FN_vkCmdSetRenderingInputAttachmentIndices>;

/// `vkCmdSetRenderingInputAttachmentIndices`
pub type FN_vkCmdSetRenderingInputAttachmentIndices = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pInputAttachmentIndexInfo: *const VkRenderingInputAttachmentIndexInfo) -> ();


/// `vkCmdSetRenderingInputAttachmentIndicesKHR` = `vkCmdSetRenderingInputAttachmentIndices`
pub type PFN_vkCmdSetRenderingInputAttachmentIndicesKHR = PFN_vkCmdSetRenderingInputAttachmentIndices;

/// `vkCmdSetRenderingInputAttachmentIndicesKHR` = `vkCmdSetRenderingInputAttachmentIndices`
pub type FN_vkCmdSetRenderingInputAttachmentIndicesKHR = FN_vkCmdSetRenderingInputAttachmentIndices;

/// `vkCmdSetRepresentativeFragmentTestEnableNV`
pub type PFN_vkCmdSetRepresentativeFragmentTestEnableNV = Option<FN_vkCmdSetRepresentativeFragmentTestEnableNV>;

/// `vkCmdSetRepresentativeFragmentTestEnableNV`
pub type FN_vkCmdSetRepresentativeFragmentTestEnableNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, representativeFragmentTestEnable: VkBool32) -> ();


/// `vkCmdSetSampleLocationsEnableEXT`
pub type PFN_vkCmdSetSampleLocationsEnableEXT = Option<FN_vkCmdSetSampleLocationsEnableEXT>;

/// `vkCmdSetSampleLocationsEnableEXT`
pub type FN_vkCmdSetSampleLocationsEnableEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, sampleLocationsEnable: VkBool32) -> ();


/// `vkCmdSetSampleLocationsEXT`
pub type PFN_vkCmdSetSampleLocationsEXT = Option<FN_vkCmdSetSampleLocationsEXT>;

/// `vkCmdSetSampleLocationsEXT`
pub type FN_vkCmdSetSampleLocationsEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pSampleLocationsInfo: *const VkSampleLocationsInfoEXT) -> ();


/// `vkCmdSetSampleMaskEXT`
pub type PFN_vkCmdSetSampleMaskEXT = Option<FN_vkCmdSetSampleMaskEXT>;

/// `vkCmdSetSampleMaskEXT`
pub type FN_vkCmdSetSampleMaskEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, samples: VkSampleCountFlags, pSampleMask: *const VkSampleMask) -> ();


/// `vkCmdSetScissor`
pub type PFN_vkCmdSetScissor = Option<FN_vkCmdSetScissor>;

/// `vkCmdSetScissor`
pub type FN_vkCmdSetScissor = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, firstScissor: uint32_t, scissorCount: uint32_t, pScissors: *const VkRect2D) -> ();


/// `vkCmdSetScissorWithCount`
pub type PFN_vkCmdSetScissorWithCount = Option<FN_vkCmdSetScissorWithCount>;

/// `vkCmdSetScissorWithCount`
pub type FN_vkCmdSetScissorWithCount = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, scissorCount: uint32_t, pScissors: *const VkRect2D) -> ();


/// `vkCmdSetScissorWithCountEXT` = `vkCmdSetScissorWithCount`
pub type PFN_vkCmdSetScissorWithCountEXT = PFN_vkCmdSetScissorWithCount;

/// `vkCmdSetScissorWithCountEXT` = `vkCmdSetScissorWithCount`
pub type FN_vkCmdSetScissorWithCountEXT = FN_vkCmdSetScissorWithCount;

/// `vkCmdSetShadingRateImageEnableNV`
pub type PFN_vkCmdSetShadingRateImageEnableNV = Option<FN_vkCmdSetShadingRateImageEnableNV>;

/// `vkCmdSetShadingRateImageEnableNV`
pub type FN_vkCmdSetShadingRateImageEnableNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, shadingRateImageEnable: VkBool32) -> ();


/// `vkCmdSetStencilCompareMask`
pub type PFN_vkCmdSetStencilCompareMask = Option<FN_vkCmdSetStencilCompareMask>;

/// `vkCmdSetStencilCompareMask`
pub type FN_vkCmdSetStencilCompareMask = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, faceMask: VkStencilFaceFlags, compareMask: uint32_t) -> ();


/// `vkCmdSetStencilOp`
pub type PFN_vkCmdSetStencilOp = Option<FN_vkCmdSetStencilOp>;

/// `vkCmdSetStencilOp`
pub type FN_vkCmdSetStencilOp = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, faceMask: VkStencilFaceFlags, failOp: VkStencilOp, passOp: VkStencilOp, depthFailOp: VkStencilOp, compareOp: VkCompareOp) -> ();


/// `vkCmdSetStencilOpEXT` = `vkCmdSetStencilOp`
pub type PFN_vkCmdSetStencilOpEXT = PFN_vkCmdSetStencilOp;

/// `vkCmdSetStencilOpEXT` = `vkCmdSetStencilOp`
pub type FN_vkCmdSetStencilOpEXT = FN_vkCmdSetStencilOp;

/// `vkCmdSetStencilReference`
pub type PFN_vkCmdSetStencilReference = Option<FN_vkCmdSetStencilReference>;

/// `vkCmdSetStencilReference`
pub type FN_vkCmdSetStencilReference = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, faceMask: VkStencilFaceFlags, reference: uint32_t) -> ();


/// `vkCmdSetStencilTestEnable`
pub type PFN_vkCmdSetStencilTestEnable = Option<FN_vkCmdSetStencilTestEnable>;

/// `vkCmdSetStencilTestEnable`
pub type FN_vkCmdSetStencilTestEnable = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, stencilTestEnable: VkBool32) -> ();


/// `vkCmdSetStencilTestEnableEXT` = `vkCmdSetStencilTestEnable`
pub type PFN_vkCmdSetStencilTestEnableEXT = PFN_vkCmdSetStencilTestEnable;

/// `vkCmdSetStencilTestEnableEXT` = `vkCmdSetStencilTestEnable`
pub type FN_vkCmdSetStencilTestEnableEXT = FN_vkCmdSetStencilTestEnable;

/// `vkCmdSetStencilWriteMask`
pub type PFN_vkCmdSetStencilWriteMask = Option<FN_vkCmdSetStencilWriteMask>;

/// `vkCmdSetStencilWriteMask`
pub type FN_vkCmdSetStencilWriteMask = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, faceMask: VkStencilFaceFlags, writeMask: uint32_t) -> ();


/// `vkCmdSetTessellationDomainOriginEXT`
pub type PFN_vkCmdSetTessellationDomainOriginEXT = Option<FN_vkCmdSetTessellationDomainOriginEXT>;

/// `vkCmdSetTessellationDomainOriginEXT`
pub type FN_vkCmdSetTessellationDomainOriginEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, domainOrigin: VkTessellationDomainOrigin) -> ();


/// `vkCmdSetVertexInputEXT`
pub type PFN_vkCmdSetVertexInputEXT = Option<FN_vkCmdSetVertexInputEXT>;

/// `vkCmdSetVertexInputEXT`
pub type FN_vkCmdSetVertexInputEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, vertexBindingDescriptionCount: uint32_t, pVertexBindingDescriptions: *const VkVertexInputBindingDescription2EXT, vertexAttributeDescriptionCount: uint32_t, pVertexAttributeDescriptions: *const VkVertexInputAttributeDescription2EXT) -> ();


/// `vkCmdSetViewport`
pub type PFN_vkCmdSetViewport = Option<FN_vkCmdSetViewport>;

/// `vkCmdSetViewport`
pub type FN_vkCmdSetViewport = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, firstViewport: uint32_t, viewportCount: uint32_t, pViewports: *const VkViewport) -> ();


/// `vkCmdSetViewportShadingRatePaletteNV`
pub type PFN_vkCmdSetViewportShadingRatePaletteNV = Option<FN_vkCmdSetViewportShadingRatePaletteNV>;

/// `vkCmdSetViewportShadingRatePaletteNV`
pub type FN_vkCmdSetViewportShadingRatePaletteNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, firstViewport: uint32_t, viewportCount: uint32_t, pShadingRatePalettes: *const VkShadingRatePaletteNV) -> ();


/// `vkCmdSetViewportSwizzleNV`
pub type PFN_vkCmdSetViewportSwizzleNV = Option<FN_vkCmdSetViewportSwizzleNV>;

/// `vkCmdSetViewportSwizzleNV`
pub type FN_vkCmdSetViewportSwizzleNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, firstViewport: uint32_t, viewportCount: uint32_t, pViewportSwizzles: *const VkViewportSwizzleNV) -> ();


/// `vkCmdSetViewportWithCount`
pub type PFN_vkCmdSetViewportWithCount = Option<FN_vkCmdSetViewportWithCount>;

/// `vkCmdSetViewportWithCount`
pub type FN_vkCmdSetViewportWithCount = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, viewportCount: uint32_t, pViewports: *const VkViewport) -> ();


/// `vkCmdSetViewportWithCountEXT` = `vkCmdSetViewportWithCount`
pub type PFN_vkCmdSetViewportWithCountEXT = PFN_vkCmdSetViewportWithCount;

/// `vkCmdSetViewportWithCountEXT` = `vkCmdSetViewportWithCount`
pub type FN_vkCmdSetViewportWithCountEXT = FN_vkCmdSetViewportWithCount;

/// `vkCmdSetViewportWScalingEnableNV`
pub type PFN_vkCmdSetViewportWScalingEnableNV = Option<FN_vkCmdSetViewportWScalingEnableNV>;

/// `vkCmdSetViewportWScalingEnableNV`
pub type FN_vkCmdSetViewportWScalingEnableNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, viewportWScalingEnable: VkBool32) -> ();


/// `vkCmdSetViewportWScalingNV`
pub type PFN_vkCmdSetViewportWScalingNV = Option<FN_vkCmdSetViewportWScalingNV>;

/// `vkCmdSetViewportWScalingNV`
pub type FN_vkCmdSetViewportWScalingNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, firstViewport: uint32_t, viewportCount: uint32_t, pViewportWScalings: *const VkViewportWScalingNV) -> ();


/// `vkCmdSubpassShadingHUAWEI`
pub type PFN_vkCmdSubpassShadingHUAWEI = Option<FN_vkCmdSubpassShadingHUAWEI>;

/// `vkCmdSubpassShadingHUAWEI`
pub type FN_vkCmdSubpassShadingHUAWEI = unsafe extern "system" fn(commandBuffer: VkCommandBuffer) -> ();


/// `vkCmdTraceRaysIndirect2KHR`
pub type PFN_vkCmdTraceRaysIndirect2KHR = Option<FN_vkCmdTraceRaysIndirect2KHR>;

/// `vkCmdTraceRaysIndirect2KHR`
pub type FN_vkCmdTraceRaysIndirect2KHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, indirectDeviceAddress: VkDeviceAddress) -> ();


/// `vkCmdTraceRaysIndirectKHR`
pub type PFN_vkCmdTraceRaysIndirectKHR = Option<FN_vkCmdTraceRaysIndirectKHR>;

/// `vkCmdTraceRaysIndirectKHR`
pub type FN_vkCmdTraceRaysIndirectKHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pRaygenShaderBindingTable: *const VkStridedDeviceAddressRegionKHR, pMissShaderBindingTable: *const VkStridedDeviceAddressRegionKHR, pHitShaderBindingTable: *const VkStridedDeviceAddressRegionKHR, pCallableShaderBindingTable: *const VkStridedDeviceAddressRegionKHR, indirectDeviceAddress: VkDeviceAddress) -> ();


/// `vkCmdTraceRaysKHR`
pub type PFN_vkCmdTraceRaysKHR = Option<FN_vkCmdTraceRaysKHR>;

/// `vkCmdTraceRaysKHR`
pub type FN_vkCmdTraceRaysKHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pRaygenShaderBindingTable: *const VkStridedDeviceAddressRegionKHR, pMissShaderBindingTable: *const VkStridedDeviceAddressRegionKHR, pHitShaderBindingTable: *const VkStridedDeviceAddressRegionKHR, pCallableShaderBindingTable: *const VkStridedDeviceAddressRegionKHR, width: uint32_t, height: uint32_t, depth: uint32_t) -> ();


/// `vkCmdTraceRaysNV`
pub type PFN_vkCmdTraceRaysNV = Option<FN_vkCmdTraceRaysNV>;

/// `vkCmdTraceRaysNV`
pub type FN_vkCmdTraceRaysNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, raygenShaderBindingTableBuffer: VkBuffer, raygenShaderBindingOffset: VkDeviceSize, missShaderBindingTableBuffer: VkBuffer, missShaderBindingOffset: VkDeviceSize, missShaderBindingStride: VkDeviceSize, hitShaderBindingTableBuffer: VkBuffer, hitShaderBindingOffset: VkDeviceSize, hitShaderBindingStride: VkDeviceSize, callableShaderBindingTableBuffer: VkBuffer, callableShaderBindingOffset: VkDeviceSize, callableShaderBindingStride: VkDeviceSize, width: uint32_t, height: uint32_t, depth: uint32_t) -> ();


/// `vkCmdUpdateBuffer`
pub type PFN_vkCmdUpdateBuffer = Option<FN_vkCmdUpdateBuffer>;

/// `vkCmdUpdateBuffer`
pub type FN_vkCmdUpdateBuffer = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, dstBuffer: VkBuffer, dstOffset: VkDeviceSize, dataSize: VkDeviceSize, pData: *const void) -> ();


/// `vkCmdUpdatePipelineIndirectBufferNV`
pub type PFN_vkCmdUpdatePipelineIndirectBufferNV = Option<FN_vkCmdUpdatePipelineIndirectBufferNV>;

/// `vkCmdUpdatePipelineIndirectBufferNV`
pub type FN_vkCmdUpdatePipelineIndirectBufferNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, pipeline: VkPipeline) -> ();


/// `vkCmdWaitEvents`
pub type PFN_vkCmdWaitEvents = Option<FN_vkCmdWaitEvents>;

/// `vkCmdWaitEvents`
pub type FN_vkCmdWaitEvents = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, eventCount: uint32_t, pEvents: *const VkEvent, srcStageMask: VkPipelineStageFlags, dstStageMask: VkPipelineStageFlags, memoryBarrierCount: uint32_t, pMemoryBarriers: *const VkMemoryBarrier, bufferMemoryBarrierCount: uint32_t, pBufferMemoryBarriers: *const VkBufferMemoryBarrier, imageMemoryBarrierCount: uint32_t, pImageMemoryBarriers: *const VkImageMemoryBarrier) -> ();


/// `vkCmdWaitEvents2`
pub type PFN_vkCmdWaitEvents2 = Option<FN_vkCmdWaitEvents2>;

/// `vkCmdWaitEvents2`
pub type FN_vkCmdWaitEvents2 = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, eventCount: uint32_t, pEvents: *const VkEvent, pDependencyInfos: *const VkDependencyInfo) -> ();


/// `vkCmdWaitEvents2KHR` = `vkCmdWaitEvents2`
pub type PFN_vkCmdWaitEvents2KHR = PFN_vkCmdWaitEvents2;

/// `vkCmdWaitEvents2KHR` = `vkCmdWaitEvents2`
pub type FN_vkCmdWaitEvents2KHR = FN_vkCmdWaitEvents2;

/// `vkCmdWriteAccelerationStructuresPropertiesKHR`
pub type PFN_vkCmdWriteAccelerationStructuresPropertiesKHR = Option<FN_vkCmdWriteAccelerationStructuresPropertiesKHR>;

/// `vkCmdWriteAccelerationStructuresPropertiesKHR`
pub type FN_vkCmdWriteAccelerationStructuresPropertiesKHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, accelerationStructureCount: uint32_t, pAccelerationStructures: *const VkAccelerationStructureKHR, queryType: VkQueryType, queryPool: VkQueryPool, firstQuery: uint32_t) -> ();


/// `vkCmdWriteAccelerationStructuresPropertiesNV`
pub type PFN_vkCmdWriteAccelerationStructuresPropertiesNV = Option<FN_vkCmdWriteAccelerationStructuresPropertiesNV>;

/// `vkCmdWriteAccelerationStructuresPropertiesNV`
pub type FN_vkCmdWriteAccelerationStructuresPropertiesNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, accelerationStructureCount: uint32_t, pAccelerationStructures: *const VkAccelerationStructureNV, queryType: VkQueryType, queryPool: VkQueryPool, firstQuery: uint32_t) -> ();


/// `vkCmdWriteBufferMarker2AMD`
pub type PFN_vkCmdWriteBufferMarker2AMD = Option<FN_vkCmdWriteBufferMarker2AMD>;

/// `vkCmdWriteBufferMarker2AMD`
pub type FN_vkCmdWriteBufferMarker2AMD = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, stage: VkPipelineStageFlags2, dstBuffer: VkBuffer, dstOffset: VkDeviceSize, marker: uint32_t) -> ();


/// `vkCmdWriteBufferMarkerAMD`
pub type PFN_vkCmdWriteBufferMarkerAMD = Option<FN_vkCmdWriteBufferMarkerAMD>;

/// `vkCmdWriteBufferMarkerAMD`
pub type FN_vkCmdWriteBufferMarkerAMD = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pipelineStage: VkPipelineStageFlags, dstBuffer: VkBuffer, dstOffset: VkDeviceSize, marker: uint32_t) -> ();


/// `vkCmdWriteMicromapsPropertiesEXT`
pub type PFN_vkCmdWriteMicromapsPropertiesEXT = Option<FN_vkCmdWriteMicromapsPropertiesEXT>;

/// `vkCmdWriteMicromapsPropertiesEXT`
pub type FN_vkCmdWriteMicromapsPropertiesEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, micromapCount: uint32_t, pMicromaps: *const VkMicromapEXT, queryType: VkQueryType, queryPool: VkQueryPool, firstQuery: uint32_t) -> ();


/// `vkCmdWriteTimestamp`
pub type PFN_vkCmdWriteTimestamp = Option<FN_vkCmdWriteTimestamp>;

/// `vkCmdWriteTimestamp`
pub type FN_vkCmdWriteTimestamp = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pipelineStage: VkPipelineStageFlags, queryPool: VkQueryPool, query: uint32_t) -> ();


/// `vkCmdWriteTimestamp2`
pub type PFN_vkCmdWriteTimestamp2 = Option<FN_vkCmdWriteTimestamp2>;

/// `vkCmdWriteTimestamp2`
pub type FN_vkCmdWriteTimestamp2 = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, stage: VkPipelineStageFlags2, queryPool: VkQueryPool, query: uint32_t) -> ();


/// `vkCmdWriteTimestamp2KHR` = `vkCmdWriteTimestamp2`
pub type PFN_vkCmdWriteTimestamp2KHR = PFN_vkCmdWriteTimestamp2;

/// `vkCmdWriteTimestamp2KHR` = `vkCmdWriteTimestamp2`
pub type FN_vkCmdWriteTimestamp2KHR = FN_vkCmdWriteTimestamp2;

/// `vkCompileDeferredNV`
pub type PFN_vkCompileDeferredNV = Option<FN_vkCompileDeferredNV>;

/// `vkCompileDeferredNV`
pub type FN_vkCompileDeferredNV = unsafe extern "system" fn(device: VkDevice, pipeline: VkPipeline, shader: uint32_t) -> VkResult;


/// `vkConvertCooperativeVectorMatrixNV`
pub type PFN_vkConvertCooperativeVectorMatrixNV = Option<FN_vkConvertCooperativeVectorMatrixNV>;

/// `vkConvertCooperativeVectorMatrixNV`
pub type FN_vkConvertCooperativeVectorMatrixNV = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkConvertCooperativeVectorMatrixInfoNV) -> VkResult;


/// `vkCopyAccelerationStructureKHR`
pub type PFN_vkCopyAccelerationStructureKHR = Option<FN_vkCopyAccelerationStructureKHR>;

/// `vkCopyAccelerationStructureKHR`
pub type FN_vkCopyAccelerationStructureKHR = unsafe extern "system" fn(device: VkDevice, deferredOperation: VkDeferredOperationKHR, pInfo: *const VkCopyAccelerationStructureInfoKHR) -> VkResult;


/// `vkCopyAccelerationStructureToMemoryKHR`
pub type PFN_vkCopyAccelerationStructureToMemoryKHR = Option<FN_vkCopyAccelerationStructureToMemoryKHR>;

/// `vkCopyAccelerationStructureToMemoryKHR`
pub type FN_vkCopyAccelerationStructureToMemoryKHR = unsafe extern "system" fn(device: VkDevice, deferredOperation: VkDeferredOperationKHR, pInfo: *const VkCopyAccelerationStructureToMemoryInfoKHR) -> VkResult;


/// `vkCopyImageToImage`
pub type PFN_vkCopyImageToImage = Option<FN_vkCopyImageToImage>;

/// `vkCopyImageToImage`
pub type FN_vkCopyImageToImage = unsafe extern "system" fn(device: VkDevice, pCopyImageToImageInfo: *const VkCopyImageToImageInfo) -> VkResult;


/// `vkCopyImageToImageEXT` = `vkCopyImageToImage`
pub type PFN_vkCopyImageToImageEXT = PFN_vkCopyImageToImage;

/// `vkCopyImageToImageEXT` = `vkCopyImageToImage`
pub type FN_vkCopyImageToImageEXT = FN_vkCopyImageToImage;

/// `vkCopyImageToMemory`
pub type PFN_vkCopyImageToMemory = Option<FN_vkCopyImageToMemory>;

/// `vkCopyImageToMemory`
pub type FN_vkCopyImageToMemory = unsafe extern "system" fn(device: VkDevice, pCopyImageToMemoryInfo: *const VkCopyImageToMemoryInfo) -> VkResult;


/// `vkCopyImageToMemoryEXT` = `vkCopyImageToMemory`
pub type PFN_vkCopyImageToMemoryEXT = PFN_vkCopyImageToMemory;

/// `vkCopyImageToMemoryEXT` = `vkCopyImageToMemory`
pub type FN_vkCopyImageToMemoryEXT = FN_vkCopyImageToMemory;

/// `vkCopyMemoryToAccelerationStructureKHR`
pub type PFN_vkCopyMemoryToAccelerationStructureKHR = Option<FN_vkCopyMemoryToAccelerationStructureKHR>;

/// `vkCopyMemoryToAccelerationStructureKHR`
pub type FN_vkCopyMemoryToAccelerationStructureKHR = unsafe extern "system" fn(device: VkDevice, deferredOperation: VkDeferredOperationKHR, pInfo: *const VkCopyMemoryToAccelerationStructureInfoKHR) -> VkResult;


/// `vkCopyMemoryToImage`
pub type PFN_vkCopyMemoryToImage = Option<FN_vkCopyMemoryToImage>;

/// `vkCopyMemoryToImage`
pub type FN_vkCopyMemoryToImage = unsafe extern "system" fn(device: VkDevice, pCopyMemoryToImageInfo: *const VkCopyMemoryToImageInfo) -> VkResult;


/// `vkCopyMemoryToImageEXT` = `vkCopyMemoryToImage`
pub type PFN_vkCopyMemoryToImageEXT = PFN_vkCopyMemoryToImage;

/// `vkCopyMemoryToImageEXT` = `vkCopyMemoryToImage`
pub type FN_vkCopyMemoryToImageEXT = FN_vkCopyMemoryToImage;

/// `vkCopyMemoryToMicromapEXT`
pub type PFN_vkCopyMemoryToMicromapEXT = Option<FN_vkCopyMemoryToMicromapEXT>;

/// `vkCopyMemoryToMicromapEXT`
pub type FN_vkCopyMemoryToMicromapEXT = unsafe extern "system" fn(device: VkDevice, deferredOperation: VkDeferredOperationKHR, pInfo: *const VkCopyMemoryToMicromapInfoEXT) -> VkResult;


/// `vkCopyMicromapEXT`
pub type PFN_vkCopyMicromapEXT = Option<FN_vkCopyMicromapEXT>;

/// `vkCopyMicromapEXT`
pub type FN_vkCopyMicromapEXT = unsafe extern "system" fn(device: VkDevice, deferredOperation: VkDeferredOperationKHR, pInfo: *const VkCopyMicromapInfoEXT) -> VkResult;


/// `vkCopyMicromapToMemoryEXT`
pub type PFN_vkCopyMicromapToMemoryEXT = Option<FN_vkCopyMicromapToMemoryEXT>;

/// `vkCopyMicromapToMemoryEXT`
pub type FN_vkCopyMicromapToMemoryEXT = unsafe extern "system" fn(device: VkDevice, deferredOperation: VkDeferredOperationKHR, pInfo: *const VkCopyMicromapToMemoryInfoEXT) -> VkResult;


/// `vkCreateAccelerationStructureKHR`
pub type PFN_vkCreateAccelerationStructureKHR = Option<FN_vkCreateAccelerationStructureKHR>;

/// `vkCreateAccelerationStructureKHR`
pub type FN_vkCreateAccelerationStructureKHR = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkAccelerationStructureCreateInfoKHR, pAllocator: *const VkAllocationCallbacks, pAccelerationStructure: *mut VkAccelerationStructureKHR) -> VkResult;


/// `vkCreateAccelerationStructureNV`
pub type PFN_vkCreateAccelerationStructureNV = Option<FN_vkCreateAccelerationStructureNV>;

/// `vkCreateAccelerationStructureNV`
pub type FN_vkCreateAccelerationStructureNV = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkAccelerationStructureCreateInfoNV, pAllocator: *const VkAllocationCallbacks, pAccelerationStructure: *mut VkAccelerationStructureNV) -> VkResult;


/// `vkCreateAndroidSurfaceKHR`
pub type PFN_vkCreateAndroidSurfaceKHR = Option<FN_vkCreateAndroidSurfaceKHR>;

/// `vkCreateAndroidSurfaceKHR`
pub type FN_vkCreateAndroidSurfaceKHR = unsafe extern "system" fn(instance: VkInstance, pCreateInfo: *const VkAndroidSurfaceCreateInfoKHR, pAllocator: *const VkAllocationCallbacks, pSurface: *mut VkSurfaceKHR) -> VkResult;


/// `vkCreateBuffer`
pub type PFN_vkCreateBuffer = Option<FN_vkCreateBuffer>;

/// `vkCreateBuffer`
pub type FN_vkCreateBuffer = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkBufferCreateInfo, pAllocator: *const VkAllocationCallbacks, pBuffer: *mut VkBuffer) -> VkResult;


/// `vkCreateBufferCollectionFUCHSIA`
pub type PFN_vkCreateBufferCollectionFUCHSIA = Option<FN_vkCreateBufferCollectionFUCHSIA>;

/// `vkCreateBufferCollectionFUCHSIA`
pub type FN_vkCreateBufferCollectionFUCHSIA = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkBufferCollectionCreateInfoFUCHSIA, pAllocator: *const VkAllocationCallbacks, pCollection: *mut VkBufferCollectionFUCHSIA) -> VkResult;


/// `vkCreateBufferView`
pub type PFN_vkCreateBufferView = Option<FN_vkCreateBufferView>;

/// `vkCreateBufferView`
pub type FN_vkCreateBufferView = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkBufferViewCreateInfo, pAllocator: *const VkAllocationCallbacks, pView: *mut VkBufferView) -> VkResult;


/// `vkCreateCommandPool`
pub type PFN_vkCreateCommandPool = Option<FN_vkCreateCommandPool>;

/// `vkCreateCommandPool`
pub type FN_vkCreateCommandPool = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkCommandPoolCreateInfo, pAllocator: *const VkAllocationCallbacks, pCommandPool: *mut VkCommandPool) -> VkResult;


/// `vkCreateComputePipelines`
pub type PFN_vkCreateComputePipelines = Option<FN_vkCreateComputePipelines>;

/// `vkCreateComputePipelines`
pub type FN_vkCreateComputePipelines = unsafe extern "system" fn(device: VkDevice, pipelineCache: VkPipelineCache, createInfoCount: uint32_t, pCreateInfos: *const VkComputePipelineCreateInfo, pAllocator: *const VkAllocationCallbacks, pPipelines: *mut VkPipeline) -> VkResult;


/// `vkCreateCudaFunctionNV`
pub type PFN_vkCreateCudaFunctionNV = Option<FN_vkCreateCudaFunctionNV>;

/// `vkCreateCudaFunctionNV`
pub type FN_vkCreateCudaFunctionNV = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkCudaFunctionCreateInfoNV, pAllocator: *const VkAllocationCallbacks, pFunction: *mut VkCudaFunctionNV) -> VkResult;


/// `vkCreateCudaModuleNV`
pub type PFN_vkCreateCudaModuleNV = Option<FN_vkCreateCudaModuleNV>;

/// `vkCreateCudaModuleNV`
pub type FN_vkCreateCudaModuleNV = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkCudaModuleCreateInfoNV, pAllocator: *const VkAllocationCallbacks, pModule: *mut VkCudaModuleNV) -> VkResult;


/// `vkCreateCuFunctionNVX`
pub type PFN_vkCreateCuFunctionNVX = Option<FN_vkCreateCuFunctionNVX>;

/// `vkCreateCuFunctionNVX`
pub type FN_vkCreateCuFunctionNVX = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkCuFunctionCreateInfoNVX, pAllocator: *const VkAllocationCallbacks, pFunction: *mut VkCuFunctionNVX) -> VkResult;


/// `vkCreateCuModuleNVX`
pub type PFN_vkCreateCuModuleNVX = Option<FN_vkCreateCuModuleNVX>;

/// `vkCreateCuModuleNVX`
pub type FN_vkCreateCuModuleNVX = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkCuModuleCreateInfoNVX, pAllocator: *const VkAllocationCallbacks, pModule: *mut VkCuModuleNVX) -> VkResult;


/// `vkCreateDataGraphPipelinesARM`
pub type PFN_vkCreateDataGraphPipelinesARM = Option<FN_vkCreateDataGraphPipelinesARM>;

/// `vkCreateDataGraphPipelinesARM`
pub type FN_vkCreateDataGraphPipelinesARM = unsafe extern "system" fn(device: VkDevice, deferredOperation: VkDeferredOperationKHR, pipelineCache: VkPipelineCache, createInfoCount: uint32_t, pCreateInfos: *const VkDataGraphPipelineCreateInfoARM, pAllocator: *const VkAllocationCallbacks, pPipelines: *mut VkPipeline) -> VkResult;


/// `vkCreateDataGraphPipelineSessionARM`
pub type PFN_vkCreateDataGraphPipelineSessionARM = Option<FN_vkCreateDataGraphPipelineSessionARM>;

/// `vkCreateDataGraphPipelineSessionARM`
pub type FN_vkCreateDataGraphPipelineSessionARM = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkDataGraphPipelineSessionCreateInfoARM, pAllocator: *const VkAllocationCallbacks, pSession: *mut VkDataGraphPipelineSessionARM) -> VkResult;


/// `vkCreateDebugReportCallbackEXT`
pub type PFN_vkCreateDebugReportCallbackEXT = Option<FN_vkCreateDebugReportCallbackEXT>;

/// `vkCreateDebugReportCallbackEXT`
pub type FN_vkCreateDebugReportCallbackEXT = unsafe extern "system" fn(instance: VkInstance, pCreateInfo: *const VkDebugReportCallbackCreateInfoEXT, pAllocator: *const VkAllocationCallbacks, pCallback: *mut VkDebugReportCallbackEXT) -> VkResult;


/// `vkCreateDebugUtilsMessengerEXT`
pub type PFN_vkCreateDebugUtilsMessengerEXT = Option<FN_vkCreateDebugUtilsMessengerEXT>;

/// `vkCreateDebugUtilsMessengerEXT`
pub type FN_vkCreateDebugUtilsMessengerEXT = unsafe extern "system" fn(instance: VkInstance, pCreateInfo: *const VkDebugUtilsMessengerCreateInfoEXT, pAllocator: *const VkAllocationCallbacks, pMessenger: *mut VkDebugUtilsMessengerEXT) -> VkResult;


/// `vkCreateDeferredOperationKHR`
pub type PFN_vkCreateDeferredOperationKHR = Option<FN_vkCreateDeferredOperationKHR>;

/// `vkCreateDeferredOperationKHR`
pub type FN_vkCreateDeferredOperationKHR = unsafe extern "system" fn(device: VkDevice, pAllocator: *const VkAllocationCallbacks, pDeferredOperation: *mut VkDeferredOperationKHR) -> VkResult;


/// `vkCreateDescriptorPool`
pub type PFN_vkCreateDescriptorPool = Option<FN_vkCreateDescriptorPool>;

/// `vkCreateDescriptorPool`
pub type FN_vkCreateDescriptorPool = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkDescriptorPoolCreateInfo, pAllocator: *const VkAllocationCallbacks, pDescriptorPool: *mut VkDescriptorPool) -> VkResult;


/// `vkCreateDescriptorSetLayout`
pub type PFN_vkCreateDescriptorSetLayout = Option<FN_vkCreateDescriptorSetLayout>;

/// `vkCreateDescriptorSetLayout`
pub type FN_vkCreateDescriptorSetLayout = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkDescriptorSetLayoutCreateInfo, pAllocator: *const VkAllocationCallbacks, pSetLayout: *mut VkDescriptorSetLayout) -> VkResult;


/// `vkCreateDescriptorUpdateTemplate`
pub type PFN_vkCreateDescriptorUpdateTemplate = Option<FN_vkCreateDescriptorUpdateTemplate>;

/// `vkCreateDescriptorUpdateTemplate`
pub type FN_vkCreateDescriptorUpdateTemplate = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkDescriptorUpdateTemplateCreateInfo, pAllocator: *const VkAllocationCallbacks, pDescriptorUpdateTemplate: *mut VkDescriptorUpdateTemplate) -> VkResult;


/// `vkCreateDescriptorUpdateTemplateKHR` = `vkCreateDescriptorUpdateTemplate`
pub type PFN_vkCreateDescriptorUpdateTemplateKHR = PFN_vkCreateDescriptorUpdateTemplate;

/// `vkCreateDescriptorUpdateTemplateKHR` = `vkCreateDescriptorUpdateTemplate`
pub type FN_vkCreateDescriptorUpdateTemplateKHR = FN_vkCreateDescriptorUpdateTemplate;

/// `vkCreateDevice`
pub type PFN_vkCreateDevice = Option<FN_vkCreateDevice>;

/// `vkCreateDevice`
pub type FN_vkCreateDevice = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pCreateInfo: *const VkDeviceCreateInfo, pAllocator: *const VkAllocationCallbacks, pDevice: *mut VkDevice) -> VkResult;


/// `vkCreateDirectFBSurfaceEXT`
pub type PFN_vkCreateDirectFBSurfaceEXT = Option<FN_vkCreateDirectFBSurfaceEXT>;

/// `vkCreateDirectFBSurfaceEXT`
pub type FN_vkCreateDirectFBSurfaceEXT = unsafe extern "system" fn(instance: VkInstance, pCreateInfo: *const VkDirectFBSurfaceCreateInfoEXT, pAllocator: *const VkAllocationCallbacks, pSurface: *mut VkSurfaceKHR) -> VkResult;


/// `vkCreateDisplayModeKHR`
pub type PFN_vkCreateDisplayModeKHR = Option<FN_vkCreateDisplayModeKHR>;

/// `vkCreateDisplayModeKHR`
pub type FN_vkCreateDisplayModeKHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, display: VkDisplayKHR, pCreateInfo: *const VkDisplayModeCreateInfoKHR, pAllocator: *const VkAllocationCallbacks, pMode: *mut VkDisplayModeKHR) -> VkResult;


/// `vkCreateDisplayPlaneSurfaceKHR`
pub type PFN_vkCreateDisplayPlaneSurfaceKHR = Option<FN_vkCreateDisplayPlaneSurfaceKHR>;

/// `vkCreateDisplayPlaneSurfaceKHR`
pub type FN_vkCreateDisplayPlaneSurfaceKHR = unsafe extern "system" fn(instance: VkInstance, pCreateInfo: *const VkDisplaySurfaceCreateInfoKHR, pAllocator: *const VkAllocationCallbacks, pSurface: *mut VkSurfaceKHR) -> VkResult;


/// `vkCreateEvent`
pub type PFN_vkCreateEvent = Option<FN_vkCreateEvent>;

/// `vkCreateEvent`
pub type FN_vkCreateEvent = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkEventCreateInfo, pAllocator: *const VkAllocationCallbacks, pEvent: *mut VkEvent) -> VkResult;


/// `vkCreateExecutionGraphPipelinesAMDX`
pub type PFN_vkCreateExecutionGraphPipelinesAMDX = Option<FN_vkCreateExecutionGraphPipelinesAMDX>;

/// `vkCreateExecutionGraphPipelinesAMDX`
pub type FN_vkCreateExecutionGraphPipelinesAMDX = unsafe extern "system" fn(device: VkDevice, pipelineCache: VkPipelineCache, createInfoCount: uint32_t, pCreateInfos: *const VkExecutionGraphPipelineCreateInfoAMDX, pAllocator: *const VkAllocationCallbacks, pPipelines: *mut VkPipeline) -> VkResult;


/// `vkCreateExternalComputeQueueNV`
pub type PFN_vkCreateExternalComputeQueueNV = Option<FN_vkCreateExternalComputeQueueNV>;

/// `vkCreateExternalComputeQueueNV`
pub type FN_vkCreateExternalComputeQueueNV = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkExternalComputeQueueCreateInfoNV, pAllocator: *const VkAllocationCallbacks, pExternalQueue: *mut VkExternalComputeQueueNV) -> VkResult;


/// `vkCreateFence`
pub type PFN_vkCreateFence = Option<FN_vkCreateFence>;

/// `vkCreateFence`
pub type FN_vkCreateFence = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkFenceCreateInfo, pAllocator: *const VkAllocationCallbacks, pFence: *mut VkFence) -> VkResult;


/// `vkCreateFramebuffer`
pub type PFN_vkCreateFramebuffer = Option<FN_vkCreateFramebuffer>;

/// `vkCreateFramebuffer`
pub type FN_vkCreateFramebuffer = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkFramebufferCreateInfo, pAllocator: *const VkAllocationCallbacks, pFramebuffer: *mut VkFramebuffer) -> VkResult;


/// `vkCreateGraphicsPipelines`
pub type PFN_vkCreateGraphicsPipelines = Option<FN_vkCreateGraphicsPipelines>;

/// `vkCreateGraphicsPipelines`
pub type FN_vkCreateGraphicsPipelines = unsafe extern "system" fn(device: VkDevice, pipelineCache: VkPipelineCache, createInfoCount: uint32_t, pCreateInfos: *const VkGraphicsPipelineCreateInfo, pAllocator: *const VkAllocationCallbacks, pPipelines: *mut VkPipeline) -> VkResult;


/// `vkCreateHeadlessSurfaceEXT`
pub type PFN_vkCreateHeadlessSurfaceEXT = Option<FN_vkCreateHeadlessSurfaceEXT>;

/// `vkCreateHeadlessSurfaceEXT`
pub type FN_vkCreateHeadlessSurfaceEXT = unsafe extern "system" fn(instance: VkInstance, pCreateInfo: *const VkHeadlessSurfaceCreateInfoEXT, pAllocator: *const VkAllocationCallbacks, pSurface: *mut VkSurfaceKHR) -> VkResult;


/// `vkCreateImage`
pub type PFN_vkCreateImage = Option<FN_vkCreateImage>;

/// `vkCreateImage`
pub type FN_vkCreateImage = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkImageCreateInfo, pAllocator: *const VkAllocationCallbacks, pImage: *mut VkImage) -> VkResult;


/// `vkCreateImagePipeSurfaceFUCHSIA`
pub type PFN_vkCreateImagePipeSurfaceFUCHSIA = Option<FN_vkCreateImagePipeSurfaceFUCHSIA>;

/// `vkCreateImagePipeSurfaceFUCHSIA`
pub type FN_vkCreateImagePipeSurfaceFUCHSIA = unsafe extern "system" fn(instance: VkInstance, pCreateInfo: *const VkImagePipeSurfaceCreateInfoFUCHSIA, pAllocator: *const VkAllocationCallbacks, pSurface: *mut VkSurfaceKHR) -> VkResult;


/// `vkCreateImageView`
pub type PFN_vkCreateImageView = Option<FN_vkCreateImageView>;

/// `vkCreateImageView`
pub type FN_vkCreateImageView = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkImageViewCreateInfo, pAllocator: *const VkAllocationCallbacks, pView: *mut VkImageView) -> VkResult;


/// `vkCreateIndirectCommandsLayoutEXT`
pub type PFN_vkCreateIndirectCommandsLayoutEXT = Option<FN_vkCreateIndirectCommandsLayoutEXT>;

/// `vkCreateIndirectCommandsLayoutEXT`
pub type FN_vkCreateIndirectCommandsLayoutEXT = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkIndirectCommandsLayoutCreateInfoEXT, pAllocator: *const VkAllocationCallbacks, pIndirectCommandsLayout: *mut VkIndirectCommandsLayoutEXT) -> VkResult;


/// `vkCreateIndirectCommandsLayoutNV`
pub type PFN_vkCreateIndirectCommandsLayoutNV = Option<FN_vkCreateIndirectCommandsLayoutNV>;

/// `vkCreateIndirectCommandsLayoutNV`
pub type FN_vkCreateIndirectCommandsLayoutNV = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkIndirectCommandsLayoutCreateInfoNV, pAllocator: *const VkAllocationCallbacks, pIndirectCommandsLayout: *mut VkIndirectCommandsLayoutNV) -> VkResult;


/// `vkCreateIndirectExecutionSetEXT`
pub type PFN_vkCreateIndirectExecutionSetEXT = Option<FN_vkCreateIndirectExecutionSetEXT>;

/// `vkCreateIndirectExecutionSetEXT`
pub type FN_vkCreateIndirectExecutionSetEXT = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkIndirectExecutionSetCreateInfoEXT, pAllocator: *const VkAllocationCallbacks, pIndirectExecutionSet: *mut VkIndirectExecutionSetEXT) -> VkResult;


/// `vkCreateInstance`
pub type PFN_vkCreateInstance = Option<FN_vkCreateInstance>;

/// `vkCreateInstance`
pub type FN_vkCreateInstance = unsafe extern "system" fn(pCreateInfo: *const VkInstanceCreateInfo, pAllocator: *const VkAllocationCallbacks, pInstance: *mut VkInstance) -> VkResult;


/// `vkCreateIOSSurfaceMVK`
pub type PFN_vkCreateIOSSurfaceMVK = Option<FN_vkCreateIOSSurfaceMVK>;

/// `vkCreateIOSSurfaceMVK`
pub type FN_vkCreateIOSSurfaceMVK = unsafe extern "system" fn(instance: VkInstance, pCreateInfo: *const VkIOSSurfaceCreateInfoMVK, pAllocator: *const VkAllocationCallbacks, pSurface: *mut VkSurfaceKHR) -> VkResult;


/// `vkCreateMacOSSurfaceMVK`
pub type PFN_vkCreateMacOSSurfaceMVK = Option<FN_vkCreateMacOSSurfaceMVK>;

/// `vkCreateMacOSSurfaceMVK`
pub type FN_vkCreateMacOSSurfaceMVK = unsafe extern "system" fn(instance: VkInstance, pCreateInfo: *const VkMacOSSurfaceCreateInfoMVK, pAllocator: *const VkAllocationCallbacks, pSurface: *mut VkSurfaceKHR) -> VkResult;


/// `vkCreateMetalSurfaceEXT`
pub type PFN_vkCreateMetalSurfaceEXT = Option<FN_vkCreateMetalSurfaceEXT>;

/// `vkCreateMetalSurfaceEXT`
pub type FN_vkCreateMetalSurfaceEXT = unsafe extern "system" fn(instance: VkInstance, pCreateInfo: *const VkMetalSurfaceCreateInfoEXT, pAllocator: *const VkAllocationCallbacks, pSurface: *mut VkSurfaceKHR) -> VkResult;


/// `vkCreateMicromapEXT`
pub type PFN_vkCreateMicromapEXT = Option<FN_vkCreateMicromapEXT>;

/// `vkCreateMicromapEXT`
pub type FN_vkCreateMicromapEXT = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkMicromapCreateInfoEXT, pAllocator: *const VkAllocationCallbacks, pMicromap: *mut VkMicromapEXT) -> VkResult;


/// `vkCreateOpticalFlowSessionNV`
pub type PFN_vkCreateOpticalFlowSessionNV = Option<FN_vkCreateOpticalFlowSessionNV>;

/// `vkCreateOpticalFlowSessionNV`
pub type FN_vkCreateOpticalFlowSessionNV = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkOpticalFlowSessionCreateInfoNV, pAllocator: *const VkAllocationCallbacks, pSession: *mut VkOpticalFlowSessionNV) -> VkResult;


/// `vkCreatePipelineBinariesKHR`
pub type PFN_vkCreatePipelineBinariesKHR = Option<FN_vkCreatePipelineBinariesKHR>;

/// `vkCreatePipelineBinariesKHR`
pub type FN_vkCreatePipelineBinariesKHR = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkPipelineBinaryCreateInfoKHR, pAllocator: *const VkAllocationCallbacks, pBinaries: *mut VkPipelineBinaryHandlesInfoKHR) -> VkResult;


/// `vkCreatePipelineCache`
pub type PFN_vkCreatePipelineCache = Option<FN_vkCreatePipelineCache>;

/// `vkCreatePipelineCache`
pub type FN_vkCreatePipelineCache = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkPipelineCacheCreateInfo, pAllocator: *const VkAllocationCallbacks, pPipelineCache: *mut VkPipelineCache) -> VkResult;


/// `vkCreatePipelineLayout`
pub type PFN_vkCreatePipelineLayout = Option<FN_vkCreatePipelineLayout>;

/// `vkCreatePipelineLayout`
pub type FN_vkCreatePipelineLayout = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkPipelineLayoutCreateInfo, pAllocator: *const VkAllocationCallbacks, pPipelineLayout: *mut VkPipelineLayout) -> VkResult;


/// `vkCreatePrivateDataSlot`
pub type PFN_vkCreatePrivateDataSlot = Option<FN_vkCreatePrivateDataSlot>;

/// `vkCreatePrivateDataSlot`
pub type FN_vkCreatePrivateDataSlot = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkPrivateDataSlotCreateInfo, pAllocator: *const VkAllocationCallbacks, pPrivateDataSlot: *mut VkPrivateDataSlot) -> VkResult;


/// `vkCreatePrivateDataSlotEXT` = `vkCreatePrivateDataSlot`
pub type PFN_vkCreatePrivateDataSlotEXT = PFN_vkCreatePrivateDataSlot;

/// `vkCreatePrivateDataSlotEXT` = `vkCreatePrivateDataSlot`
pub type FN_vkCreatePrivateDataSlotEXT = FN_vkCreatePrivateDataSlot;

/// `vkCreateQueryPool`
pub type PFN_vkCreateQueryPool = Option<FN_vkCreateQueryPool>;

/// `vkCreateQueryPool`
pub type FN_vkCreateQueryPool = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkQueryPoolCreateInfo, pAllocator: *const VkAllocationCallbacks, pQueryPool: *mut VkQueryPool) -> VkResult;


/// `vkCreateRayTracingPipelinesKHR`
pub type PFN_vkCreateRayTracingPipelinesKHR = Option<FN_vkCreateRayTracingPipelinesKHR>;

/// `vkCreateRayTracingPipelinesKHR`
pub type FN_vkCreateRayTracingPipelinesKHR = unsafe extern "system" fn(device: VkDevice, deferredOperation: VkDeferredOperationKHR, pipelineCache: VkPipelineCache, createInfoCount: uint32_t, pCreateInfos: *const VkRayTracingPipelineCreateInfoKHR, pAllocator: *const VkAllocationCallbacks, pPipelines: *mut VkPipeline) -> VkResult;


/// `vkCreateRayTracingPipelinesNV`
pub type PFN_vkCreateRayTracingPipelinesNV = Option<FN_vkCreateRayTracingPipelinesNV>;

/// `vkCreateRayTracingPipelinesNV`
pub type FN_vkCreateRayTracingPipelinesNV = unsafe extern "system" fn(device: VkDevice, pipelineCache: VkPipelineCache, createInfoCount: uint32_t, pCreateInfos: *const VkRayTracingPipelineCreateInfoNV, pAllocator: *const VkAllocationCallbacks, pPipelines: *mut VkPipeline) -> VkResult;


/// `vkCreateRenderPass`
pub type PFN_vkCreateRenderPass = Option<FN_vkCreateRenderPass>;

/// `vkCreateRenderPass`
pub type FN_vkCreateRenderPass = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkRenderPassCreateInfo, pAllocator: *const VkAllocationCallbacks, pRenderPass: *mut VkRenderPass) -> VkResult;


/// `vkCreateRenderPass2`
pub type PFN_vkCreateRenderPass2 = Option<FN_vkCreateRenderPass2>;

/// `vkCreateRenderPass2`
pub type FN_vkCreateRenderPass2 = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkRenderPassCreateInfo2, pAllocator: *const VkAllocationCallbacks, pRenderPass: *mut VkRenderPass) -> VkResult;


/// `vkCreateRenderPass2KHR` = `vkCreateRenderPass2`
pub type PFN_vkCreateRenderPass2KHR = PFN_vkCreateRenderPass2;

/// `vkCreateRenderPass2KHR` = `vkCreateRenderPass2`
pub type FN_vkCreateRenderPass2KHR = FN_vkCreateRenderPass2;

/// `vkCreateSampler`
pub type PFN_vkCreateSampler = Option<FN_vkCreateSampler>;

/// `vkCreateSampler`
pub type FN_vkCreateSampler = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkSamplerCreateInfo, pAllocator: *const VkAllocationCallbacks, pSampler: *mut VkSampler) -> VkResult;


/// `vkCreateSamplerYcbcrConversion`
pub type PFN_vkCreateSamplerYcbcrConversion = Option<FN_vkCreateSamplerYcbcrConversion>;

/// `vkCreateSamplerYcbcrConversion`
pub type FN_vkCreateSamplerYcbcrConversion = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkSamplerYcbcrConversionCreateInfo, pAllocator: *const VkAllocationCallbacks, pYcbcrConversion: *mut VkSamplerYcbcrConversion) -> VkResult;


/// `vkCreateSamplerYcbcrConversionKHR` = `vkCreateSamplerYcbcrConversion`
pub type PFN_vkCreateSamplerYcbcrConversionKHR = PFN_vkCreateSamplerYcbcrConversion;

/// `vkCreateSamplerYcbcrConversionKHR` = `vkCreateSamplerYcbcrConversion`
pub type FN_vkCreateSamplerYcbcrConversionKHR = FN_vkCreateSamplerYcbcrConversion;

/// `vkCreateScreenSurfaceQNX`
pub type PFN_vkCreateScreenSurfaceQNX = Option<FN_vkCreateScreenSurfaceQNX>;

/// `vkCreateScreenSurfaceQNX`
pub type FN_vkCreateScreenSurfaceQNX = unsafe extern "system" fn(instance: VkInstance, pCreateInfo: *const VkScreenSurfaceCreateInfoQNX, pAllocator: *const VkAllocationCallbacks, pSurface: *mut VkSurfaceKHR) -> VkResult;


/// `vkCreateSemaphore`
pub type PFN_vkCreateSemaphore = Option<FN_vkCreateSemaphore>;

/// `vkCreateSemaphore`
pub type FN_vkCreateSemaphore = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkSemaphoreCreateInfo, pAllocator: *const VkAllocationCallbacks, pSemaphore: *mut VkSemaphore) -> VkResult;


/// `vkCreateSemaphoreSciSyncPoolNV`
pub type PFN_vkCreateSemaphoreSciSyncPoolNV = Option<FN_vkCreateSemaphoreSciSyncPoolNV>;

/// `vkCreateSemaphoreSciSyncPoolNV`
pub type FN_vkCreateSemaphoreSciSyncPoolNV = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkSemaphoreSciSyncPoolCreateInfoNV, pAllocator: *const VkAllocationCallbacks, pSemaphorePool: *mut VkSemaphoreSciSyncPoolNV) -> VkResult;


/// `vkCreateShaderInstrumentationARM`
pub type PFN_vkCreateShaderInstrumentationARM = Option<FN_vkCreateShaderInstrumentationARM>;

/// `vkCreateShaderInstrumentationARM`
pub type FN_vkCreateShaderInstrumentationARM = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkShaderInstrumentationCreateInfoARM, pAllocator: *const VkAllocationCallbacks, pInstrumentation: *mut VkShaderInstrumentationARM) -> VkResult;


/// `vkCreateShaderModule`
pub type PFN_vkCreateShaderModule = Option<FN_vkCreateShaderModule>;

/// `vkCreateShaderModule`
pub type FN_vkCreateShaderModule = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkShaderModuleCreateInfo, pAllocator: *const VkAllocationCallbacks, pShaderModule: *mut VkShaderModule) -> VkResult;


/// `vkCreateShadersEXT`
pub type PFN_vkCreateShadersEXT = Option<FN_vkCreateShadersEXT>;

/// `vkCreateShadersEXT`
pub type FN_vkCreateShadersEXT = unsafe extern "system" fn(device: VkDevice, createInfoCount: uint32_t, pCreateInfos: *const VkShaderCreateInfoEXT, pAllocator: *const VkAllocationCallbacks, pShaders: *mut VkShaderEXT) -> VkResult;


/// `vkCreateSharedSwapchainsKHR`
pub type PFN_vkCreateSharedSwapchainsKHR = Option<FN_vkCreateSharedSwapchainsKHR>;

/// `vkCreateSharedSwapchainsKHR`
pub type FN_vkCreateSharedSwapchainsKHR = unsafe extern "system" fn(device: VkDevice, swapchainCount: uint32_t, pCreateInfos: *const VkSwapchainCreateInfoKHR, pAllocator: *const VkAllocationCallbacks, pSwapchains: *mut VkSwapchainKHR) -> VkResult;


/// `vkCreateStreamDescriptorSurfaceGGP`
pub type PFN_vkCreateStreamDescriptorSurfaceGGP = Option<FN_vkCreateStreamDescriptorSurfaceGGP>;

/// `vkCreateStreamDescriptorSurfaceGGP`
pub type FN_vkCreateStreamDescriptorSurfaceGGP = unsafe extern "system" fn(instance: VkInstance, pCreateInfo: *const VkStreamDescriptorSurfaceCreateInfoGGP, pAllocator: *const VkAllocationCallbacks, pSurface: *mut VkSurfaceKHR) -> VkResult;


/// `vkCreateSurfaceOHOS`
pub type PFN_vkCreateSurfaceOHOS = Option<FN_vkCreateSurfaceOHOS>;

/// `vkCreateSurfaceOHOS`
pub type FN_vkCreateSurfaceOHOS = unsafe extern "system" fn(instance: VkInstance, pCreateInfo: *const VkSurfaceCreateInfoOHOS, pAllocator: *const VkAllocationCallbacks, pSurface: *mut VkSurfaceKHR) -> VkResult;


/// `vkCreateSwapchainKHR`
pub type PFN_vkCreateSwapchainKHR = Option<FN_vkCreateSwapchainKHR>;

/// `vkCreateSwapchainKHR`
pub type FN_vkCreateSwapchainKHR = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkSwapchainCreateInfoKHR, pAllocator: *const VkAllocationCallbacks, pSwapchain: *mut VkSwapchainKHR) -> VkResult;


/// `vkCreateTensorARM`
pub type PFN_vkCreateTensorARM = Option<FN_vkCreateTensorARM>;

/// `vkCreateTensorARM`
pub type FN_vkCreateTensorARM = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkTensorCreateInfoARM, pAllocator: *const VkAllocationCallbacks, pTensor: *mut VkTensorARM) -> VkResult;


/// `vkCreateTensorViewARM`
pub type PFN_vkCreateTensorViewARM = Option<FN_vkCreateTensorViewARM>;

/// `vkCreateTensorViewARM`
pub type FN_vkCreateTensorViewARM = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkTensorViewCreateInfoARM, pAllocator: *const VkAllocationCallbacks, pView: *mut VkTensorViewARM) -> VkResult;


/// `vkCreateUbmSurfaceSEC`
pub type PFN_vkCreateUbmSurfaceSEC = Option<FN_vkCreateUbmSurfaceSEC>;

/// `vkCreateUbmSurfaceSEC`
pub type FN_vkCreateUbmSurfaceSEC = unsafe extern "system" fn(instance: VkInstance, pCreateInfo: *const VkUbmSurfaceCreateInfoSEC, pAllocator: *const VkAllocationCallbacks, pSurface: *mut VkSurfaceKHR) -> VkResult;


/// `vkCreateValidationCacheEXT`
pub type PFN_vkCreateValidationCacheEXT = Option<FN_vkCreateValidationCacheEXT>;

/// `vkCreateValidationCacheEXT`
pub type FN_vkCreateValidationCacheEXT = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkValidationCacheCreateInfoEXT, pAllocator: *const VkAllocationCallbacks, pValidationCache: *mut VkValidationCacheEXT) -> VkResult;


/// `vkCreateVideoSessionKHR`
pub type PFN_vkCreateVideoSessionKHR = Option<FN_vkCreateVideoSessionKHR>;

/// `vkCreateVideoSessionKHR`
pub type FN_vkCreateVideoSessionKHR = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkVideoSessionCreateInfoKHR, pAllocator: *const VkAllocationCallbacks, pVideoSession: *mut VkVideoSessionKHR) -> VkResult;


/// `vkCreateVideoSessionParametersKHR`
pub type PFN_vkCreateVideoSessionParametersKHR = Option<FN_vkCreateVideoSessionParametersKHR>;

/// `vkCreateVideoSessionParametersKHR`
pub type FN_vkCreateVideoSessionParametersKHR = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkVideoSessionParametersCreateInfoKHR, pAllocator: *const VkAllocationCallbacks, pVideoSessionParameters: *mut VkVideoSessionParametersKHR) -> VkResult;


/// `vkCreateViSurfaceNN`
pub type PFN_vkCreateViSurfaceNN = Option<FN_vkCreateViSurfaceNN>;

/// `vkCreateViSurfaceNN`
pub type FN_vkCreateViSurfaceNN = unsafe extern "system" fn(instance: VkInstance, pCreateInfo: *const VkViSurfaceCreateInfoNN, pAllocator: *const VkAllocationCallbacks, pSurface: *mut VkSurfaceKHR) -> VkResult;


/// `vkCreateWaylandSurfaceKHR`
pub type PFN_vkCreateWaylandSurfaceKHR = Option<FN_vkCreateWaylandSurfaceKHR>;

/// `vkCreateWaylandSurfaceKHR`
pub type FN_vkCreateWaylandSurfaceKHR = unsafe extern "system" fn(instance: VkInstance, pCreateInfo: *const VkWaylandSurfaceCreateInfoKHR, pAllocator: *const VkAllocationCallbacks, pSurface: *mut VkSurfaceKHR) -> VkResult;


/// `vkCreateWin32SurfaceKHR`
pub type PFN_vkCreateWin32SurfaceKHR = Option<FN_vkCreateWin32SurfaceKHR>;

/// `vkCreateWin32SurfaceKHR`
pub type FN_vkCreateWin32SurfaceKHR = unsafe extern "system" fn(instance: VkInstance, pCreateInfo: *const VkWin32SurfaceCreateInfoKHR, pAllocator: *const VkAllocationCallbacks, pSurface: *mut VkSurfaceKHR) -> VkResult;


/// `vkCreateXcbSurfaceKHR`
pub type PFN_vkCreateXcbSurfaceKHR = Option<FN_vkCreateXcbSurfaceKHR>;

/// `vkCreateXcbSurfaceKHR`
pub type FN_vkCreateXcbSurfaceKHR = unsafe extern "system" fn(instance: VkInstance, pCreateInfo: *const VkXcbSurfaceCreateInfoKHR, pAllocator: *const VkAllocationCallbacks, pSurface: *mut VkSurfaceKHR) -> VkResult;


/// `vkCreateXlibSurfaceKHR`
pub type PFN_vkCreateXlibSurfaceKHR = Option<FN_vkCreateXlibSurfaceKHR>;

/// `vkCreateXlibSurfaceKHR`
pub type FN_vkCreateXlibSurfaceKHR = unsafe extern "system" fn(instance: VkInstance, pCreateInfo: *const VkXlibSurfaceCreateInfoKHR, pAllocator: *const VkAllocationCallbacks, pSurface: *mut VkSurfaceKHR) -> VkResult;


/// `vkDebugMarkerSetObjectNameEXT`
pub type PFN_vkDebugMarkerSetObjectNameEXT = Option<FN_vkDebugMarkerSetObjectNameEXT>;

/// `vkDebugMarkerSetObjectNameEXT`
pub type FN_vkDebugMarkerSetObjectNameEXT = unsafe extern "system" fn(device: VkDevice, pNameInfo: *const VkDebugMarkerObjectNameInfoEXT) -> VkResult;


/// `vkDebugMarkerSetObjectTagEXT`
pub type PFN_vkDebugMarkerSetObjectTagEXT = Option<FN_vkDebugMarkerSetObjectTagEXT>;

/// `vkDebugMarkerSetObjectTagEXT`
pub type FN_vkDebugMarkerSetObjectTagEXT = unsafe extern "system" fn(device: VkDevice, pTagInfo: *const VkDebugMarkerObjectTagInfoEXT) -> VkResult;


/// `vkDebugReportMessageEXT`
pub type PFN_vkDebugReportMessageEXT = Option<FN_vkDebugReportMessageEXT>;

/// `vkDebugReportMessageEXT`
pub type FN_vkDebugReportMessageEXT = unsafe extern "system" fn(instance: VkInstance, flags: VkDebugReportFlagsEXT, objectType: VkDebugReportObjectTypeEXT, object: uint64_t, location: size_t, messageCode: int32_t, pLayerPrefix: *const c_char, pMessage: *const c_char) -> ();


/// `vkDeferredOperationJoinKHR`
pub type PFN_vkDeferredOperationJoinKHR = Option<FN_vkDeferredOperationJoinKHR>;

/// `vkDeferredOperationJoinKHR`
pub type FN_vkDeferredOperationJoinKHR = unsafe extern "system" fn(device: VkDevice, operation: VkDeferredOperationKHR) -> VkResult;


/// `vkDestroyAccelerationStructureKHR`
pub type PFN_vkDestroyAccelerationStructureKHR = Option<FN_vkDestroyAccelerationStructureKHR>;

/// `vkDestroyAccelerationStructureKHR`
pub type FN_vkDestroyAccelerationStructureKHR = unsafe extern "system" fn(device: VkDevice, accelerationStructure: VkAccelerationStructureKHR, pAllocator: *const VkAllocationCallbacks) -> ();


/// `vkDestroyAccelerationStructureNV`
pub type PFN_vkDestroyAccelerationStructureNV = Option<FN_vkDestroyAccelerationStructureNV>;

/// `vkDestroyAccelerationStructureNV`
pub type FN_vkDestroyAccelerationStructureNV = unsafe extern "system" fn(device: VkDevice, accelerationStructure: VkAccelerationStructureNV, pAllocator: *const VkAllocationCallbacks) -> ();


/// `vkDestroyBuffer`
pub type PFN_vkDestroyBuffer = Option<FN_vkDestroyBuffer>;

/// `vkDestroyBuffer`
pub type FN_vkDestroyBuffer = unsafe extern "system" fn(device: VkDevice, buffer: VkBuffer, pAllocator: *const VkAllocationCallbacks) -> ();


/// `vkDestroyBufferCollectionFUCHSIA`
pub type PFN_vkDestroyBufferCollectionFUCHSIA = Option<FN_vkDestroyBufferCollectionFUCHSIA>;

/// `vkDestroyBufferCollectionFUCHSIA`
pub type FN_vkDestroyBufferCollectionFUCHSIA = unsafe extern "system" fn(device: VkDevice, collection: VkBufferCollectionFUCHSIA, pAllocator: *const VkAllocationCallbacks) -> ();


/// `vkDestroyBufferView`
pub type PFN_vkDestroyBufferView = Option<FN_vkDestroyBufferView>;

/// `vkDestroyBufferView`
pub type FN_vkDestroyBufferView = unsafe extern "system" fn(device: VkDevice, bufferView: VkBufferView, pAllocator: *const VkAllocationCallbacks) -> ();


/// `vkDestroyCommandPool`
pub type PFN_vkDestroyCommandPool = Option<FN_vkDestroyCommandPool>;

/// `vkDestroyCommandPool`
pub type FN_vkDestroyCommandPool = unsafe extern "system" fn(device: VkDevice, commandPool: VkCommandPool, pAllocator: *const VkAllocationCallbacks) -> ();


/// `vkDestroyCudaFunctionNV`
pub type PFN_vkDestroyCudaFunctionNV = Option<FN_vkDestroyCudaFunctionNV>;

/// `vkDestroyCudaFunctionNV`
pub type FN_vkDestroyCudaFunctionNV = unsafe extern "system" fn(device: VkDevice, function: VkCudaFunctionNV, pAllocator: *const VkAllocationCallbacks) -> ();


/// `vkDestroyCudaModuleNV`
pub type PFN_vkDestroyCudaModuleNV = Option<FN_vkDestroyCudaModuleNV>;

/// `vkDestroyCudaModuleNV`
pub type FN_vkDestroyCudaModuleNV = unsafe extern "system" fn(device: VkDevice, module: VkCudaModuleNV, pAllocator: *const VkAllocationCallbacks) -> ();


/// `vkDestroyCuFunctionNVX`
pub type PFN_vkDestroyCuFunctionNVX = Option<FN_vkDestroyCuFunctionNVX>;

/// `vkDestroyCuFunctionNVX`
pub type FN_vkDestroyCuFunctionNVX = unsafe extern "system" fn(device: VkDevice, function: VkCuFunctionNVX, pAllocator: *const VkAllocationCallbacks) -> ();


/// `vkDestroyCuModuleNVX`
pub type PFN_vkDestroyCuModuleNVX = Option<FN_vkDestroyCuModuleNVX>;

/// `vkDestroyCuModuleNVX`
pub type FN_vkDestroyCuModuleNVX = unsafe extern "system" fn(device: VkDevice, module: VkCuModuleNVX, pAllocator: *const VkAllocationCallbacks) -> ();


/// `vkDestroyDataGraphPipelineSessionARM`
pub type PFN_vkDestroyDataGraphPipelineSessionARM = Option<FN_vkDestroyDataGraphPipelineSessionARM>;

/// `vkDestroyDataGraphPipelineSessionARM`
pub type FN_vkDestroyDataGraphPipelineSessionARM = unsafe extern "system" fn(device: VkDevice, session: VkDataGraphPipelineSessionARM, pAllocator: *const VkAllocationCallbacks) -> ();


/// `vkDestroyDebugReportCallbackEXT`
pub type PFN_vkDestroyDebugReportCallbackEXT = Option<FN_vkDestroyDebugReportCallbackEXT>;

/// `vkDestroyDebugReportCallbackEXT`
pub type FN_vkDestroyDebugReportCallbackEXT = unsafe extern "system" fn(instance: VkInstance, callback: VkDebugReportCallbackEXT, pAllocator: *const VkAllocationCallbacks) -> ();


/// `vkDestroyDebugUtilsMessengerEXT`
pub type PFN_vkDestroyDebugUtilsMessengerEXT = Option<FN_vkDestroyDebugUtilsMessengerEXT>;

/// `vkDestroyDebugUtilsMessengerEXT`
pub type FN_vkDestroyDebugUtilsMessengerEXT = unsafe extern "system" fn(instance: VkInstance, messenger: VkDebugUtilsMessengerEXT, pAllocator: *const VkAllocationCallbacks) -> ();


/// `vkDestroyDeferredOperationKHR`
pub type PFN_vkDestroyDeferredOperationKHR = Option<FN_vkDestroyDeferredOperationKHR>;

/// `vkDestroyDeferredOperationKHR`
pub type FN_vkDestroyDeferredOperationKHR = unsafe extern "system" fn(device: VkDevice, operation: VkDeferredOperationKHR, pAllocator: *const VkAllocationCallbacks) -> ();


/// `vkDestroyDescriptorPool`
pub type PFN_vkDestroyDescriptorPool = Option<FN_vkDestroyDescriptorPool>;

/// `vkDestroyDescriptorPool`
pub type FN_vkDestroyDescriptorPool = unsafe extern "system" fn(device: VkDevice, descriptorPool: VkDescriptorPool, pAllocator: *const VkAllocationCallbacks) -> ();


/// `vkDestroyDescriptorSetLayout`
pub type PFN_vkDestroyDescriptorSetLayout = Option<FN_vkDestroyDescriptorSetLayout>;

/// `vkDestroyDescriptorSetLayout`
pub type FN_vkDestroyDescriptorSetLayout = unsafe extern "system" fn(device: VkDevice, descriptorSetLayout: VkDescriptorSetLayout, pAllocator: *const VkAllocationCallbacks) -> ();


/// `vkDestroyDescriptorUpdateTemplate`
pub type PFN_vkDestroyDescriptorUpdateTemplate = Option<FN_vkDestroyDescriptorUpdateTemplate>;

/// `vkDestroyDescriptorUpdateTemplate`
pub type FN_vkDestroyDescriptorUpdateTemplate = unsafe extern "system" fn(device: VkDevice, descriptorUpdateTemplate: VkDescriptorUpdateTemplate, pAllocator: *const VkAllocationCallbacks) -> ();


/// `vkDestroyDescriptorUpdateTemplateKHR` = `vkDestroyDescriptorUpdateTemplate`
pub type PFN_vkDestroyDescriptorUpdateTemplateKHR = PFN_vkDestroyDescriptorUpdateTemplate;

/// `vkDestroyDescriptorUpdateTemplateKHR` = `vkDestroyDescriptorUpdateTemplate`
pub type FN_vkDestroyDescriptorUpdateTemplateKHR = FN_vkDestroyDescriptorUpdateTemplate;

/// `vkDestroyDevice`
pub type PFN_vkDestroyDevice = Option<FN_vkDestroyDevice>;

/// `vkDestroyDevice`
pub type FN_vkDestroyDevice = unsafe extern "system" fn(device: VkDevice, pAllocator: *const VkAllocationCallbacks) -> ();


/// `vkDestroyEvent`
pub type PFN_vkDestroyEvent = Option<FN_vkDestroyEvent>;

/// `vkDestroyEvent`
pub type FN_vkDestroyEvent = unsafe extern "system" fn(device: VkDevice, event: VkEvent, pAllocator: *const VkAllocationCallbacks) -> ();


/// `vkDestroyExternalComputeQueueNV`
pub type PFN_vkDestroyExternalComputeQueueNV = Option<FN_vkDestroyExternalComputeQueueNV>;

/// `vkDestroyExternalComputeQueueNV`
pub type FN_vkDestroyExternalComputeQueueNV = unsafe extern "system" fn(device: VkDevice, externalQueue: VkExternalComputeQueueNV, pAllocator: *const VkAllocationCallbacks) -> ();


/// `vkDestroyFence`
pub type PFN_vkDestroyFence = Option<FN_vkDestroyFence>;

/// `vkDestroyFence`
pub type FN_vkDestroyFence = unsafe extern "system" fn(device: VkDevice, fence: VkFence, pAllocator: *const VkAllocationCallbacks) -> ();


/// `vkDestroyFramebuffer`
pub type PFN_vkDestroyFramebuffer = Option<FN_vkDestroyFramebuffer>;

/// `vkDestroyFramebuffer`
pub type FN_vkDestroyFramebuffer = unsafe extern "system" fn(device: VkDevice, framebuffer: VkFramebuffer, pAllocator: *const VkAllocationCallbacks) -> ();


/// `vkDestroyImage`
pub type PFN_vkDestroyImage = Option<FN_vkDestroyImage>;

/// `vkDestroyImage`
pub type FN_vkDestroyImage = unsafe extern "system" fn(device: VkDevice, image: VkImage, pAllocator: *const VkAllocationCallbacks) -> ();


/// `vkDestroyImageView`
pub type PFN_vkDestroyImageView = Option<FN_vkDestroyImageView>;

/// `vkDestroyImageView`
pub type FN_vkDestroyImageView = unsafe extern "system" fn(device: VkDevice, imageView: VkImageView, pAllocator: *const VkAllocationCallbacks) -> ();


/// `vkDestroyIndirectCommandsLayoutEXT`
pub type PFN_vkDestroyIndirectCommandsLayoutEXT = Option<FN_vkDestroyIndirectCommandsLayoutEXT>;

/// `vkDestroyIndirectCommandsLayoutEXT`
pub type FN_vkDestroyIndirectCommandsLayoutEXT = unsafe extern "system" fn(device: VkDevice, indirectCommandsLayout: VkIndirectCommandsLayoutEXT, pAllocator: *const VkAllocationCallbacks) -> ();


/// `vkDestroyIndirectCommandsLayoutNV`
pub type PFN_vkDestroyIndirectCommandsLayoutNV = Option<FN_vkDestroyIndirectCommandsLayoutNV>;

/// `vkDestroyIndirectCommandsLayoutNV`
pub type FN_vkDestroyIndirectCommandsLayoutNV = unsafe extern "system" fn(device: VkDevice, indirectCommandsLayout: VkIndirectCommandsLayoutNV, pAllocator: *const VkAllocationCallbacks) -> ();


/// `vkDestroyIndirectExecutionSetEXT`
pub type PFN_vkDestroyIndirectExecutionSetEXT = Option<FN_vkDestroyIndirectExecutionSetEXT>;

/// `vkDestroyIndirectExecutionSetEXT`
pub type FN_vkDestroyIndirectExecutionSetEXT = unsafe extern "system" fn(device: VkDevice, indirectExecutionSet: VkIndirectExecutionSetEXT, pAllocator: *const VkAllocationCallbacks) -> ();


/// `vkDestroyInstance`
pub type PFN_vkDestroyInstance = Option<FN_vkDestroyInstance>;

/// `vkDestroyInstance`
pub type FN_vkDestroyInstance = unsafe extern "system" fn(instance: VkInstance, pAllocator: *const VkAllocationCallbacks) -> ();


/// `vkDestroyMicromapEXT`
pub type PFN_vkDestroyMicromapEXT = Option<FN_vkDestroyMicromapEXT>;

/// `vkDestroyMicromapEXT`
pub type FN_vkDestroyMicromapEXT = unsafe extern "system" fn(device: VkDevice, micromap: VkMicromapEXT, pAllocator: *const VkAllocationCallbacks) -> ();


/// `vkDestroyOpticalFlowSessionNV`
pub type PFN_vkDestroyOpticalFlowSessionNV = Option<FN_vkDestroyOpticalFlowSessionNV>;

/// `vkDestroyOpticalFlowSessionNV`
pub type FN_vkDestroyOpticalFlowSessionNV = unsafe extern "system" fn(device: VkDevice, session: VkOpticalFlowSessionNV, pAllocator: *const VkAllocationCallbacks) -> ();


/// `vkDestroyPipeline`
pub type PFN_vkDestroyPipeline = Option<FN_vkDestroyPipeline>;

/// `vkDestroyPipeline`
pub type FN_vkDestroyPipeline = unsafe extern "system" fn(device: VkDevice, pipeline: VkPipeline, pAllocator: *const VkAllocationCallbacks) -> ();


/// `vkDestroyPipelineBinaryKHR`
pub type PFN_vkDestroyPipelineBinaryKHR = Option<FN_vkDestroyPipelineBinaryKHR>;

/// `vkDestroyPipelineBinaryKHR`
pub type FN_vkDestroyPipelineBinaryKHR = unsafe extern "system" fn(device: VkDevice, pipelineBinary: VkPipelineBinaryKHR, pAllocator: *const VkAllocationCallbacks) -> ();


/// `vkDestroyPipelineCache`
pub type PFN_vkDestroyPipelineCache = Option<FN_vkDestroyPipelineCache>;

/// `vkDestroyPipelineCache`
pub type FN_vkDestroyPipelineCache = unsafe extern "system" fn(device: VkDevice, pipelineCache: VkPipelineCache, pAllocator: *const VkAllocationCallbacks) -> ();


/// `vkDestroyPipelineLayout`
pub type PFN_vkDestroyPipelineLayout = Option<FN_vkDestroyPipelineLayout>;

/// `vkDestroyPipelineLayout`
pub type FN_vkDestroyPipelineLayout = unsafe extern "system" fn(device: VkDevice, pipelineLayout: VkPipelineLayout, pAllocator: *const VkAllocationCallbacks) -> ();


/// `vkDestroyPrivateDataSlot`
pub type PFN_vkDestroyPrivateDataSlot = Option<FN_vkDestroyPrivateDataSlot>;

/// `vkDestroyPrivateDataSlot`
pub type FN_vkDestroyPrivateDataSlot = unsafe extern "system" fn(device: VkDevice, privateDataSlot: VkPrivateDataSlot, pAllocator: *const VkAllocationCallbacks) -> ();


/// `vkDestroyPrivateDataSlotEXT` = `vkDestroyPrivateDataSlot`
pub type PFN_vkDestroyPrivateDataSlotEXT = PFN_vkDestroyPrivateDataSlot;

/// `vkDestroyPrivateDataSlotEXT` = `vkDestroyPrivateDataSlot`
pub type FN_vkDestroyPrivateDataSlotEXT = FN_vkDestroyPrivateDataSlot;

/// `vkDestroyQueryPool`
pub type PFN_vkDestroyQueryPool = Option<FN_vkDestroyQueryPool>;

/// `vkDestroyQueryPool`
pub type FN_vkDestroyQueryPool = unsafe extern "system" fn(device: VkDevice, queryPool: VkQueryPool, pAllocator: *const VkAllocationCallbacks) -> ();


/// `vkDestroyRenderPass`
pub type PFN_vkDestroyRenderPass = Option<FN_vkDestroyRenderPass>;

/// `vkDestroyRenderPass`
pub type FN_vkDestroyRenderPass = unsafe extern "system" fn(device: VkDevice, renderPass: VkRenderPass, pAllocator: *const VkAllocationCallbacks) -> ();


/// `vkDestroySampler`
pub type PFN_vkDestroySampler = Option<FN_vkDestroySampler>;

/// `vkDestroySampler`
pub type FN_vkDestroySampler = unsafe extern "system" fn(device: VkDevice, sampler: VkSampler, pAllocator: *const VkAllocationCallbacks) -> ();


/// `vkDestroySamplerYcbcrConversion`
pub type PFN_vkDestroySamplerYcbcrConversion = Option<FN_vkDestroySamplerYcbcrConversion>;

/// `vkDestroySamplerYcbcrConversion`
pub type FN_vkDestroySamplerYcbcrConversion = unsafe extern "system" fn(device: VkDevice, ycbcrConversion: VkSamplerYcbcrConversion, pAllocator: *const VkAllocationCallbacks) -> ();


/// `vkDestroySamplerYcbcrConversionKHR` = `vkDestroySamplerYcbcrConversion`
pub type PFN_vkDestroySamplerYcbcrConversionKHR = PFN_vkDestroySamplerYcbcrConversion;

/// `vkDestroySamplerYcbcrConversionKHR` = `vkDestroySamplerYcbcrConversion`
pub type FN_vkDestroySamplerYcbcrConversionKHR = FN_vkDestroySamplerYcbcrConversion;

/// `vkDestroySemaphore`
pub type PFN_vkDestroySemaphore = Option<FN_vkDestroySemaphore>;

/// `vkDestroySemaphore`
pub type FN_vkDestroySemaphore = unsafe extern "system" fn(device: VkDevice, semaphore: VkSemaphore, pAllocator: *const VkAllocationCallbacks) -> ();


/// `vkDestroySemaphoreSciSyncPoolNV`
pub type PFN_vkDestroySemaphoreSciSyncPoolNV = Option<FN_vkDestroySemaphoreSciSyncPoolNV>;

/// `vkDestroySemaphoreSciSyncPoolNV`
pub type FN_vkDestroySemaphoreSciSyncPoolNV = unsafe extern "system" fn(device: VkDevice, semaphorePool: VkSemaphoreSciSyncPoolNV, pAllocator: *const VkAllocationCallbacks) -> ();


/// `vkDestroyShaderEXT`
pub type PFN_vkDestroyShaderEXT = Option<FN_vkDestroyShaderEXT>;

/// `vkDestroyShaderEXT`
pub type FN_vkDestroyShaderEXT = unsafe extern "system" fn(device: VkDevice, shader: VkShaderEXT, pAllocator: *const VkAllocationCallbacks) -> ();


/// `vkDestroyShaderInstrumentationARM`
pub type PFN_vkDestroyShaderInstrumentationARM = Option<FN_vkDestroyShaderInstrumentationARM>;

/// `vkDestroyShaderInstrumentationARM`
pub type FN_vkDestroyShaderInstrumentationARM = unsafe extern "system" fn(device: VkDevice, instrumentation: VkShaderInstrumentationARM, pAllocator: *const VkAllocationCallbacks) -> ();


/// `vkDestroyShaderModule`
pub type PFN_vkDestroyShaderModule = Option<FN_vkDestroyShaderModule>;

/// `vkDestroyShaderModule`
pub type FN_vkDestroyShaderModule = unsafe extern "system" fn(device: VkDevice, shaderModule: VkShaderModule, pAllocator: *const VkAllocationCallbacks) -> ();


/// `vkDestroySurfaceKHR`
pub type PFN_vkDestroySurfaceKHR = Option<FN_vkDestroySurfaceKHR>;

/// `vkDestroySurfaceKHR`
pub type FN_vkDestroySurfaceKHR = unsafe extern "system" fn(instance: VkInstance, surface: VkSurfaceKHR, pAllocator: *const VkAllocationCallbacks) -> ();


/// `vkDestroySwapchainKHR`
pub type PFN_vkDestroySwapchainKHR = Option<FN_vkDestroySwapchainKHR>;

/// `vkDestroySwapchainKHR`
pub type FN_vkDestroySwapchainKHR = unsafe extern "system" fn(device: VkDevice, swapchain: VkSwapchainKHR, pAllocator: *const VkAllocationCallbacks) -> ();


/// `vkDestroyTensorARM`
pub type PFN_vkDestroyTensorARM = Option<FN_vkDestroyTensorARM>;

/// `vkDestroyTensorARM`
pub type FN_vkDestroyTensorARM = unsafe extern "system" fn(device: VkDevice, tensor: VkTensorARM, pAllocator: *const VkAllocationCallbacks) -> ();


/// `vkDestroyTensorViewARM`
pub type PFN_vkDestroyTensorViewARM = Option<FN_vkDestroyTensorViewARM>;

/// `vkDestroyTensorViewARM`
pub type FN_vkDestroyTensorViewARM = unsafe extern "system" fn(device: VkDevice, tensorView: VkTensorViewARM, pAllocator: *const VkAllocationCallbacks) -> ();


/// `vkDestroyValidationCacheEXT`
pub type PFN_vkDestroyValidationCacheEXT = Option<FN_vkDestroyValidationCacheEXT>;

/// `vkDestroyValidationCacheEXT`
pub type FN_vkDestroyValidationCacheEXT = unsafe extern "system" fn(device: VkDevice, validationCache: VkValidationCacheEXT, pAllocator: *const VkAllocationCallbacks) -> ();


/// `vkDestroyVideoSessionKHR`
pub type PFN_vkDestroyVideoSessionKHR = Option<FN_vkDestroyVideoSessionKHR>;

/// `vkDestroyVideoSessionKHR`
pub type FN_vkDestroyVideoSessionKHR = unsafe extern "system" fn(device: VkDevice, videoSession: VkVideoSessionKHR, pAllocator: *const VkAllocationCallbacks) -> ();


/// `vkDestroyVideoSessionParametersKHR`
pub type PFN_vkDestroyVideoSessionParametersKHR = Option<FN_vkDestroyVideoSessionParametersKHR>;

/// `vkDestroyVideoSessionParametersKHR`
pub type FN_vkDestroyVideoSessionParametersKHR = unsafe extern "system" fn(device: VkDevice, videoSessionParameters: VkVideoSessionParametersKHR, pAllocator: *const VkAllocationCallbacks) -> ();


/// `vkDeviceWaitIdle`
pub type PFN_vkDeviceWaitIdle = Option<FN_vkDeviceWaitIdle>;

/// `vkDeviceWaitIdle`
pub type FN_vkDeviceWaitIdle = unsafe extern "system" fn(device: VkDevice) -> VkResult;


/// `vkDisplayPowerControlEXT`
pub type PFN_vkDisplayPowerControlEXT = Option<FN_vkDisplayPowerControlEXT>;

/// `vkDisplayPowerControlEXT`
pub type FN_vkDisplayPowerControlEXT = unsafe extern "system" fn(device: VkDevice, display: VkDisplayKHR, pDisplayPowerInfo: *const VkDisplayPowerInfoEXT) -> VkResult;


/// `vkEndCommandBuffer`
pub type PFN_vkEndCommandBuffer = Option<FN_vkEndCommandBuffer>;

/// `vkEndCommandBuffer`
pub type FN_vkEndCommandBuffer = unsafe extern "system" fn(commandBuffer: VkCommandBuffer) -> VkResult;


/// `vkEnumerateDeviceExtensionProperties`
pub type PFN_vkEnumerateDeviceExtensionProperties = Option<FN_vkEnumerateDeviceExtensionProperties>;

/// `vkEnumerateDeviceExtensionProperties`
pub type FN_vkEnumerateDeviceExtensionProperties = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pLayerName: *const c_char, pPropertyCount: *mut uint32_t, pProperties: *mut VkExtensionProperties) -> VkResult;


/// `vkEnumerateDeviceLayerProperties`
pub type PFN_vkEnumerateDeviceLayerProperties = Option<FN_vkEnumerateDeviceLayerProperties>;

/// `vkEnumerateDeviceLayerProperties`
pub type FN_vkEnumerateDeviceLayerProperties = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pPropertyCount: *mut uint32_t, pProperties: *mut VkLayerProperties) -> VkResult;


/// `vkEnumerateInstanceExtensionProperties`
pub type PFN_vkEnumerateInstanceExtensionProperties = Option<FN_vkEnumerateInstanceExtensionProperties>;

/// `vkEnumerateInstanceExtensionProperties`
pub type FN_vkEnumerateInstanceExtensionProperties = unsafe extern "system" fn(pLayerName: *const c_char, pPropertyCount: *mut uint32_t, pProperties: *mut VkExtensionProperties) -> VkResult;


/// `vkEnumerateInstanceLayerProperties`
pub type PFN_vkEnumerateInstanceLayerProperties = Option<FN_vkEnumerateInstanceLayerProperties>;

/// `vkEnumerateInstanceLayerProperties`
pub type FN_vkEnumerateInstanceLayerProperties = unsafe extern "system" fn(pPropertyCount: *mut uint32_t, pProperties: *mut VkLayerProperties) -> VkResult;


/// `vkEnumerateInstanceVersion`
pub type PFN_vkEnumerateInstanceVersion = Option<FN_vkEnumerateInstanceVersion>;

/// `vkEnumerateInstanceVersion`
pub type FN_vkEnumerateInstanceVersion = unsafe extern "system" fn(pApiVersion: *mut uint32_t) -> VkResult;


/// `vkEnumeratePhysicalDeviceGroups`
pub type PFN_vkEnumeratePhysicalDeviceGroups = Option<FN_vkEnumeratePhysicalDeviceGroups>;

/// `vkEnumeratePhysicalDeviceGroups`
pub type FN_vkEnumeratePhysicalDeviceGroups = unsafe extern "system" fn(instance: VkInstance, pPhysicalDeviceGroupCount: *mut uint32_t, pPhysicalDeviceGroupProperties: *mut VkPhysicalDeviceGroupProperties) -> VkResult;


/// `vkEnumeratePhysicalDeviceGroupsKHR` = `vkEnumeratePhysicalDeviceGroups`
pub type PFN_vkEnumeratePhysicalDeviceGroupsKHR = PFN_vkEnumeratePhysicalDeviceGroups;

/// `vkEnumeratePhysicalDeviceGroupsKHR` = `vkEnumeratePhysicalDeviceGroups`
pub type FN_vkEnumeratePhysicalDeviceGroupsKHR = FN_vkEnumeratePhysicalDeviceGroups;

/// `vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM`
pub type PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM = Option<FN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM>;

/// `vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM`
pub type FN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, queueFamilyIndex: uint32_t, pCounterCount: *mut uint32_t, pCounters: *mut VkPerformanceCounterARM, pCounterDescriptions: *mut VkPerformanceCounterDescriptionARM) -> VkResult;


/// `vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR`
pub type PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR = Option<FN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR>;

/// `vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR`
pub type FN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, queueFamilyIndex: uint32_t, pCounterCount: *mut uint32_t, pCounters: *mut VkPerformanceCounterKHR, pCounterDescriptions: *mut VkPerformanceCounterDescriptionKHR) -> VkResult;


/// `vkEnumeratePhysicalDevices`
pub type PFN_vkEnumeratePhysicalDevices = Option<FN_vkEnumeratePhysicalDevices>;

/// `vkEnumeratePhysicalDevices`
pub type FN_vkEnumeratePhysicalDevices = unsafe extern "system" fn(instance: VkInstance, pPhysicalDeviceCount: *mut uint32_t, pPhysicalDevices: *mut VkPhysicalDevice) -> VkResult;


/// `vkEnumeratePhysicalDeviceShaderInstrumentationMetricsARM`
pub type PFN_vkEnumeratePhysicalDeviceShaderInstrumentationMetricsARM = Option<FN_vkEnumeratePhysicalDeviceShaderInstrumentationMetricsARM>;

/// `vkEnumeratePhysicalDeviceShaderInstrumentationMetricsARM`
pub type FN_vkEnumeratePhysicalDeviceShaderInstrumentationMetricsARM = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pDescriptionCount: *mut uint32_t, pDescriptions: *mut VkShaderInstrumentationMetricDescriptionARM) -> VkResult;


/// `vkExportMetalObjectsEXT`
pub type PFN_vkExportMetalObjectsEXT = Option<FN_vkExportMetalObjectsEXT>;

/// `vkExportMetalObjectsEXT`
pub type FN_vkExportMetalObjectsEXT = unsafe extern "system" fn(device: VkDevice, pMetalObjectsInfo: *mut VkExportMetalObjectsInfoEXT) -> ();


/// `vkFlushMappedMemoryRanges`
pub type PFN_vkFlushMappedMemoryRanges = Option<FN_vkFlushMappedMemoryRanges>;

/// `vkFlushMappedMemoryRanges`
pub type FN_vkFlushMappedMemoryRanges = unsafe extern "system" fn(device: VkDevice, memoryRangeCount: uint32_t, pMemoryRanges: *const VkMappedMemoryRange) -> VkResult;


/// `vkFreeCommandBuffers`
pub type PFN_vkFreeCommandBuffers = Option<FN_vkFreeCommandBuffers>;

/// `vkFreeCommandBuffers`
pub type FN_vkFreeCommandBuffers = unsafe extern "system" fn(device: VkDevice, commandPool: VkCommandPool, commandBufferCount: uint32_t, pCommandBuffers: *const VkCommandBuffer) -> ();


/// `vkFreeDescriptorSets`
pub type PFN_vkFreeDescriptorSets = Option<FN_vkFreeDescriptorSets>;

/// `vkFreeDescriptorSets`
pub type FN_vkFreeDescriptorSets = unsafe extern "system" fn(device: VkDevice, descriptorPool: VkDescriptorPool, descriptorSetCount: uint32_t, pDescriptorSets: *const VkDescriptorSet) -> VkResult;


/// `vkFreeMemory`
pub type PFN_vkFreeMemory = Option<FN_vkFreeMemory>;

/// `vkFreeMemory`
pub type FN_vkFreeMemory = unsafe extern "system" fn(device: VkDevice, memory: VkDeviceMemory, pAllocator: *const VkAllocationCallbacks) -> ();


/// `vkGetAccelerationStructureBuildSizesKHR`
pub type PFN_vkGetAccelerationStructureBuildSizesKHR = Option<FN_vkGetAccelerationStructureBuildSizesKHR>;

/// `vkGetAccelerationStructureBuildSizesKHR`
pub type FN_vkGetAccelerationStructureBuildSizesKHR = unsafe extern "system" fn(device: VkDevice, buildType: VkAccelerationStructureBuildTypeKHR, pBuildInfo: *const VkAccelerationStructureBuildGeometryInfoKHR, pMaxPrimitiveCounts: *const uint32_t, pSizeInfo: *mut VkAccelerationStructureBuildSizesInfoKHR) -> ();


/// `vkGetAccelerationStructureDeviceAddressKHR`
pub type PFN_vkGetAccelerationStructureDeviceAddressKHR = Option<FN_vkGetAccelerationStructureDeviceAddressKHR>;

/// `vkGetAccelerationStructureDeviceAddressKHR`
pub type FN_vkGetAccelerationStructureDeviceAddressKHR = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkAccelerationStructureDeviceAddressInfoKHR) -> VkDeviceAddress;


/// `vkGetAccelerationStructureHandleNV`
pub type PFN_vkGetAccelerationStructureHandleNV = Option<FN_vkGetAccelerationStructureHandleNV>;

/// `vkGetAccelerationStructureHandleNV`
pub type FN_vkGetAccelerationStructureHandleNV = unsafe extern "system" fn(device: VkDevice, accelerationStructure: VkAccelerationStructureNV, dataSize: size_t, pData: *mut void) -> VkResult;


/// `vkGetAccelerationStructureMemoryRequirementsNV`
pub type PFN_vkGetAccelerationStructureMemoryRequirementsNV = Option<FN_vkGetAccelerationStructureMemoryRequirementsNV>;

/// `vkGetAccelerationStructureMemoryRequirementsNV`
pub type FN_vkGetAccelerationStructureMemoryRequirementsNV = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkAccelerationStructureMemoryRequirementsInfoNV, pMemoryRequirements: *mut VkMemoryRequirements2KHR) -> ();


/// `vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT`
pub type PFN_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT = Option<FN_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT>;

/// `vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT`
pub type FN_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkAccelerationStructureCaptureDescriptorDataInfoEXT, pData: *mut void) -> VkResult;


/// `vkGetAndroidHardwareBufferPropertiesANDROID`
pub type PFN_vkGetAndroidHardwareBufferPropertiesANDROID = Option<FN_vkGetAndroidHardwareBufferPropertiesANDROID>;

/// `vkGetAndroidHardwareBufferPropertiesANDROID`
pub type FN_vkGetAndroidHardwareBufferPropertiesANDROID = unsafe extern "system" fn(device: VkDevice, buffer: *const AHardwareBuffer, pProperties: *mut VkAndroidHardwareBufferPropertiesANDROID) -> VkResult;


/// `vkGetBufferCollectionPropertiesFUCHSIA`
pub type PFN_vkGetBufferCollectionPropertiesFUCHSIA = Option<FN_vkGetBufferCollectionPropertiesFUCHSIA>;

/// `vkGetBufferCollectionPropertiesFUCHSIA`
pub type FN_vkGetBufferCollectionPropertiesFUCHSIA = unsafe extern "system" fn(device: VkDevice, collection: VkBufferCollectionFUCHSIA, pProperties: *mut VkBufferCollectionPropertiesFUCHSIA) -> VkResult;


/// `vkGetBufferDeviceAddress`
pub type PFN_vkGetBufferDeviceAddress = Option<FN_vkGetBufferDeviceAddress>;

/// `vkGetBufferDeviceAddress`
pub type FN_vkGetBufferDeviceAddress = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkBufferDeviceAddressInfo) -> VkDeviceAddress;


/// `vkGetBufferDeviceAddressEXT` = `vkGetBufferDeviceAddress`
pub type PFN_vkGetBufferDeviceAddressEXT = PFN_vkGetBufferDeviceAddress;

/// `vkGetBufferDeviceAddressEXT` = `vkGetBufferDeviceAddress`
pub type FN_vkGetBufferDeviceAddressEXT = FN_vkGetBufferDeviceAddress;

/// `vkGetBufferDeviceAddressKHR` = `vkGetBufferDeviceAddress`
pub type PFN_vkGetBufferDeviceAddressKHR = PFN_vkGetBufferDeviceAddress;

/// `vkGetBufferDeviceAddressKHR` = `vkGetBufferDeviceAddress`
pub type FN_vkGetBufferDeviceAddressKHR = FN_vkGetBufferDeviceAddress;

/// `vkGetBufferMemoryRequirements`
pub type PFN_vkGetBufferMemoryRequirements = Option<FN_vkGetBufferMemoryRequirements>;

/// `vkGetBufferMemoryRequirements`
pub type FN_vkGetBufferMemoryRequirements = unsafe extern "system" fn(device: VkDevice, buffer: VkBuffer, pMemoryRequirements: *mut VkMemoryRequirements) -> ();


/// `vkGetBufferMemoryRequirements2`
pub type PFN_vkGetBufferMemoryRequirements2 = Option<FN_vkGetBufferMemoryRequirements2>;

/// `vkGetBufferMemoryRequirements2`
pub type FN_vkGetBufferMemoryRequirements2 = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkBufferMemoryRequirementsInfo2, pMemoryRequirements: *mut VkMemoryRequirements2) -> ();


/// `vkGetBufferMemoryRequirements2KHR` = `vkGetBufferMemoryRequirements2`
pub type PFN_vkGetBufferMemoryRequirements2KHR = PFN_vkGetBufferMemoryRequirements2;

/// `vkGetBufferMemoryRequirements2KHR` = `vkGetBufferMemoryRequirements2`
pub type FN_vkGetBufferMemoryRequirements2KHR = FN_vkGetBufferMemoryRequirements2;

/// `vkGetBufferOpaqueCaptureAddress`
pub type PFN_vkGetBufferOpaqueCaptureAddress = Option<FN_vkGetBufferOpaqueCaptureAddress>;

/// `vkGetBufferOpaqueCaptureAddress`
pub type FN_vkGetBufferOpaqueCaptureAddress = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkBufferDeviceAddressInfo) -> uint64_t;


/// `vkGetBufferOpaqueCaptureAddressKHR` = `vkGetBufferOpaqueCaptureAddress`
pub type PFN_vkGetBufferOpaqueCaptureAddressKHR = PFN_vkGetBufferOpaqueCaptureAddress;

/// `vkGetBufferOpaqueCaptureAddressKHR` = `vkGetBufferOpaqueCaptureAddress`
pub type FN_vkGetBufferOpaqueCaptureAddressKHR = FN_vkGetBufferOpaqueCaptureAddress;

/// `vkGetBufferOpaqueCaptureDescriptorDataEXT`
pub type PFN_vkGetBufferOpaqueCaptureDescriptorDataEXT = Option<FN_vkGetBufferOpaqueCaptureDescriptorDataEXT>;

/// `vkGetBufferOpaqueCaptureDescriptorDataEXT`
pub type FN_vkGetBufferOpaqueCaptureDescriptorDataEXT = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkBufferCaptureDescriptorDataInfoEXT, pData: *mut void) -> VkResult;


/// `vkGetCalibratedTimestampsEXT` = `vkGetCalibratedTimestampsKHR`
pub type PFN_vkGetCalibratedTimestampsEXT = PFN_vkGetCalibratedTimestampsKHR;

/// `vkGetCalibratedTimestampsEXT` = `vkGetCalibratedTimestampsKHR`
pub type FN_vkGetCalibratedTimestampsEXT = FN_vkGetCalibratedTimestampsKHR;

/// `vkGetCalibratedTimestampsKHR`
pub type PFN_vkGetCalibratedTimestampsKHR = Option<FN_vkGetCalibratedTimestampsKHR>;

/// `vkGetCalibratedTimestampsKHR`
pub type FN_vkGetCalibratedTimestampsKHR = unsafe extern "system" fn(device: VkDevice, timestampCount: uint32_t, pTimestampInfos: *const VkCalibratedTimestampInfoKHR, pTimestamps: *mut uint64_t, pMaxDeviation: *mut uint64_t) -> VkResult;


/// `vkGetClusterAccelerationStructureBuildSizesNV`
pub type PFN_vkGetClusterAccelerationStructureBuildSizesNV = Option<FN_vkGetClusterAccelerationStructureBuildSizesNV>;

/// `vkGetClusterAccelerationStructureBuildSizesNV`
pub type FN_vkGetClusterAccelerationStructureBuildSizesNV = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkClusterAccelerationStructureInputInfoNV, pSizeInfo: *mut VkAccelerationStructureBuildSizesInfoKHR) -> ();


/// `vkGetCommandPoolMemoryConsumption`
pub type PFN_vkGetCommandPoolMemoryConsumption = Option<FN_vkGetCommandPoolMemoryConsumption>;

/// `vkGetCommandPoolMemoryConsumption`
pub type FN_vkGetCommandPoolMemoryConsumption = unsafe extern "system" fn(device: VkDevice, commandPool: VkCommandPool, commandBuffer: VkCommandBuffer, pConsumption: *mut VkCommandPoolMemoryConsumption) -> ();


/// `vkGetCudaModuleCacheNV`
pub type PFN_vkGetCudaModuleCacheNV = Option<FN_vkGetCudaModuleCacheNV>;

/// `vkGetCudaModuleCacheNV`
pub type FN_vkGetCudaModuleCacheNV = unsafe extern "system" fn(device: VkDevice, module: VkCudaModuleNV, pCacheSize: *mut size_t, pCacheData: *mut void) -> VkResult;


/// `vkGetDataGraphPipelineAvailablePropertiesARM`
pub type PFN_vkGetDataGraphPipelineAvailablePropertiesARM = Option<FN_vkGetDataGraphPipelineAvailablePropertiesARM>;

/// `vkGetDataGraphPipelineAvailablePropertiesARM`
pub type FN_vkGetDataGraphPipelineAvailablePropertiesARM = unsafe extern "system" fn(device: VkDevice, pPipelineInfo: *const VkDataGraphPipelineInfoARM, pPropertiesCount: *mut uint32_t, pProperties: *mut VkDataGraphPipelinePropertyARM) -> VkResult;


/// `vkGetDataGraphPipelinePropertiesARM`
pub type PFN_vkGetDataGraphPipelinePropertiesARM = Option<FN_vkGetDataGraphPipelinePropertiesARM>;

/// `vkGetDataGraphPipelinePropertiesARM`
pub type FN_vkGetDataGraphPipelinePropertiesARM = unsafe extern "system" fn(device: VkDevice, pPipelineInfo: *const VkDataGraphPipelineInfoARM, propertiesCount: uint32_t, pProperties: *mut VkDataGraphPipelinePropertyQueryResultARM) -> VkResult;


/// `vkGetDataGraphPipelineSessionBindPointRequirementsARM`
pub type PFN_vkGetDataGraphPipelineSessionBindPointRequirementsARM = Option<FN_vkGetDataGraphPipelineSessionBindPointRequirementsARM>;

/// `vkGetDataGraphPipelineSessionBindPointRequirementsARM`
pub type FN_vkGetDataGraphPipelineSessionBindPointRequirementsARM = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkDataGraphPipelineSessionBindPointRequirementsInfoARM, pBindPointRequirementCount: *mut uint32_t, pBindPointRequirements: *mut VkDataGraphPipelineSessionBindPointRequirementARM) -> VkResult;


/// `vkGetDataGraphPipelineSessionMemoryRequirementsARM`
pub type PFN_vkGetDataGraphPipelineSessionMemoryRequirementsARM = Option<FN_vkGetDataGraphPipelineSessionMemoryRequirementsARM>;

/// `vkGetDataGraphPipelineSessionMemoryRequirementsARM`
pub type FN_vkGetDataGraphPipelineSessionMemoryRequirementsARM = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkDataGraphPipelineSessionMemoryRequirementsInfoARM, pMemoryRequirements: *mut VkMemoryRequirements2) -> ();


/// `vkGetDeferredOperationMaxConcurrencyKHR`
pub type PFN_vkGetDeferredOperationMaxConcurrencyKHR = Option<FN_vkGetDeferredOperationMaxConcurrencyKHR>;

/// `vkGetDeferredOperationMaxConcurrencyKHR`
pub type FN_vkGetDeferredOperationMaxConcurrencyKHR = unsafe extern "system" fn(device: VkDevice, operation: VkDeferredOperationKHR) -> uint32_t;


/// `vkGetDeferredOperationResultKHR`
pub type PFN_vkGetDeferredOperationResultKHR = Option<FN_vkGetDeferredOperationResultKHR>;

/// `vkGetDeferredOperationResultKHR`
pub type FN_vkGetDeferredOperationResultKHR = unsafe extern "system" fn(device: VkDevice, operation: VkDeferredOperationKHR) -> VkResult;


/// `vkGetDescriptorEXT`
pub type PFN_vkGetDescriptorEXT = Option<FN_vkGetDescriptorEXT>;

/// `vkGetDescriptorEXT`
pub type FN_vkGetDescriptorEXT = unsafe extern "system" fn(device: VkDevice, pDescriptorInfo: *const VkDescriptorGetInfoEXT, dataSize: size_t, pDescriptor: *mut void) -> ();


/// `vkGetDescriptorSetHostMappingVALVE`
pub type PFN_vkGetDescriptorSetHostMappingVALVE = Option<FN_vkGetDescriptorSetHostMappingVALVE>;

/// `vkGetDescriptorSetHostMappingVALVE`
pub type FN_vkGetDescriptorSetHostMappingVALVE = unsafe extern "system" fn(device: VkDevice, descriptorSet: VkDescriptorSet, ppData: *mut *mut void) -> ();


/// `vkGetDescriptorSetLayoutBindingOffsetEXT`
pub type PFN_vkGetDescriptorSetLayoutBindingOffsetEXT = Option<FN_vkGetDescriptorSetLayoutBindingOffsetEXT>;

/// `vkGetDescriptorSetLayoutBindingOffsetEXT`
pub type FN_vkGetDescriptorSetLayoutBindingOffsetEXT = unsafe extern "system" fn(device: VkDevice, layout: VkDescriptorSetLayout, binding: uint32_t, pOffset: *mut VkDeviceSize) -> ();


/// `vkGetDescriptorSetLayoutHostMappingInfoVALVE`
pub type PFN_vkGetDescriptorSetLayoutHostMappingInfoVALVE = Option<FN_vkGetDescriptorSetLayoutHostMappingInfoVALVE>;

/// `vkGetDescriptorSetLayoutHostMappingInfoVALVE`
pub type FN_vkGetDescriptorSetLayoutHostMappingInfoVALVE = unsafe extern "system" fn(device: VkDevice, pBindingReference: *const VkDescriptorSetBindingReferenceVALVE, pHostMapping: *mut VkDescriptorSetLayoutHostMappingInfoVALVE) -> ();


/// `vkGetDescriptorSetLayoutSizeEXT`
pub type PFN_vkGetDescriptorSetLayoutSizeEXT = Option<FN_vkGetDescriptorSetLayoutSizeEXT>;

/// `vkGetDescriptorSetLayoutSizeEXT`
pub type FN_vkGetDescriptorSetLayoutSizeEXT = unsafe extern "system" fn(device: VkDevice, layout: VkDescriptorSetLayout, pLayoutSizeInBytes: *mut VkDeviceSize) -> ();


/// `vkGetDescriptorSetLayoutSupport`
pub type PFN_vkGetDescriptorSetLayoutSupport = Option<FN_vkGetDescriptorSetLayoutSupport>;

/// `vkGetDescriptorSetLayoutSupport`
pub type FN_vkGetDescriptorSetLayoutSupport = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkDescriptorSetLayoutCreateInfo, pSupport: *mut VkDescriptorSetLayoutSupport) -> ();


/// `vkGetDescriptorSetLayoutSupportKHR` = `vkGetDescriptorSetLayoutSupport`
pub type PFN_vkGetDescriptorSetLayoutSupportKHR = PFN_vkGetDescriptorSetLayoutSupport;

/// `vkGetDescriptorSetLayoutSupportKHR` = `vkGetDescriptorSetLayoutSupport`
pub type FN_vkGetDescriptorSetLayoutSupportKHR = FN_vkGetDescriptorSetLayoutSupport;

/// `vkGetDeviceAccelerationStructureCompatibilityKHR`
pub type PFN_vkGetDeviceAccelerationStructureCompatibilityKHR = Option<FN_vkGetDeviceAccelerationStructureCompatibilityKHR>;

/// `vkGetDeviceAccelerationStructureCompatibilityKHR`
pub type FN_vkGetDeviceAccelerationStructureCompatibilityKHR = unsafe extern "system" fn(device: VkDevice, pVersionInfo: *const VkAccelerationStructureVersionInfoKHR, pCompatibility: *mut VkAccelerationStructureCompatibilityKHR) -> ();


/// `vkGetDeviceBufferMemoryRequirements`
pub type PFN_vkGetDeviceBufferMemoryRequirements = Option<FN_vkGetDeviceBufferMemoryRequirements>;

/// `vkGetDeviceBufferMemoryRequirements`
pub type FN_vkGetDeviceBufferMemoryRequirements = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkDeviceBufferMemoryRequirements, pMemoryRequirements: *mut VkMemoryRequirements2) -> ();


/// `vkGetDeviceBufferMemoryRequirementsKHR` = `vkGetDeviceBufferMemoryRequirements`
pub type PFN_vkGetDeviceBufferMemoryRequirementsKHR = PFN_vkGetDeviceBufferMemoryRequirements;

/// `vkGetDeviceBufferMemoryRequirementsKHR` = `vkGetDeviceBufferMemoryRequirements`
pub type FN_vkGetDeviceBufferMemoryRequirementsKHR = FN_vkGetDeviceBufferMemoryRequirements;

/// `vkGetDeviceCombinedImageSamplerIndexNVX`
pub type PFN_vkGetDeviceCombinedImageSamplerIndexNVX = Option<FN_vkGetDeviceCombinedImageSamplerIndexNVX>;

/// `vkGetDeviceCombinedImageSamplerIndexNVX`
pub type FN_vkGetDeviceCombinedImageSamplerIndexNVX = unsafe extern "system" fn(device: VkDevice, imageViewIndex: uint64_t, samplerIndex: uint64_t) -> uint64_t;


/// `vkGetDeviceFaultInfoEXT`
pub type PFN_vkGetDeviceFaultInfoEXT = Option<FN_vkGetDeviceFaultInfoEXT>;

/// `vkGetDeviceFaultInfoEXT`
pub type FN_vkGetDeviceFaultInfoEXT = unsafe extern "system" fn(device: VkDevice, pFaultCounts: *mut VkDeviceFaultCountsEXT, pFaultInfo: *mut VkDeviceFaultInfoEXT) -> VkResult;


/// `vkGetDeviceGroupPeerMemoryFeatures`
pub type PFN_vkGetDeviceGroupPeerMemoryFeatures = Option<FN_vkGetDeviceGroupPeerMemoryFeatures>;

/// `vkGetDeviceGroupPeerMemoryFeatures`
pub type FN_vkGetDeviceGroupPeerMemoryFeatures = unsafe extern "system" fn(device: VkDevice, heapIndex: uint32_t, localDeviceIndex: uint32_t, remoteDeviceIndex: uint32_t, pPeerMemoryFeatures: *mut VkPeerMemoryFeatureFlags) -> ();


/// `vkGetDeviceGroupPeerMemoryFeaturesKHR` = `vkGetDeviceGroupPeerMemoryFeatures`
pub type PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR = PFN_vkGetDeviceGroupPeerMemoryFeatures;

/// `vkGetDeviceGroupPeerMemoryFeaturesKHR` = `vkGetDeviceGroupPeerMemoryFeatures`
pub type FN_vkGetDeviceGroupPeerMemoryFeaturesKHR = FN_vkGetDeviceGroupPeerMemoryFeatures;

/// `vkGetDeviceGroupPresentCapabilitiesKHR`
pub type PFN_vkGetDeviceGroupPresentCapabilitiesKHR = Option<FN_vkGetDeviceGroupPresentCapabilitiesKHR>;

/// `vkGetDeviceGroupPresentCapabilitiesKHR`
pub type FN_vkGetDeviceGroupPresentCapabilitiesKHR = unsafe extern "system" fn(device: VkDevice, pDeviceGroupPresentCapabilities: *mut VkDeviceGroupPresentCapabilitiesKHR) -> VkResult;


/// `vkGetDeviceGroupSurfacePresentModes2EXT`
pub type PFN_vkGetDeviceGroupSurfacePresentModes2EXT = Option<FN_vkGetDeviceGroupSurfacePresentModes2EXT>;

/// `vkGetDeviceGroupSurfacePresentModes2EXT`
pub type FN_vkGetDeviceGroupSurfacePresentModes2EXT = unsafe extern "system" fn(device: VkDevice, pSurfaceInfo: *const VkPhysicalDeviceSurfaceInfo2KHR, pModes: *mut VkDeviceGroupPresentModeFlagsKHR) -> VkResult;


/// `vkGetDeviceGroupSurfacePresentModesKHR`
pub type PFN_vkGetDeviceGroupSurfacePresentModesKHR = Option<FN_vkGetDeviceGroupSurfacePresentModesKHR>;

/// `vkGetDeviceGroupSurfacePresentModesKHR`
pub type FN_vkGetDeviceGroupSurfacePresentModesKHR = unsafe extern "system" fn(device: VkDevice, surface: VkSurfaceKHR, pModes: *mut VkDeviceGroupPresentModeFlagsKHR) -> VkResult;


/// `vkGetDeviceImageMemoryRequirements`
pub type PFN_vkGetDeviceImageMemoryRequirements = Option<FN_vkGetDeviceImageMemoryRequirements>;

/// `vkGetDeviceImageMemoryRequirements`
pub type FN_vkGetDeviceImageMemoryRequirements = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkDeviceImageMemoryRequirements, pMemoryRequirements: *mut VkMemoryRequirements2) -> ();


/// `vkGetDeviceImageMemoryRequirementsKHR` = `vkGetDeviceImageMemoryRequirements`
pub type PFN_vkGetDeviceImageMemoryRequirementsKHR = PFN_vkGetDeviceImageMemoryRequirements;

/// `vkGetDeviceImageMemoryRequirementsKHR` = `vkGetDeviceImageMemoryRequirements`
pub type FN_vkGetDeviceImageMemoryRequirementsKHR = FN_vkGetDeviceImageMemoryRequirements;

/// `vkGetDeviceImageSparseMemoryRequirements`
pub type PFN_vkGetDeviceImageSparseMemoryRequirements = Option<FN_vkGetDeviceImageSparseMemoryRequirements>;

/// `vkGetDeviceImageSparseMemoryRequirements`
pub type FN_vkGetDeviceImageSparseMemoryRequirements = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkDeviceImageMemoryRequirements, pSparseMemoryRequirementCount: *mut uint32_t, pSparseMemoryRequirements: *mut VkSparseImageMemoryRequirements2) -> ();


/// `vkGetDeviceImageSparseMemoryRequirementsKHR` = `vkGetDeviceImageSparseMemoryRequirements`
pub type PFN_vkGetDeviceImageSparseMemoryRequirementsKHR = PFN_vkGetDeviceImageSparseMemoryRequirements;

/// `vkGetDeviceImageSparseMemoryRequirementsKHR` = `vkGetDeviceImageSparseMemoryRequirements`
pub type FN_vkGetDeviceImageSparseMemoryRequirementsKHR = FN_vkGetDeviceImageSparseMemoryRequirements;

/// `vkGetDeviceImageSubresourceLayout`
pub type PFN_vkGetDeviceImageSubresourceLayout = Option<FN_vkGetDeviceImageSubresourceLayout>;

/// `vkGetDeviceImageSubresourceLayout`
pub type FN_vkGetDeviceImageSubresourceLayout = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkDeviceImageSubresourceInfo, pLayout: *mut VkSubresourceLayout2) -> ();


/// `vkGetDeviceImageSubresourceLayoutKHR` = `vkGetDeviceImageSubresourceLayout`
pub type PFN_vkGetDeviceImageSubresourceLayoutKHR = PFN_vkGetDeviceImageSubresourceLayout;

/// `vkGetDeviceImageSubresourceLayoutKHR` = `vkGetDeviceImageSubresourceLayout`
pub type FN_vkGetDeviceImageSubresourceLayoutKHR = FN_vkGetDeviceImageSubresourceLayout;

/// `vkGetDeviceMemoryCommitment`
pub type PFN_vkGetDeviceMemoryCommitment = Option<FN_vkGetDeviceMemoryCommitment>;

/// `vkGetDeviceMemoryCommitment`
pub type FN_vkGetDeviceMemoryCommitment = unsafe extern "system" fn(device: VkDevice, memory: VkDeviceMemory, pCommittedMemoryInBytes: *mut VkDeviceSize) -> ();


/// `vkGetDeviceMemoryOpaqueCaptureAddress`
pub type PFN_vkGetDeviceMemoryOpaqueCaptureAddress = Option<FN_vkGetDeviceMemoryOpaqueCaptureAddress>;

/// `vkGetDeviceMemoryOpaqueCaptureAddress`
pub type FN_vkGetDeviceMemoryOpaqueCaptureAddress = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkDeviceMemoryOpaqueCaptureAddressInfo) -> uint64_t;


/// `vkGetDeviceMemoryOpaqueCaptureAddressKHR` = `vkGetDeviceMemoryOpaqueCaptureAddress`
pub type PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR = PFN_vkGetDeviceMemoryOpaqueCaptureAddress;

/// `vkGetDeviceMemoryOpaqueCaptureAddressKHR` = `vkGetDeviceMemoryOpaqueCaptureAddress`
pub type FN_vkGetDeviceMemoryOpaqueCaptureAddressKHR = FN_vkGetDeviceMemoryOpaqueCaptureAddress;

/// `vkGetDeviceMicromapCompatibilityEXT`
pub type PFN_vkGetDeviceMicromapCompatibilityEXT = Option<FN_vkGetDeviceMicromapCompatibilityEXT>;

/// `vkGetDeviceMicromapCompatibilityEXT`
pub type FN_vkGetDeviceMicromapCompatibilityEXT = unsafe extern "system" fn(device: VkDevice, pVersionInfo: *const VkMicromapVersionInfoEXT, pCompatibility: *mut VkAccelerationStructureCompatibilityKHR) -> ();


/// `vkGetDeviceProcAddr`
pub type PFN_vkGetDeviceProcAddr = Option<FN_vkGetDeviceProcAddr>;

/// `vkGetDeviceProcAddr`
pub type FN_vkGetDeviceProcAddr = unsafe extern "system" fn(device: VkDevice, pName: *const c_char) -> PFN_vkVoidFunction;


/// `vkGetDeviceQueue`
pub type PFN_vkGetDeviceQueue = Option<FN_vkGetDeviceQueue>;

/// `vkGetDeviceQueue`
pub type FN_vkGetDeviceQueue = unsafe extern "system" fn(device: VkDevice, queueFamilyIndex: uint32_t, queueIndex: uint32_t, pQueue: *mut VkQueue) -> ();


/// `vkGetDeviceQueue2`
pub type PFN_vkGetDeviceQueue2 = Option<FN_vkGetDeviceQueue2>;

/// `vkGetDeviceQueue2`
pub type FN_vkGetDeviceQueue2 = unsafe extern "system" fn(device: VkDevice, pQueueInfo: *const VkDeviceQueueInfo2, pQueue: *mut VkQueue) -> ();


/// `vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI`
pub type PFN_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI = Option<FN_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI>;

/// `vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI`
pub type FN_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI = unsafe extern "system" fn(device: VkDevice, renderpass: VkRenderPass, pMaxWorkgroupSize: *mut VkExtent2D) -> VkResult;


/// `vkGetDeviceTensorMemoryRequirementsARM`
pub type PFN_vkGetDeviceTensorMemoryRequirementsARM = Option<FN_vkGetDeviceTensorMemoryRequirementsARM>;

/// `vkGetDeviceTensorMemoryRequirementsARM`
pub type FN_vkGetDeviceTensorMemoryRequirementsARM = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkDeviceTensorMemoryRequirementsARM, pMemoryRequirements: *mut VkMemoryRequirements2) -> ();


/// `vkGetDisplayModeProperties2KHR`
pub type PFN_vkGetDisplayModeProperties2KHR = Option<FN_vkGetDisplayModeProperties2KHR>;

/// `vkGetDisplayModeProperties2KHR`
pub type FN_vkGetDisplayModeProperties2KHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, display: VkDisplayKHR, pPropertyCount: *mut uint32_t, pProperties: *mut VkDisplayModeProperties2KHR) -> VkResult;


/// `vkGetDisplayModePropertiesKHR`
pub type PFN_vkGetDisplayModePropertiesKHR = Option<FN_vkGetDisplayModePropertiesKHR>;

/// `vkGetDisplayModePropertiesKHR`
pub type FN_vkGetDisplayModePropertiesKHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, display: VkDisplayKHR, pPropertyCount: *mut uint32_t, pProperties: *mut VkDisplayModePropertiesKHR) -> VkResult;


/// `vkGetDisplayPlaneCapabilities2KHR`
pub type PFN_vkGetDisplayPlaneCapabilities2KHR = Option<FN_vkGetDisplayPlaneCapabilities2KHR>;

/// `vkGetDisplayPlaneCapabilities2KHR`
pub type FN_vkGetDisplayPlaneCapabilities2KHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pDisplayPlaneInfo: *const VkDisplayPlaneInfo2KHR, pCapabilities: *mut VkDisplayPlaneCapabilities2KHR) -> VkResult;


/// `vkGetDisplayPlaneCapabilitiesKHR`
pub type PFN_vkGetDisplayPlaneCapabilitiesKHR = Option<FN_vkGetDisplayPlaneCapabilitiesKHR>;

/// `vkGetDisplayPlaneCapabilitiesKHR`
pub type FN_vkGetDisplayPlaneCapabilitiesKHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, mode: VkDisplayModeKHR, planeIndex: uint32_t, pCapabilities: *mut VkDisplayPlaneCapabilitiesKHR) -> VkResult;


/// `vkGetDisplayPlaneSupportedDisplaysKHR`
pub type PFN_vkGetDisplayPlaneSupportedDisplaysKHR = Option<FN_vkGetDisplayPlaneSupportedDisplaysKHR>;

/// `vkGetDisplayPlaneSupportedDisplaysKHR`
pub type FN_vkGetDisplayPlaneSupportedDisplaysKHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, planeIndex: uint32_t, pDisplayCount: *mut uint32_t, pDisplays: *mut VkDisplayKHR) -> VkResult;


/// `vkGetDrmDisplayEXT`
pub type PFN_vkGetDrmDisplayEXT = Option<FN_vkGetDrmDisplayEXT>;

/// `vkGetDrmDisplayEXT`
pub type FN_vkGetDrmDisplayEXT = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, drmFd: int32_t, connectorId: uint32_t, display: *mut VkDisplayKHR) -> VkResult;


/// `vkGetDynamicRenderingTilePropertiesQCOM`
pub type PFN_vkGetDynamicRenderingTilePropertiesQCOM = Option<FN_vkGetDynamicRenderingTilePropertiesQCOM>;

/// `vkGetDynamicRenderingTilePropertiesQCOM`
pub type FN_vkGetDynamicRenderingTilePropertiesQCOM = unsafe extern "system" fn(device: VkDevice, pRenderingInfo: *const VkRenderingInfo, pProperties: *mut VkTilePropertiesQCOM) -> VkResult;


/// `vkGetEncodedVideoSessionParametersKHR`
pub type PFN_vkGetEncodedVideoSessionParametersKHR = Option<FN_vkGetEncodedVideoSessionParametersKHR>;

/// `vkGetEncodedVideoSessionParametersKHR`
pub type FN_vkGetEncodedVideoSessionParametersKHR = unsafe extern "system" fn(device: VkDevice, pVideoSessionParametersInfo: *const VkVideoEncodeSessionParametersGetInfoKHR, pFeedbackInfo: *mut VkVideoEncodeSessionParametersFeedbackInfoKHR, pDataSize: *mut size_t, pData: *mut void) -> VkResult;


/// `vkGetEventStatus`
pub type PFN_vkGetEventStatus = Option<FN_vkGetEventStatus>;

/// `vkGetEventStatus`
pub type FN_vkGetEventStatus = unsafe extern "system" fn(device: VkDevice, event: VkEvent) -> VkResult;


/// `vkGetExecutionGraphPipelineNodeIndexAMDX`
pub type PFN_vkGetExecutionGraphPipelineNodeIndexAMDX = Option<FN_vkGetExecutionGraphPipelineNodeIndexAMDX>;

/// `vkGetExecutionGraphPipelineNodeIndexAMDX`
pub type FN_vkGetExecutionGraphPipelineNodeIndexAMDX = unsafe extern "system" fn(device: VkDevice, executionGraph: VkPipeline, pNodeInfo: *const VkPipelineShaderStageNodeCreateInfoAMDX, pNodeIndex: *mut uint32_t) -> VkResult;


/// `vkGetExecutionGraphPipelineScratchSizeAMDX`
pub type PFN_vkGetExecutionGraphPipelineScratchSizeAMDX = Option<FN_vkGetExecutionGraphPipelineScratchSizeAMDX>;

/// `vkGetExecutionGraphPipelineScratchSizeAMDX`
pub type FN_vkGetExecutionGraphPipelineScratchSizeAMDX = unsafe extern "system" fn(device: VkDevice, executionGraph: VkPipeline, pSizeInfo: *mut VkExecutionGraphPipelineScratchSizeAMDX) -> VkResult;


/// `vkGetExternalComputeQueueDataNV`
pub type PFN_vkGetExternalComputeQueueDataNV = Option<FN_vkGetExternalComputeQueueDataNV>;

/// `vkGetExternalComputeQueueDataNV`
pub type FN_vkGetExternalComputeQueueDataNV = unsafe extern "system" fn(externalQueue: VkExternalComputeQueueNV, params: *mut VkExternalComputeQueueDataParamsNV, pData: *mut void) -> ();


/// `vkGetFaultData`
pub type PFN_vkGetFaultData = Option<FN_vkGetFaultData>;

/// `vkGetFaultData`
pub type FN_vkGetFaultData = unsafe extern "system" fn(device: VkDevice, faultQueryBehavior: VkFaultQueryBehavior, pUnrecordedFaults: *mut VkBool32, pFaultCount: *mut uint32_t, pFaults: *mut VkFaultData) -> VkResult;


/// `vkGetFenceFdKHR`
pub type PFN_vkGetFenceFdKHR = Option<FN_vkGetFenceFdKHR>;

/// `vkGetFenceFdKHR`
pub type FN_vkGetFenceFdKHR = unsafe extern "system" fn(device: VkDevice, pGetFdInfo: *const VkFenceGetFdInfoKHR, pFd: *mut int) -> VkResult;


/// `vkGetFenceSciSyncFenceNV`
pub type PFN_vkGetFenceSciSyncFenceNV = Option<FN_vkGetFenceSciSyncFenceNV>;

/// `vkGetFenceSciSyncFenceNV`
pub type FN_vkGetFenceSciSyncFenceNV = unsafe extern "system" fn(device: VkDevice, pGetSciSyncHandleInfo: *const VkFenceGetSciSyncInfoNV, pHandle: *mut void) -> VkResult;


/// `vkGetFenceSciSyncObjNV`
pub type PFN_vkGetFenceSciSyncObjNV = Option<FN_vkGetFenceSciSyncObjNV>;

/// `vkGetFenceSciSyncObjNV`
pub type FN_vkGetFenceSciSyncObjNV = unsafe extern "system" fn(device: VkDevice, pGetSciSyncHandleInfo: *const VkFenceGetSciSyncInfoNV, pHandle: *mut void) -> VkResult;


/// `vkGetFenceStatus`
pub type PFN_vkGetFenceStatus = Option<FN_vkGetFenceStatus>;

/// `vkGetFenceStatus`
pub type FN_vkGetFenceStatus = unsafe extern "system" fn(device: VkDevice, fence: VkFence) -> VkResult;


/// `vkGetFenceWin32HandleKHR`
pub type PFN_vkGetFenceWin32HandleKHR = Option<FN_vkGetFenceWin32HandleKHR>;

/// `vkGetFenceWin32HandleKHR`
pub type FN_vkGetFenceWin32HandleKHR = unsafe extern "system" fn(device: VkDevice, pGetWin32HandleInfo: *const VkFenceGetWin32HandleInfoKHR, pHandle: *mut HANDLE) -> VkResult;


/// `vkGetFramebufferTilePropertiesQCOM`
pub type PFN_vkGetFramebufferTilePropertiesQCOM = Option<FN_vkGetFramebufferTilePropertiesQCOM>;

/// `vkGetFramebufferTilePropertiesQCOM`
pub type FN_vkGetFramebufferTilePropertiesQCOM = unsafe extern "system" fn(device: VkDevice, framebuffer: VkFramebuffer, pPropertiesCount: *mut uint32_t, pProperties: *mut VkTilePropertiesQCOM) -> VkResult;


/// `vkGetGeneratedCommandsMemoryRequirementsEXT`
pub type PFN_vkGetGeneratedCommandsMemoryRequirementsEXT = Option<FN_vkGetGeneratedCommandsMemoryRequirementsEXT>;

/// `vkGetGeneratedCommandsMemoryRequirementsEXT`
pub type FN_vkGetGeneratedCommandsMemoryRequirementsEXT = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkGeneratedCommandsMemoryRequirementsInfoEXT, pMemoryRequirements: *mut VkMemoryRequirements2) -> ();


/// `vkGetGeneratedCommandsMemoryRequirementsNV`
pub type PFN_vkGetGeneratedCommandsMemoryRequirementsNV = Option<FN_vkGetGeneratedCommandsMemoryRequirementsNV>;

/// `vkGetGeneratedCommandsMemoryRequirementsNV`
pub type FN_vkGetGeneratedCommandsMemoryRequirementsNV = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkGeneratedCommandsMemoryRequirementsInfoNV, pMemoryRequirements: *mut VkMemoryRequirements2) -> ();


/// `vkGetImageDrmFormatModifierPropertiesEXT`
pub type PFN_vkGetImageDrmFormatModifierPropertiesEXT = Option<FN_vkGetImageDrmFormatModifierPropertiesEXT>;

/// `vkGetImageDrmFormatModifierPropertiesEXT`
pub type FN_vkGetImageDrmFormatModifierPropertiesEXT = unsafe extern "system" fn(device: VkDevice, image: VkImage, pProperties: *mut VkImageDrmFormatModifierPropertiesEXT) -> VkResult;


/// `vkGetImageMemoryRequirements`
pub type PFN_vkGetImageMemoryRequirements = Option<FN_vkGetImageMemoryRequirements>;

/// `vkGetImageMemoryRequirements`
pub type FN_vkGetImageMemoryRequirements = unsafe extern "system" fn(device: VkDevice, image: VkImage, pMemoryRequirements: *mut VkMemoryRequirements) -> ();


/// `vkGetImageMemoryRequirements2`
pub type PFN_vkGetImageMemoryRequirements2 = Option<FN_vkGetImageMemoryRequirements2>;

/// `vkGetImageMemoryRequirements2`
pub type FN_vkGetImageMemoryRequirements2 = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkImageMemoryRequirementsInfo2, pMemoryRequirements: *mut VkMemoryRequirements2) -> ();


/// `vkGetImageMemoryRequirements2KHR` = `vkGetImageMemoryRequirements2`
pub type PFN_vkGetImageMemoryRequirements2KHR = PFN_vkGetImageMemoryRequirements2;

/// `vkGetImageMemoryRequirements2KHR` = `vkGetImageMemoryRequirements2`
pub type FN_vkGetImageMemoryRequirements2KHR = FN_vkGetImageMemoryRequirements2;

/// `vkGetImageOpaqueCaptureDataEXT`
pub type PFN_vkGetImageOpaqueCaptureDataEXT = Option<FN_vkGetImageOpaqueCaptureDataEXT>;

/// `vkGetImageOpaqueCaptureDataEXT`
pub type FN_vkGetImageOpaqueCaptureDataEXT = unsafe extern "system" fn(device: VkDevice, imageCount: uint32_t, pImages: *const VkImage, pDatas: *mut VkHostAddressRangeEXT) -> VkResult;


/// `vkGetImageOpaqueCaptureDescriptorDataEXT`
pub type PFN_vkGetImageOpaqueCaptureDescriptorDataEXT = Option<FN_vkGetImageOpaqueCaptureDescriptorDataEXT>;

/// `vkGetImageOpaqueCaptureDescriptorDataEXT`
pub type FN_vkGetImageOpaqueCaptureDescriptorDataEXT = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkImageCaptureDescriptorDataInfoEXT, pData: *mut void) -> VkResult;


/// `vkGetImageSparseMemoryRequirements`
pub type PFN_vkGetImageSparseMemoryRequirements = Option<FN_vkGetImageSparseMemoryRequirements>;

/// `vkGetImageSparseMemoryRequirements`
pub type FN_vkGetImageSparseMemoryRequirements = unsafe extern "system" fn(device: VkDevice, image: VkImage, pSparseMemoryRequirementCount: *mut uint32_t, pSparseMemoryRequirements: *mut VkSparseImageMemoryRequirements) -> ();


/// `vkGetImageSparseMemoryRequirements2`
pub type PFN_vkGetImageSparseMemoryRequirements2 = Option<FN_vkGetImageSparseMemoryRequirements2>;

/// `vkGetImageSparseMemoryRequirements2`
pub type FN_vkGetImageSparseMemoryRequirements2 = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkImageSparseMemoryRequirementsInfo2, pSparseMemoryRequirementCount: *mut uint32_t, pSparseMemoryRequirements: *mut VkSparseImageMemoryRequirements2) -> ();


/// `vkGetImageSparseMemoryRequirements2KHR` = `vkGetImageSparseMemoryRequirements2`
pub type PFN_vkGetImageSparseMemoryRequirements2KHR = PFN_vkGetImageSparseMemoryRequirements2;

/// `vkGetImageSparseMemoryRequirements2KHR` = `vkGetImageSparseMemoryRequirements2`
pub type FN_vkGetImageSparseMemoryRequirements2KHR = FN_vkGetImageSparseMemoryRequirements2;

/// `vkGetImageSubresourceLayout`
pub type PFN_vkGetImageSubresourceLayout = Option<FN_vkGetImageSubresourceLayout>;

/// `vkGetImageSubresourceLayout`
pub type FN_vkGetImageSubresourceLayout = unsafe extern "system" fn(device: VkDevice, image: VkImage, pSubresource: *const VkImageSubresource, pLayout: *mut VkSubresourceLayout) -> ();


/// `vkGetImageSubresourceLayout2`
pub type PFN_vkGetImageSubresourceLayout2 = Option<FN_vkGetImageSubresourceLayout2>;

/// `vkGetImageSubresourceLayout2`
pub type FN_vkGetImageSubresourceLayout2 = unsafe extern "system" fn(device: VkDevice, image: VkImage, pSubresource: *const VkImageSubresource2, pLayout: *mut VkSubresourceLayout2) -> ();


/// `vkGetImageSubresourceLayout2EXT` = `vkGetImageSubresourceLayout2`
pub type PFN_vkGetImageSubresourceLayout2EXT = PFN_vkGetImageSubresourceLayout2;

/// `vkGetImageSubresourceLayout2EXT` = `vkGetImageSubresourceLayout2`
pub type FN_vkGetImageSubresourceLayout2EXT = FN_vkGetImageSubresourceLayout2;

/// `vkGetImageSubresourceLayout2KHR` = `vkGetImageSubresourceLayout2`
pub type PFN_vkGetImageSubresourceLayout2KHR = PFN_vkGetImageSubresourceLayout2;

/// `vkGetImageSubresourceLayout2KHR` = `vkGetImageSubresourceLayout2`
pub type FN_vkGetImageSubresourceLayout2KHR = FN_vkGetImageSubresourceLayout2;

/// `vkGetImageViewAddressNVX`
pub type PFN_vkGetImageViewAddressNVX = Option<FN_vkGetImageViewAddressNVX>;

/// `vkGetImageViewAddressNVX`
pub type FN_vkGetImageViewAddressNVX = unsafe extern "system" fn(device: VkDevice, imageView: VkImageView, pProperties: *mut VkImageViewAddressPropertiesNVX) -> VkResult;


/// `vkGetImageViewHandle64NVX`
pub type PFN_vkGetImageViewHandle64NVX = Option<FN_vkGetImageViewHandle64NVX>;

/// `vkGetImageViewHandle64NVX`
pub type FN_vkGetImageViewHandle64NVX = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkImageViewHandleInfoNVX) -> uint64_t;


/// `vkGetImageViewHandleNVX`
pub type PFN_vkGetImageViewHandleNVX = Option<FN_vkGetImageViewHandleNVX>;

/// `vkGetImageViewHandleNVX`
pub type FN_vkGetImageViewHandleNVX = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkImageViewHandleInfoNVX) -> uint32_t;


/// `vkGetImageViewOpaqueCaptureDescriptorDataEXT`
pub type PFN_vkGetImageViewOpaqueCaptureDescriptorDataEXT = Option<FN_vkGetImageViewOpaqueCaptureDescriptorDataEXT>;

/// `vkGetImageViewOpaqueCaptureDescriptorDataEXT`
pub type FN_vkGetImageViewOpaqueCaptureDescriptorDataEXT = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkImageViewCaptureDescriptorDataInfoEXT, pData: *mut void) -> VkResult;


/// `vkGetInstanceProcAddr`
pub type PFN_vkGetInstanceProcAddr = Option<FN_vkGetInstanceProcAddr>;

/// `vkGetInstanceProcAddr`
pub type FN_vkGetInstanceProcAddr = unsafe extern "system" fn(instance: VkInstance, pName: *const c_char) -> PFN_vkVoidFunction;


/// `vkGetLatencyTimingsNV`
pub type PFN_vkGetLatencyTimingsNV = Option<FN_vkGetLatencyTimingsNV>;

/// `vkGetLatencyTimingsNV`
pub type FN_vkGetLatencyTimingsNV = unsafe extern "system" fn(device: VkDevice, swapchain: VkSwapchainKHR, pLatencyMarkerInfo: *mut VkGetLatencyMarkerInfoNV) -> ();


/// `vkGetMemoryAndroidHardwareBufferANDROID`
pub type PFN_vkGetMemoryAndroidHardwareBufferANDROID = Option<FN_vkGetMemoryAndroidHardwareBufferANDROID>;

/// `vkGetMemoryAndroidHardwareBufferANDROID`
pub type FN_vkGetMemoryAndroidHardwareBufferANDROID = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkMemoryGetAndroidHardwareBufferInfoANDROID, pBuffer: *mut *mut AHardwareBuffer) -> VkResult;


/// `vkGetMemoryFdKHR`
pub type PFN_vkGetMemoryFdKHR = Option<FN_vkGetMemoryFdKHR>;

/// `vkGetMemoryFdKHR`
pub type FN_vkGetMemoryFdKHR = unsafe extern "system" fn(device: VkDevice, pGetFdInfo: *const VkMemoryGetFdInfoKHR, pFd: *mut int) -> VkResult;


/// `vkGetMemoryFdPropertiesKHR`
pub type PFN_vkGetMemoryFdPropertiesKHR = Option<FN_vkGetMemoryFdPropertiesKHR>;

/// `vkGetMemoryFdPropertiesKHR`
pub type FN_vkGetMemoryFdPropertiesKHR = unsafe extern "system" fn(device: VkDevice, handleType: VkExternalMemoryHandleTypeFlags, fd: int, pMemoryFdProperties: *mut VkMemoryFdPropertiesKHR) -> VkResult;


/// `vkGetMemoryHostPointerPropertiesEXT`
pub type PFN_vkGetMemoryHostPointerPropertiesEXT = Option<FN_vkGetMemoryHostPointerPropertiesEXT>;

/// `vkGetMemoryHostPointerPropertiesEXT`
pub type FN_vkGetMemoryHostPointerPropertiesEXT = unsafe extern "system" fn(device: VkDevice, handleType: VkExternalMemoryHandleTypeFlags, pHostPointer: *const void, pMemoryHostPointerProperties: *mut VkMemoryHostPointerPropertiesEXT) -> VkResult;


/// `vkGetMemoryMetalHandleEXT`
pub type PFN_vkGetMemoryMetalHandleEXT = Option<FN_vkGetMemoryMetalHandleEXT>;

/// `vkGetMemoryMetalHandleEXT`
pub type FN_vkGetMemoryMetalHandleEXT = unsafe extern "system" fn(device: VkDevice, pGetMetalHandleInfo: *const VkMemoryGetMetalHandleInfoEXT, pHandle: *mut *mut void) -> VkResult;


/// `vkGetMemoryMetalHandlePropertiesEXT`
pub type PFN_vkGetMemoryMetalHandlePropertiesEXT = Option<FN_vkGetMemoryMetalHandlePropertiesEXT>;

/// `vkGetMemoryMetalHandlePropertiesEXT`
pub type FN_vkGetMemoryMetalHandlePropertiesEXT = unsafe extern "system" fn(device: VkDevice, handleType: VkExternalMemoryHandleTypeFlags, pHandle: *const void, pMemoryMetalHandleProperties: *mut VkMemoryMetalHandlePropertiesEXT) -> VkResult;


/// `vkGetMemoryNativeBufferOHOS`
pub type PFN_vkGetMemoryNativeBufferOHOS = Option<FN_vkGetMemoryNativeBufferOHOS>;

/// `vkGetMemoryNativeBufferOHOS`
pub type FN_vkGetMemoryNativeBufferOHOS = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkMemoryGetNativeBufferInfoOHOS, pBuffer: *mut *mut OH_NativeBuffer) -> VkResult;


/// `vkGetMemoryRemoteAddressNV`
pub type PFN_vkGetMemoryRemoteAddressNV = Option<FN_vkGetMemoryRemoteAddressNV>;

/// `vkGetMemoryRemoteAddressNV`
pub type FN_vkGetMemoryRemoteAddressNV = unsafe extern "system" fn(device: VkDevice, pMemoryGetRemoteAddressInfo: *const VkMemoryGetRemoteAddressInfoNV, pAddress: *mut VkRemoteAddressNV) -> VkResult;


/// `vkGetMemorySciBufNV`
pub type PFN_vkGetMemorySciBufNV = Option<FN_vkGetMemorySciBufNV>;

/// `vkGetMemorySciBufNV`
pub type FN_vkGetMemorySciBufNV = unsafe extern "system" fn(device: VkDevice, pGetSciBufInfo: *const VkMemoryGetSciBufInfoNV, pHandle: *mut NvSciBufObj) -> VkResult;


/// `vkGetMemoryWin32HandleKHR`
pub type PFN_vkGetMemoryWin32HandleKHR = Option<FN_vkGetMemoryWin32HandleKHR>;

/// `vkGetMemoryWin32HandleKHR`
pub type FN_vkGetMemoryWin32HandleKHR = unsafe extern "system" fn(device: VkDevice, pGetWin32HandleInfo: *const VkMemoryGetWin32HandleInfoKHR, pHandle: *mut HANDLE) -> VkResult;


/// `vkGetMemoryWin32HandleNV`
pub type PFN_vkGetMemoryWin32HandleNV = Option<FN_vkGetMemoryWin32HandleNV>;

/// `vkGetMemoryWin32HandleNV`
pub type FN_vkGetMemoryWin32HandleNV = unsafe extern "system" fn(device: VkDevice, memory: VkDeviceMemory, handleType: VkExternalMemoryHandleTypeFlagsNV, pHandle: *mut HANDLE) -> VkResult;


/// `vkGetMemoryWin32HandlePropertiesKHR`
pub type PFN_vkGetMemoryWin32HandlePropertiesKHR = Option<FN_vkGetMemoryWin32HandlePropertiesKHR>;

/// `vkGetMemoryWin32HandlePropertiesKHR`
pub type FN_vkGetMemoryWin32HandlePropertiesKHR = unsafe extern "system" fn(device: VkDevice, handleType: VkExternalMemoryHandleTypeFlags, handle: HANDLE, pMemoryWin32HandleProperties: *mut VkMemoryWin32HandlePropertiesKHR) -> VkResult;


/// `vkGetMemoryZirconHandleFUCHSIA`
pub type PFN_vkGetMemoryZirconHandleFUCHSIA = Option<FN_vkGetMemoryZirconHandleFUCHSIA>;

/// `vkGetMemoryZirconHandleFUCHSIA`
pub type FN_vkGetMemoryZirconHandleFUCHSIA = unsafe extern "system" fn(device: VkDevice, pGetZirconHandleInfo: *const VkMemoryGetZirconHandleInfoFUCHSIA, pZirconHandle: *mut zx_handle_t) -> VkResult;


/// `vkGetMemoryZirconHandlePropertiesFUCHSIA`
pub type PFN_vkGetMemoryZirconHandlePropertiesFUCHSIA = Option<FN_vkGetMemoryZirconHandlePropertiesFUCHSIA>;

/// `vkGetMemoryZirconHandlePropertiesFUCHSIA`
pub type FN_vkGetMemoryZirconHandlePropertiesFUCHSIA = unsafe extern "system" fn(device: VkDevice, handleType: VkExternalMemoryHandleTypeFlags, zirconHandle: zx_handle_t, pMemoryZirconHandleProperties: *mut VkMemoryZirconHandlePropertiesFUCHSIA) -> VkResult;


/// `vkGetMicromapBuildSizesEXT`
pub type PFN_vkGetMicromapBuildSizesEXT = Option<FN_vkGetMicromapBuildSizesEXT>;

/// `vkGetMicromapBuildSizesEXT`
pub type FN_vkGetMicromapBuildSizesEXT = unsafe extern "system" fn(device: VkDevice, buildType: VkAccelerationStructureBuildTypeKHR, pBuildInfo: *const VkMicromapBuildInfoEXT, pSizeInfo: *mut VkMicromapBuildSizesInfoEXT) -> ();


/// `vkGetNativeBufferPropertiesOHOS`
pub type PFN_vkGetNativeBufferPropertiesOHOS = Option<FN_vkGetNativeBufferPropertiesOHOS>;

/// `vkGetNativeBufferPropertiesOHOS`
pub type FN_vkGetNativeBufferPropertiesOHOS = unsafe extern "system" fn(device: VkDevice, buffer: *const OH_NativeBuffer, pProperties: *mut VkNativeBufferPropertiesOHOS) -> VkResult;


/// `vkGetPartitionedAccelerationStructuresBuildSizesNV`
pub type PFN_vkGetPartitionedAccelerationStructuresBuildSizesNV = Option<FN_vkGetPartitionedAccelerationStructuresBuildSizesNV>;

/// `vkGetPartitionedAccelerationStructuresBuildSizesNV`
pub type FN_vkGetPartitionedAccelerationStructuresBuildSizesNV = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkPartitionedAccelerationStructureInstancesInputNV, pSizeInfo: *mut VkAccelerationStructureBuildSizesInfoKHR) -> ();


/// `vkGetPastPresentationTimingEXT`
pub type PFN_vkGetPastPresentationTimingEXT = Option<FN_vkGetPastPresentationTimingEXT>;

/// `vkGetPastPresentationTimingEXT`
pub type FN_vkGetPastPresentationTimingEXT = unsafe extern "system" fn(device: VkDevice, pPastPresentationTimingInfo: *const VkPastPresentationTimingInfoEXT, pPastPresentationTimingProperties: *mut VkPastPresentationTimingPropertiesEXT) -> VkResult;


/// `vkGetPastPresentationTimingGOOGLE`
pub type PFN_vkGetPastPresentationTimingGOOGLE = Option<FN_vkGetPastPresentationTimingGOOGLE>;

/// `vkGetPastPresentationTimingGOOGLE`
pub type FN_vkGetPastPresentationTimingGOOGLE = unsafe extern "system" fn(device: VkDevice, swapchain: VkSwapchainKHR, pPresentationTimingCount: *mut uint32_t, pPresentationTimings: *mut VkPastPresentationTimingGOOGLE) -> VkResult;


/// `vkGetPerformanceParameterINTEL`
pub type PFN_vkGetPerformanceParameterINTEL = Option<FN_vkGetPerformanceParameterINTEL>;

/// `vkGetPerformanceParameterINTEL`
pub type FN_vkGetPerformanceParameterINTEL = unsafe extern "system" fn(device: VkDevice, parameter: VkPerformanceParameterTypeINTEL, pValue: *mut VkPerformanceValueINTEL) -> VkResult;


/// `vkGetPhysicalDeviceCalibrateableTimeDomainsEXT` = `vkGetPhysicalDeviceCalibrateableTimeDomainsKHR`
pub type PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT = PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR;

/// `vkGetPhysicalDeviceCalibrateableTimeDomainsEXT` = `vkGetPhysicalDeviceCalibrateableTimeDomainsKHR`
pub type FN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT = FN_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR;

/// `vkGetPhysicalDeviceCalibrateableTimeDomainsKHR`
pub type PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR = Option<FN_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR>;

/// `vkGetPhysicalDeviceCalibrateableTimeDomainsKHR`
pub type FN_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pTimeDomainCount: *mut uint32_t, pTimeDomains: *mut VkTimeDomainKHR) -> VkResult;


/// `vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV`
pub type PFN_vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV = Option<FN_vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV>;

/// `vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV`
pub type FN_vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pPropertyCount: *mut uint32_t, pProperties: *mut VkCooperativeMatrixFlexibleDimensionsPropertiesNV) -> VkResult;


/// `vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR`
pub type PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR = Option<FN_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR>;

/// `vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR`
pub type FN_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pPropertyCount: *mut uint32_t, pProperties: *mut VkCooperativeMatrixPropertiesKHR) -> VkResult;


/// `vkGetPhysicalDeviceCooperativeMatrixPropertiesNV`
pub type PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV = Option<FN_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV>;

/// `vkGetPhysicalDeviceCooperativeMatrixPropertiesNV`
pub type FN_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pPropertyCount: *mut uint32_t, pProperties: *mut VkCooperativeMatrixPropertiesNV) -> VkResult;


/// `vkGetPhysicalDeviceCooperativeVectorPropertiesNV`
pub type PFN_vkGetPhysicalDeviceCooperativeVectorPropertiesNV = Option<FN_vkGetPhysicalDeviceCooperativeVectorPropertiesNV>;

/// `vkGetPhysicalDeviceCooperativeVectorPropertiesNV`
pub type FN_vkGetPhysicalDeviceCooperativeVectorPropertiesNV = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pPropertyCount: *mut uint32_t, pProperties: *mut VkCooperativeVectorPropertiesNV) -> VkResult;


/// `vkGetPhysicalDeviceDescriptorSizeEXT`
pub type PFN_vkGetPhysicalDeviceDescriptorSizeEXT = Option<FN_vkGetPhysicalDeviceDescriptorSizeEXT>;

/// `vkGetPhysicalDeviceDescriptorSizeEXT`
pub type FN_vkGetPhysicalDeviceDescriptorSizeEXT = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, descriptorType: VkDescriptorType) -> VkDeviceSize;


/// `vkGetPhysicalDeviceDirectFBPresentationSupportEXT`
pub type PFN_vkGetPhysicalDeviceDirectFBPresentationSupportEXT = Option<FN_vkGetPhysicalDeviceDirectFBPresentationSupportEXT>;

/// `vkGetPhysicalDeviceDirectFBPresentationSupportEXT`
pub type FN_vkGetPhysicalDeviceDirectFBPresentationSupportEXT = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, queueFamilyIndex: uint32_t, dfb: *mut IDirectFB) -> VkBool32;


/// `vkGetPhysicalDeviceDisplayPlaneProperties2KHR`
pub type PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR = Option<FN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR>;

/// `vkGetPhysicalDeviceDisplayPlaneProperties2KHR`
pub type FN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pPropertyCount: *mut uint32_t, pProperties: *mut VkDisplayPlaneProperties2KHR) -> VkResult;


/// `vkGetPhysicalDeviceDisplayPlanePropertiesKHR`
pub type PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR = Option<FN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR>;

/// `vkGetPhysicalDeviceDisplayPlanePropertiesKHR`
pub type FN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pPropertyCount: *mut uint32_t, pProperties: *mut VkDisplayPlanePropertiesKHR) -> VkResult;


/// `vkGetPhysicalDeviceDisplayProperties2KHR`
pub type PFN_vkGetPhysicalDeviceDisplayProperties2KHR = Option<FN_vkGetPhysicalDeviceDisplayProperties2KHR>;

/// `vkGetPhysicalDeviceDisplayProperties2KHR`
pub type FN_vkGetPhysicalDeviceDisplayProperties2KHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pPropertyCount: *mut uint32_t, pProperties: *mut VkDisplayProperties2KHR) -> VkResult;


/// `vkGetPhysicalDeviceDisplayPropertiesKHR`
pub type PFN_vkGetPhysicalDeviceDisplayPropertiesKHR = Option<FN_vkGetPhysicalDeviceDisplayPropertiesKHR>;

/// `vkGetPhysicalDeviceDisplayPropertiesKHR`
pub type FN_vkGetPhysicalDeviceDisplayPropertiesKHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pPropertyCount: *mut uint32_t, pProperties: *mut VkDisplayPropertiesKHR) -> VkResult;


/// `vkGetPhysicalDeviceExternalBufferProperties`
pub type PFN_vkGetPhysicalDeviceExternalBufferProperties = Option<FN_vkGetPhysicalDeviceExternalBufferProperties>;

/// `vkGetPhysicalDeviceExternalBufferProperties`
pub type FN_vkGetPhysicalDeviceExternalBufferProperties = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pExternalBufferInfo: *const VkPhysicalDeviceExternalBufferInfo, pExternalBufferProperties: *mut VkExternalBufferProperties) -> ();


/// `vkGetPhysicalDeviceExternalBufferPropertiesKHR` = `vkGetPhysicalDeviceExternalBufferProperties`
pub type PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR = PFN_vkGetPhysicalDeviceExternalBufferProperties;

/// `vkGetPhysicalDeviceExternalBufferPropertiesKHR` = `vkGetPhysicalDeviceExternalBufferProperties`
pub type FN_vkGetPhysicalDeviceExternalBufferPropertiesKHR = FN_vkGetPhysicalDeviceExternalBufferProperties;

/// `vkGetPhysicalDeviceExternalFenceProperties`
pub type PFN_vkGetPhysicalDeviceExternalFenceProperties = Option<FN_vkGetPhysicalDeviceExternalFenceProperties>;

/// `vkGetPhysicalDeviceExternalFenceProperties`
pub type FN_vkGetPhysicalDeviceExternalFenceProperties = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pExternalFenceInfo: *const VkPhysicalDeviceExternalFenceInfo, pExternalFenceProperties: *mut VkExternalFenceProperties) -> ();


/// `vkGetPhysicalDeviceExternalFencePropertiesKHR` = `vkGetPhysicalDeviceExternalFenceProperties`
pub type PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR = PFN_vkGetPhysicalDeviceExternalFenceProperties;

/// `vkGetPhysicalDeviceExternalFencePropertiesKHR` = `vkGetPhysicalDeviceExternalFenceProperties`
pub type FN_vkGetPhysicalDeviceExternalFencePropertiesKHR = FN_vkGetPhysicalDeviceExternalFenceProperties;

/// `vkGetPhysicalDeviceExternalImageFormatPropertiesNV`
pub type PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV = Option<FN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV>;

/// `vkGetPhysicalDeviceExternalImageFormatPropertiesNV`
pub type FN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, format: VkFormat, r#type: VkImageType, tiling: VkImageTiling, usage: VkImageUsageFlags, flags: VkImageCreateFlags, externalHandleType: VkExternalMemoryHandleTypeFlagsNV, pExternalImageFormatProperties: *mut VkExternalImageFormatPropertiesNV) -> VkResult;


/// `vkGetPhysicalDeviceExternalMemorySciBufPropertiesNV`
pub type PFN_vkGetPhysicalDeviceExternalMemorySciBufPropertiesNV = Option<FN_vkGetPhysicalDeviceExternalMemorySciBufPropertiesNV>;

/// `vkGetPhysicalDeviceExternalMemorySciBufPropertiesNV`
pub type FN_vkGetPhysicalDeviceExternalMemorySciBufPropertiesNV = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, handleType: VkExternalMemoryHandleTypeFlags, handle: NvSciBufObj, pMemorySciBufProperties: *mut VkMemorySciBufPropertiesNV) -> VkResult;


/// `vkGetPhysicalDeviceExternalSemaphoreProperties`
pub type PFN_vkGetPhysicalDeviceExternalSemaphoreProperties = Option<FN_vkGetPhysicalDeviceExternalSemaphoreProperties>;

/// `vkGetPhysicalDeviceExternalSemaphoreProperties`
pub type FN_vkGetPhysicalDeviceExternalSemaphoreProperties = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pExternalSemaphoreInfo: *const VkPhysicalDeviceExternalSemaphoreInfo, pExternalSemaphoreProperties: *mut VkExternalSemaphoreProperties) -> ();


/// `vkGetPhysicalDeviceExternalSemaphorePropertiesKHR` = `vkGetPhysicalDeviceExternalSemaphoreProperties`
pub type PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR = PFN_vkGetPhysicalDeviceExternalSemaphoreProperties;

/// `vkGetPhysicalDeviceExternalSemaphorePropertiesKHR` = `vkGetPhysicalDeviceExternalSemaphoreProperties`
pub type FN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR = FN_vkGetPhysicalDeviceExternalSemaphoreProperties;

/// `vkGetPhysicalDeviceExternalTensorPropertiesARM`
pub type PFN_vkGetPhysicalDeviceExternalTensorPropertiesARM = Option<FN_vkGetPhysicalDeviceExternalTensorPropertiesARM>;

/// `vkGetPhysicalDeviceExternalTensorPropertiesARM`
pub type FN_vkGetPhysicalDeviceExternalTensorPropertiesARM = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pExternalTensorInfo: *const VkPhysicalDeviceExternalTensorInfoARM, pExternalTensorProperties: *mut VkExternalTensorPropertiesARM) -> ();


/// `vkGetPhysicalDeviceFeatures`
pub type PFN_vkGetPhysicalDeviceFeatures = Option<FN_vkGetPhysicalDeviceFeatures>;

/// `vkGetPhysicalDeviceFeatures`
pub type FN_vkGetPhysicalDeviceFeatures = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pFeatures: *mut VkPhysicalDeviceFeatures) -> ();


/// `vkGetPhysicalDeviceFeatures2`
pub type PFN_vkGetPhysicalDeviceFeatures2 = Option<FN_vkGetPhysicalDeviceFeatures2>;

/// `vkGetPhysicalDeviceFeatures2`
pub type FN_vkGetPhysicalDeviceFeatures2 = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pFeatures: *mut VkPhysicalDeviceFeatures2) -> ();


/// `vkGetPhysicalDeviceFeatures2KHR` = `vkGetPhysicalDeviceFeatures2`
pub type PFN_vkGetPhysicalDeviceFeatures2KHR = PFN_vkGetPhysicalDeviceFeatures2;

/// `vkGetPhysicalDeviceFeatures2KHR` = `vkGetPhysicalDeviceFeatures2`
pub type FN_vkGetPhysicalDeviceFeatures2KHR = FN_vkGetPhysicalDeviceFeatures2;

/// `vkGetPhysicalDeviceFormatProperties`
pub type PFN_vkGetPhysicalDeviceFormatProperties = Option<FN_vkGetPhysicalDeviceFormatProperties>;

/// `vkGetPhysicalDeviceFormatProperties`
pub type FN_vkGetPhysicalDeviceFormatProperties = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, format: VkFormat, pFormatProperties: *mut VkFormatProperties) -> ();


/// `vkGetPhysicalDeviceFormatProperties2`
pub type PFN_vkGetPhysicalDeviceFormatProperties2 = Option<FN_vkGetPhysicalDeviceFormatProperties2>;

/// `vkGetPhysicalDeviceFormatProperties2`
pub type FN_vkGetPhysicalDeviceFormatProperties2 = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, format: VkFormat, pFormatProperties: *mut VkFormatProperties2) -> ();


/// `vkGetPhysicalDeviceFormatProperties2KHR` = `vkGetPhysicalDeviceFormatProperties2`
pub type PFN_vkGetPhysicalDeviceFormatProperties2KHR = PFN_vkGetPhysicalDeviceFormatProperties2;

/// `vkGetPhysicalDeviceFormatProperties2KHR` = `vkGetPhysicalDeviceFormatProperties2`
pub type FN_vkGetPhysicalDeviceFormatProperties2KHR = FN_vkGetPhysicalDeviceFormatProperties2;

/// `vkGetPhysicalDeviceFragmentShadingRatesKHR`
pub type PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR = Option<FN_vkGetPhysicalDeviceFragmentShadingRatesKHR>;

/// `vkGetPhysicalDeviceFragmentShadingRatesKHR`
pub type FN_vkGetPhysicalDeviceFragmentShadingRatesKHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pFragmentShadingRateCount: *mut uint32_t, pFragmentShadingRates: *mut VkPhysicalDeviceFragmentShadingRateKHR) -> VkResult;


/// `vkGetPhysicalDeviceImageFormatProperties`
pub type PFN_vkGetPhysicalDeviceImageFormatProperties = Option<FN_vkGetPhysicalDeviceImageFormatProperties>;

/// `vkGetPhysicalDeviceImageFormatProperties`
pub type FN_vkGetPhysicalDeviceImageFormatProperties = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, format: VkFormat, r#type: VkImageType, tiling: VkImageTiling, usage: VkImageUsageFlags, flags: VkImageCreateFlags, pImageFormatProperties: *mut VkImageFormatProperties) -> VkResult;


/// `vkGetPhysicalDeviceImageFormatProperties2`
pub type PFN_vkGetPhysicalDeviceImageFormatProperties2 = Option<FN_vkGetPhysicalDeviceImageFormatProperties2>;

/// `vkGetPhysicalDeviceImageFormatProperties2`
pub type FN_vkGetPhysicalDeviceImageFormatProperties2 = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pImageFormatInfo: *const VkPhysicalDeviceImageFormatInfo2, pImageFormatProperties: *mut VkImageFormatProperties2) -> VkResult;


/// `vkGetPhysicalDeviceImageFormatProperties2KHR` = `vkGetPhysicalDeviceImageFormatProperties2`
pub type PFN_vkGetPhysicalDeviceImageFormatProperties2KHR = PFN_vkGetPhysicalDeviceImageFormatProperties2;

/// `vkGetPhysicalDeviceImageFormatProperties2KHR` = `vkGetPhysicalDeviceImageFormatProperties2`
pub type FN_vkGetPhysicalDeviceImageFormatProperties2KHR = FN_vkGetPhysicalDeviceImageFormatProperties2;

/// `vkGetPhysicalDeviceMemoryProperties`
pub type PFN_vkGetPhysicalDeviceMemoryProperties = Option<FN_vkGetPhysicalDeviceMemoryProperties>;

/// `vkGetPhysicalDeviceMemoryProperties`
pub type FN_vkGetPhysicalDeviceMemoryProperties = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pMemoryProperties: *mut VkPhysicalDeviceMemoryProperties) -> ();


/// `vkGetPhysicalDeviceMemoryProperties2`
pub type PFN_vkGetPhysicalDeviceMemoryProperties2 = Option<FN_vkGetPhysicalDeviceMemoryProperties2>;

/// `vkGetPhysicalDeviceMemoryProperties2`
pub type FN_vkGetPhysicalDeviceMemoryProperties2 = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pMemoryProperties: *mut VkPhysicalDeviceMemoryProperties2) -> ();


/// `vkGetPhysicalDeviceMemoryProperties2KHR` = `vkGetPhysicalDeviceMemoryProperties2`
pub type PFN_vkGetPhysicalDeviceMemoryProperties2KHR = PFN_vkGetPhysicalDeviceMemoryProperties2;

/// `vkGetPhysicalDeviceMemoryProperties2KHR` = `vkGetPhysicalDeviceMemoryProperties2`
pub type FN_vkGetPhysicalDeviceMemoryProperties2KHR = FN_vkGetPhysicalDeviceMemoryProperties2;

/// `vkGetPhysicalDeviceMultisamplePropertiesEXT`
pub type PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT = Option<FN_vkGetPhysicalDeviceMultisamplePropertiesEXT>;

/// `vkGetPhysicalDeviceMultisamplePropertiesEXT`
pub type FN_vkGetPhysicalDeviceMultisamplePropertiesEXT = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, samples: VkSampleCountFlags, pMultisampleProperties: *mut VkMultisamplePropertiesEXT) -> ();


/// `vkGetPhysicalDeviceOpticalFlowImageFormatsNV`
pub type PFN_vkGetPhysicalDeviceOpticalFlowImageFormatsNV = Option<FN_vkGetPhysicalDeviceOpticalFlowImageFormatsNV>;

/// `vkGetPhysicalDeviceOpticalFlowImageFormatsNV`
pub type FN_vkGetPhysicalDeviceOpticalFlowImageFormatsNV = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pOpticalFlowImageFormatInfo: *const VkOpticalFlowImageFormatInfoNV, pFormatCount: *mut uint32_t, pImageFormatProperties: *mut VkOpticalFlowImageFormatPropertiesNV) -> VkResult;


/// `vkGetPhysicalDevicePresentRectanglesKHR`
pub type PFN_vkGetPhysicalDevicePresentRectanglesKHR = Option<FN_vkGetPhysicalDevicePresentRectanglesKHR>;

/// `vkGetPhysicalDevicePresentRectanglesKHR`
pub type FN_vkGetPhysicalDevicePresentRectanglesKHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, surface: VkSurfaceKHR, pRectCount: *mut uint32_t, pRects: *mut VkRect2D) -> VkResult;


/// `vkGetPhysicalDeviceProperties`
pub type PFN_vkGetPhysicalDeviceProperties = Option<FN_vkGetPhysicalDeviceProperties>;

/// `vkGetPhysicalDeviceProperties`
pub type FN_vkGetPhysicalDeviceProperties = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pProperties: *mut VkPhysicalDeviceProperties) -> ();


/// `vkGetPhysicalDeviceProperties2`
pub type PFN_vkGetPhysicalDeviceProperties2 = Option<FN_vkGetPhysicalDeviceProperties2>;

/// `vkGetPhysicalDeviceProperties2`
pub type FN_vkGetPhysicalDeviceProperties2 = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pProperties: *mut VkPhysicalDeviceProperties2) -> ();


/// `vkGetPhysicalDeviceProperties2KHR` = `vkGetPhysicalDeviceProperties2`
pub type PFN_vkGetPhysicalDeviceProperties2KHR = PFN_vkGetPhysicalDeviceProperties2;

/// `vkGetPhysicalDeviceProperties2KHR` = `vkGetPhysicalDeviceProperties2`
pub type FN_vkGetPhysicalDeviceProperties2KHR = FN_vkGetPhysicalDeviceProperties2;

/// `vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM`
pub type PFN_vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM = Option<FN_vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM>;

/// `vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM`
pub type FN_vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pQueueFamilyDataGraphProcessingEngineInfo: *const VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM, pQueueFamilyDataGraphProcessingEngineProperties: *mut VkQueueFamilyDataGraphProcessingEnginePropertiesARM) -> ();


/// `vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM`
pub type PFN_vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM = Option<FN_vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM>;

/// `vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM`
pub type FN_vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, queueFamilyIndex: uint32_t, pQueueFamilyDataGraphPropertyCount: *mut uint32_t, pQueueFamilyDataGraphProperties: *mut VkQueueFamilyDataGraphPropertiesARM) -> VkResult;


/// `vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR`
pub type PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR = Option<FN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR>;

/// `vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR`
pub type FN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pPerformanceQueryCreateInfo: *const VkQueryPoolPerformanceCreateInfoKHR, pNumPasses: *mut uint32_t) -> ();


/// `vkGetPhysicalDeviceQueueFamilyProperties`
pub type PFN_vkGetPhysicalDeviceQueueFamilyProperties = Option<FN_vkGetPhysicalDeviceQueueFamilyProperties>;

/// `vkGetPhysicalDeviceQueueFamilyProperties`
pub type FN_vkGetPhysicalDeviceQueueFamilyProperties = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pQueueFamilyPropertyCount: *mut uint32_t, pQueueFamilyProperties: *mut VkQueueFamilyProperties) -> ();


/// `vkGetPhysicalDeviceQueueFamilyProperties2`
pub type PFN_vkGetPhysicalDeviceQueueFamilyProperties2 = Option<FN_vkGetPhysicalDeviceQueueFamilyProperties2>;

/// `vkGetPhysicalDeviceQueueFamilyProperties2`
pub type FN_vkGetPhysicalDeviceQueueFamilyProperties2 = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pQueueFamilyPropertyCount: *mut uint32_t, pQueueFamilyProperties: *mut VkQueueFamilyProperties2) -> ();


/// `vkGetPhysicalDeviceQueueFamilyProperties2KHR` = `vkGetPhysicalDeviceQueueFamilyProperties2`
pub type PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR = PFN_vkGetPhysicalDeviceQueueFamilyProperties2;

/// `vkGetPhysicalDeviceQueueFamilyProperties2KHR` = `vkGetPhysicalDeviceQueueFamilyProperties2`
pub type FN_vkGetPhysicalDeviceQueueFamilyProperties2KHR = FN_vkGetPhysicalDeviceQueueFamilyProperties2;

/// `vkGetPhysicalDeviceRefreshableObjectTypesKHR`
pub type PFN_vkGetPhysicalDeviceRefreshableObjectTypesKHR = Option<FN_vkGetPhysicalDeviceRefreshableObjectTypesKHR>;

/// `vkGetPhysicalDeviceRefreshableObjectTypesKHR`
pub type FN_vkGetPhysicalDeviceRefreshableObjectTypesKHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pRefreshableObjectTypeCount: *mut uint32_t, pRefreshableObjectTypes: *mut VkObjectType) -> VkResult;


/// `vkGetPhysicalDeviceSciBufAttributesNV`
pub type PFN_vkGetPhysicalDeviceSciBufAttributesNV = Option<FN_vkGetPhysicalDeviceSciBufAttributesNV>;

/// `vkGetPhysicalDeviceSciBufAttributesNV`
pub type FN_vkGetPhysicalDeviceSciBufAttributesNV = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pAttributes: NvSciBufAttrList) -> VkResult;


/// `vkGetPhysicalDeviceSciSyncAttributesNV`
pub type PFN_vkGetPhysicalDeviceSciSyncAttributesNV = Option<FN_vkGetPhysicalDeviceSciSyncAttributesNV>;

/// `vkGetPhysicalDeviceSciSyncAttributesNV`
pub type FN_vkGetPhysicalDeviceSciSyncAttributesNV = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pSciSyncAttributesInfo: *const VkSciSyncAttributesInfoNV, pAttributes: NvSciSyncAttrList) -> VkResult;


/// `vkGetPhysicalDeviceScreenPresentationSupportQNX`
pub type PFN_vkGetPhysicalDeviceScreenPresentationSupportQNX = Option<FN_vkGetPhysicalDeviceScreenPresentationSupportQNX>;

/// `vkGetPhysicalDeviceScreenPresentationSupportQNX`
pub type FN_vkGetPhysicalDeviceScreenPresentationSupportQNX = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, queueFamilyIndex: uint32_t, window: *mut _screen_window) -> VkBool32;


/// `vkGetPhysicalDeviceSparseImageFormatProperties`
pub type PFN_vkGetPhysicalDeviceSparseImageFormatProperties = Option<FN_vkGetPhysicalDeviceSparseImageFormatProperties>;

/// `vkGetPhysicalDeviceSparseImageFormatProperties`
pub type FN_vkGetPhysicalDeviceSparseImageFormatProperties = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, format: VkFormat, r#type: VkImageType, samples: VkSampleCountFlags, usage: VkImageUsageFlags, tiling: VkImageTiling, pPropertyCount: *mut uint32_t, pProperties: *mut VkSparseImageFormatProperties) -> ();


/// `vkGetPhysicalDeviceSparseImageFormatProperties2`
pub type PFN_vkGetPhysicalDeviceSparseImageFormatProperties2 = Option<FN_vkGetPhysicalDeviceSparseImageFormatProperties2>;

/// `vkGetPhysicalDeviceSparseImageFormatProperties2`
pub type FN_vkGetPhysicalDeviceSparseImageFormatProperties2 = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pFormatInfo: *const VkPhysicalDeviceSparseImageFormatInfo2, pPropertyCount: *mut uint32_t, pProperties: *mut VkSparseImageFormatProperties2) -> ();


/// `vkGetPhysicalDeviceSparseImageFormatProperties2KHR` = `vkGetPhysicalDeviceSparseImageFormatProperties2`
pub type PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR = PFN_vkGetPhysicalDeviceSparseImageFormatProperties2;

/// `vkGetPhysicalDeviceSparseImageFormatProperties2KHR` = `vkGetPhysicalDeviceSparseImageFormatProperties2`
pub type FN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR = FN_vkGetPhysicalDeviceSparseImageFormatProperties2;

/// `vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV`
pub type PFN_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV = Option<FN_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV>;

/// `vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV`
pub type FN_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pCombinationCount: *mut uint32_t, pCombinations: *mut VkFramebufferMixedSamplesCombinationNV) -> VkResult;


/// `vkGetPhysicalDeviceSurfaceCapabilities2EXT`
pub type PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT = Option<FN_vkGetPhysicalDeviceSurfaceCapabilities2EXT>;

/// `vkGetPhysicalDeviceSurfaceCapabilities2EXT`
pub type FN_vkGetPhysicalDeviceSurfaceCapabilities2EXT = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, surface: VkSurfaceKHR, pSurfaceCapabilities: *mut VkSurfaceCapabilities2EXT) -> VkResult;


/// `vkGetPhysicalDeviceSurfaceCapabilities2KHR`
pub type PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR = Option<FN_vkGetPhysicalDeviceSurfaceCapabilities2KHR>;

/// `vkGetPhysicalDeviceSurfaceCapabilities2KHR`
pub type FN_vkGetPhysicalDeviceSurfaceCapabilities2KHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pSurfaceInfo: *const VkPhysicalDeviceSurfaceInfo2KHR, pSurfaceCapabilities: *mut VkSurfaceCapabilities2KHR) -> VkResult;


/// `vkGetPhysicalDeviceSurfaceCapabilitiesKHR`
pub type PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR = Option<FN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR>;

/// `vkGetPhysicalDeviceSurfaceCapabilitiesKHR`
pub type FN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, surface: VkSurfaceKHR, pSurfaceCapabilities: *mut VkSurfaceCapabilitiesKHR) -> VkResult;


/// `vkGetPhysicalDeviceSurfaceFormats2KHR`
pub type PFN_vkGetPhysicalDeviceSurfaceFormats2KHR = Option<FN_vkGetPhysicalDeviceSurfaceFormats2KHR>;

/// `vkGetPhysicalDeviceSurfaceFormats2KHR`
pub type FN_vkGetPhysicalDeviceSurfaceFormats2KHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pSurfaceInfo: *const VkPhysicalDeviceSurfaceInfo2KHR, pSurfaceFormatCount: *mut uint32_t, pSurfaceFormats: *mut VkSurfaceFormat2KHR) -> VkResult;


/// `vkGetPhysicalDeviceSurfaceFormatsKHR`
pub type PFN_vkGetPhysicalDeviceSurfaceFormatsKHR = Option<FN_vkGetPhysicalDeviceSurfaceFormatsKHR>;

/// `vkGetPhysicalDeviceSurfaceFormatsKHR`
pub type FN_vkGetPhysicalDeviceSurfaceFormatsKHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, surface: VkSurfaceKHR, pSurfaceFormatCount: *mut uint32_t, pSurfaceFormats: *mut VkSurfaceFormatKHR) -> VkResult;


/// `vkGetPhysicalDeviceSurfacePresentModes2EXT`
pub type PFN_vkGetPhysicalDeviceSurfacePresentModes2EXT = Option<FN_vkGetPhysicalDeviceSurfacePresentModes2EXT>;

/// `vkGetPhysicalDeviceSurfacePresentModes2EXT`
pub type FN_vkGetPhysicalDeviceSurfacePresentModes2EXT = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pSurfaceInfo: *const VkPhysicalDeviceSurfaceInfo2KHR, pPresentModeCount: *mut uint32_t, pPresentModes: *mut VkPresentModeKHR) -> VkResult;


/// `vkGetPhysicalDeviceSurfacePresentModesKHR`
pub type PFN_vkGetPhysicalDeviceSurfacePresentModesKHR = Option<FN_vkGetPhysicalDeviceSurfacePresentModesKHR>;

/// `vkGetPhysicalDeviceSurfacePresentModesKHR`
pub type FN_vkGetPhysicalDeviceSurfacePresentModesKHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, surface: VkSurfaceKHR, pPresentModeCount: *mut uint32_t, pPresentModes: *mut VkPresentModeKHR) -> VkResult;


/// `vkGetPhysicalDeviceSurfaceSupportKHR`
pub type PFN_vkGetPhysicalDeviceSurfaceSupportKHR = Option<FN_vkGetPhysicalDeviceSurfaceSupportKHR>;

/// `vkGetPhysicalDeviceSurfaceSupportKHR`
pub type FN_vkGetPhysicalDeviceSurfaceSupportKHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, queueFamilyIndex: uint32_t, surface: VkSurfaceKHR, pSupported: *mut VkBool32) -> VkResult;


/// `vkGetPhysicalDeviceToolProperties`
pub type PFN_vkGetPhysicalDeviceToolProperties = Option<FN_vkGetPhysicalDeviceToolProperties>;

/// `vkGetPhysicalDeviceToolProperties`
pub type FN_vkGetPhysicalDeviceToolProperties = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pToolCount: *mut uint32_t, pToolProperties: *mut VkPhysicalDeviceToolProperties) -> VkResult;


/// `vkGetPhysicalDeviceToolPropertiesEXT` = `vkGetPhysicalDeviceToolProperties`
pub type PFN_vkGetPhysicalDeviceToolPropertiesEXT = PFN_vkGetPhysicalDeviceToolProperties;

/// `vkGetPhysicalDeviceToolPropertiesEXT` = `vkGetPhysicalDeviceToolProperties`
pub type FN_vkGetPhysicalDeviceToolPropertiesEXT = FN_vkGetPhysicalDeviceToolProperties;

/// `vkGetPhysicalDeviceUbmPresentationSupportSEC`
pub type PFN_vkGetPhysicalDeviceUbmPresentationSupportSEC = Option<FN_vkGetPhysicalDeviceUbmPresentationSupportSEC>;

/// `vkGetPhysicalDeviceUbmPresentationSupportSEC`
pub type FN_vkGetPhysicalDeviceUbmPresentationSupportSEC = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, queueFamilyIndex: uint32_t, device: *mut ubm_device) -> VkBool32;


/// `vkGetPhysicalDeviceVideoCapabilitiesKHR`
pub type PFN_vkGetPhysicalDeviceVideoCapabilitiesKHR = Option<FN_vkGetPhysicalDeviceVideoCapabilitiesKHR>;

/// `vkGetPhysicalDeviceVideoCapabilitiesKHR`
pub type FN_vkGetPhysicalDeviceVideoCapabilitiesKHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pVideoProfile: *const VkVideoProfileInfoKHR, pCapabilities: *mut VkVideoCapabilitiesKHR) -> VkResult;


/// `vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR`
pub type PFN_vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR = Option<FN_vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR>;

/// `vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR`
pub type FN_vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pQualityLevelInfo: *const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR, pQualityLevelProperties: *mut VkVideoEncodeQualityLevelPropertiesKHR) -> VkResult;


/// `vkGetPhysicalDeviceVideoFormatPropertiesKHR`
pub type PFN_vkGetPhysicalDeviceVideoFormatPropertiesKHR = Option<FN_vkGetPhysicalDeviceVideoFormatPropertiesKHR>;

/// `vkGetPhysicalDeviceVideoFormatPropertiesKHR`
pub type FN_vkGetPhysicalDeviceVideoFormatPropertiesKHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pVideoFormatInfo: *const VkPhysicalDeviceVideoFormatInfoKHR, pVideoFormatPropertyCount: *mut uint32_t, pVideoFormatProperties: *mut VkVideoFormatPropertiesKHR) -> VkResult;


/// `vkGetPhysicalDeviceWaylandPresentationSupportKHR`
pub type PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR = Option<FN_vkGetPhysicalDeviceWaylandPresentationSupportKHR>;

/// `vkGetPhysicalDeviceWaylandPresentationSupportKHR`
pub type FN_vkGetPhysicalDeviceWaylandPresentationSupportKHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, queueFamilyIndex: uint32_t, display: *mut wl_display) -> VkBool32;


/// `vkGetPhysicalDeviceWin32PresentationSupportKHR`
pub type PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR = Option<FN_vkGetPhysicalDeviceWin32PresentationSupportKHR>;

/// `vkGetPhysicalDeviceWin32PresentationSupportKHR`
pub type FN_vkGetPhysicalDeviceWin32PresentationSupportKHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, queueFamilyIndex: uint32_t) -> VkBool32;


/// `vkGetPhysicalDeviceXcbPresentationSupportKHR`
pub type PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR = Option<FN_vkGetPhysicalDeviceXcbPresentationSupportKHR>;

/// `vkGetPhysicalDeviceXcbPresentationSupportKHR`
pub type FN_vkGetPhysicalDeviceXcbPresentationSupportKHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, queueFamilyIndex: uint32_t, connection: *mut xcb_connection_t, visual_id: xcb_visualid_t) -> VkBool32;


/// `vkGetPhysicalDeviceXlibPresentationSupportKHR`
pub type PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR = Option<FN_vkGetPhysicalDeviceXlibPresentationSupportKHR>;

/// `vkGetPhysicalDeviceXlibPresentationSupportKHR`
pub type FN_vkGetPhysicalDeviceXlibPresentationSupportKHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, queueFamilyIndex: uint32_t, dpy: *mut Display, visualID: VisualID) -> VkBool32;


/// `vkGetPipelineBinaryDataKHR`
pub type PFN_vkGetPipelineBinaryDataKHR = Option<FN_vkGetPipelineBinaryDataKHR>;

/// `vkGetPipelineBinaryDataKHR`
pub type FN_vkGetPipelineBinaryDataKHR = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkPipelineBinaryDataInfoKHR, pPipelineBinaryKey: *mut VkPipelineBinaryKeyKHR, pPipelineBinaryDataSize: *mut size_t, pPipelineBinaryData: *mut void) -> VkResult;


/// `vkGetPipelineCacheData`
pub type PFN_vkGetPipelineCacheData = Option<FN_vkGetPipelineCacheData>;

/// `vkGetPipelineCacheData`
pub type FN_vkGetPipelineCacheData = unsafe extern "system" fn(device: VkDevice, pipelineCache: VkPipelineCache, pDataSize: *mut size_t, pData: *mut void) -> VkResult;


/// `vkGetPipelineExecutableInternalRepresentationsKHR`
pub type PFN_vkGetPipelineExecutableInternalRepresentationsKHR = Option<FN_vkGetPipelineExecutableInternalRepresentationsKHR>;

/// `vkGetPipelineExecutableInternalRepresentationsKHR`
pub type FN_vkGetPipelineExecutableInternalRepresentationsKHR = unsafe extern "system" fn(device: VkDevice, pExecutableInfo: *const VkPipelineExecutableInfoKHR, pInternalRepresentationCount: *mut uint32_t, pInternalRepresentations: *mut VkPipelineExecutableInternalRepresentationKHR) -> VkResult;


/// `vkGetPipelineExecutablePropertiesKHR`
pub type PFN_vkGetPipelineExecutablePropertiesKHR = Option<FN_vkGetPipelineExecutablePropertiesKHR>;

/// `vkGetPipelineExecutablePropertiesKHR`
pub type FN_vkGetPipelineExecutablePropertiesKHR = unsafe extern "system" fn(device: VkDevice, pPipelineInfo: *const VkPipelineInfoKHR, pExecutableCount: *mut uint32_t, pProperties: *mut VkPipelineExecutablePropertiesKHR) -> VkResult;


/// `vkGetPipelineExecutableStatisticsKHR`
pub type PFN_vkGetPipelineExecutableStatisticsKHR = Option<FN_vkGetPipelineExecutableStatisticsKHR>;

/// `vkGetPipelineExecutableStatisticsKHR`
pub type FN_vkGetPipelineExecutableStatisticsKHR = unsafe extern "system" fn(device: VkDevice, pExecutableInfo: *const VkPipelineExecutableInfoKHR, pStatisticCount: *mut uint32_t, pStatistics: *mut VkPipelineExecutableStatisticKHR) -> VkResult;


/// `vkGetPipelineIndirectDeviceAddressNV`
pub type PFN_vkGetPipelineIndirectDeviceAddressNV = Option<FN_vkGetPipelineIndirectDeviceAddressNV>;

/// `vkGetPipelineIndirectDeviceAddressNV`
pub type FN_vkGetPipelineIndirectDeviceAddressNV = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkPipelineIndirectDeviceAddressInfoNV) -> VkDeviceAddress;


/// `vkGetPipelineIndirectMemoryRequirementsNV`
pub type PFN_vkGetPipelineIndirectMemoryRequirementsNV = Option<FN_vkGetPipelineIndirectMemoryRequirementsNV>;

/// `vkGetPipelineIndirectMemoryRequirementsNV`
pub type FN_vkGetPipelineIndirectMemoryRequirementsNV = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkComputePipelineCreateInfo, pMemoryRequirements: *mut VkMemoryRequirements2) -> ();


/// `vkGetPipelineKeyKHR`
pub type PFN_vkGetPipelineKeyKHR = Option<FN_vkGetPipelineKeyKHR>;

/// `vkGetPipelineKeyKHR`
pub type FN_vkGetPipelineKeyKHR = unsafe extern "system" fn(device: VkDevice, pPipelineCreateInfo: *const VkPipelineCreateInfoKHR, pPipelineKey: *mut VkPipelineBinaryKeyKHR) -> VkResult;


/// `vkGetPipelinePropertiesEXT`
pub type PFN_vkGetPipelinePropertiesEXT = Option<FN_vkGetPipelinePropertiesEXT>;

/// `vkGetPipelinePropertiesEXT`
pub type FN_vkGetPipelinePropertiesEXT = unsafe extern "system" fn(device: VkDevice, pPipelineInfo: *const VkPipelineInfoEXT, pPipelineProperties: *mut VkBaseOutStructure) -> VkResult;


/// `vkGetPrivateData`
pub type PFN_vkGetPrivateData = Option<FN_vkGetPrivateData>;

/// `vkGetPrivateData`
pub type FN_vkGetPrivateData = unsafe extern "system" fn(device: VkDevice, objectType: VkObjectType, objectHandle: uint64_t, privateDataSlot: VkPrivateDataSlot, pData: *mut uint64_t) -> ();


/// `vkGetPrivateDataEXT` = `vkGetPrivateData`
pub type PFN_vkGetPrivateDataEXT = PFN_vkGetPrivateData;

/// `vkGetPrivateDataEXT` = `vkGetPrivateData`
pub type FN_vkGetPrivateDataEXT = FN_vkGetPrivateData;

/// `vkGetQueryPoolResults`
pub type PFN_vkGetQueryPoolResults = Option<FN_vkGetQueryPoolResults>;

/// `vkGetQueryPoolResults`
pub type FN_vkGetQueryPoolResults = unsafe extern "system" fn(device: VkDevice, queryPool: VkQueryPool, firstQuery: uint32_t, queryCount: uint32_t, dataSize: size_t, pData: *mut void, stride: VkDeviceSize, flags: VkQueryResultFlags) -> VkResult;


/// `vkGetQueueCheckpointData2NV`
pub type PFN_vkGetQueueCheckpointData2NV = Option<FN_vkGetQueueCheckpointData2NV>;

/// `vkGetQueueCheckpointData2NV`
pub type FN_vkGetQueueCheckpointData2NV = unsafe extern "system" fn(queue: VkQueue, pCheckpointDataCount: *mut uint32_t, pCheckpointData: *mut VkCheckpointData2NV) -> ();


/// `vkGetQueueCheckpointDataNV`
pub type PFN_vkGetQueueCheckpointDataNV = Option<FN_vkGetQueueCheckpointDataNV>;

/// `vkGetQueueCheckpointDataNV`
pub type FN_vkGetQueueCheckpointDataNV = unsafe extern "system" fn(queue: VkQueue, pCheckpointDataCount: *mut uint32_t, pCheckpointData: *mut VkCheckpointDataNV) -> ();


/// `vkGetRandROutputDisplayEXT`
pub type PFN_vkGetRandROutputDisplayEXT = Option<FN_vkGetRandROutputDisplayEXT>;

/// `vkGetRandROutputDisplayEXT`
pub type FN_vkGetRandROutputDisplayEXT = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, dpy: *mut Display, rrOutput: RROutput, pDisplay: *mut VkDisplayKHR) -> VkResult;


/// `vkGetRayTracingCaptureReplayShaderGroupHandlesKHR`
pub type PFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR = Option<FN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR>;

/// `vkGetRayTracingCaptureReplayShaderGroupHandlesKHR`
pub type FN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR = unsafe extern "system" fn(device: VkDevice, pipeline: VkPipeline, firstGroup: uint32_t, groupCount: uint32_t, dataSize: size_t, pData: *mut void) -> VkResult;


/// `vkGetRayTracingShaderGroupHandlesKHR`
pub type PFN_vkGetRayTracingShaderGroupHandlesKHR = Option<FN_vkGetRayTracingShaderGroupHandlesKHR>;

/// `vkGetRayTracingShaderGroupHandlesKHR`
pub type FN_vkGetRayTracingShaderGroupHandlesKHR = unsafe extern "system" fn(device: VkDevice, pipeline: VkPipeline, firstGroup: uint32_t, groupCount: uint32_t, dataSize: size_t, pData: *mut void) -> VkResult;


/// `vkGetRayTracingShaderGroupHandlesNV` = `vkGetRayTracingShaderGroupHandlesKHR`
pub type PFN_vkGetRayTracingShaderGroupHandlesNV = PFN_vkGetRayTracingShaderGroupHandlesKHR;

/// `vkGetRayTracingShaderGroupHandlesNV` = `vkGetRayTracingShaderGroupHandlesKHR`
pub type FN_vkGetRayTracingShaderGroupHandlesNV = FN_vkGetRayTracingShaderGroupHandlesKHR;

/// `vkGetRayTracingShaderGroupStackSizeKHR`
pub type PFN_vkGetRayTracingShaderGroupStackSizeKHR = Option<FN_vkGetRayTracingShaderGroupStackSizeKHR>;

/// `vkGetRayTracingShaderGroupStackSizeKHR`
pub type FN_vkGetRayTracingShaderGroupStackSizeKHR = unsafe extern "system" fn(device: VkDevice, pipeline: VkPipeline, group: uint32_t, groupShader: VkShaderGroupShaderKHR) -> VkDeviceSize;


/// `vkGetRefreshCycleDurationGOOGLE`
pub type PFN_vkGetRefreshCycleDurationGOOGLE = Option<FN_vkGetRefreshCycleDurationGOOGLE>;

/// `vkGetRefreshCycleDurationGOOGLE`
pub type FN_vkGetRefreshCycleDurationGOOGLE = unsafe extern "system" fn(device: VkDevice, swapchain: VkSwapchainKHR, pDisplayTimingProperties: *mut VkRefreshCycleDurationGOOGLE) -> VkResult;


/// `vkGetRenderAreaGranularity`
pub type PFN_vkGetRenderAreaGranularity = Option<FN_vkGetRenderAreaGranularity>;

/// `vkGetRenderAreaGranularity`
pub type FN_vkGetRenderAreaGranularity = unsafe extern "system" fn(device: VkDevice, renderPass: VkRenderPass, pGranularity: *mut VkExtent2D) -> ();


/// `vkGetRenderingAreaGranularity`
pub type PFN_vkGetRenderingAreaGranularity = Option<FN_vkGetRenderingAreaGranularity>;

/// `vkGetRenderingAreaGranularity`
pub type FN_vkGetRenderingAreaGranularity = unsafe extern "system" fn(device: VkDevice, pRenderingAreaInfo: *const VkRenderingAreaInfo, pGranularity: *mut VkExtent2D) -> ();


/// `vkGetRenderingAreaGranularityKHR` = `vkGetRenderingAreaGranularity`
pub type PFN_vkGetRenderingAreaGranularityKHR = PFN_vkGetRenderingAreaGranularity;

/// `vkGetRenderingAreaGranularityKHR` = `vkGetRenderingAreaGranularity`
pub type FN_vkGetRenderingAreaGranularityKHR = FN_vkGetRenderingAreaGranularity;

/// `vkGetSamplerOpaqueCaptureDescriptorDataEXT`
pub type PFN_vkGetSamplerOpaqueCaptureDescriptorDataEXT = Option<FN_vkGetSamplerOpaqueCaptureDescriptorDataEXT>;

/// `vkGetSamplerOpaqueCaptureDescriptorDataEXT`
pub type FN_vkGetSamplerOpaqueCaptureDescriptorDataEXT = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkSamplerCaptureDescriptorDataInfoEXT, pData: *mut void) -> VkResult;


/// `vkGetScreenBufferPropertiesQNX`
pub type PFN_vkGetScreenBufferPropertiesQNX = Option<FN_vkGetScreenBufferPropertiesQNX>;

/// `vkGetScreenBufferPropertiesQNX`
pub type FN_vkGetScreenBufferPropertiesQNX = unsafe extern "system" fn(device: VkDevice, buffer: *const _screen_buffer, pProperties: *mut VkScreenBufferPropertiesQNX) -> VkResult;


/// `vkGetSemaphoreCounterValue`
pub type PFN_vkGetSemaphoreCounterValue = Option<FN_vkGetSemaphoreCounterValue>;

/// `vkGetSemaphoreCounterValue`
pub type FN_vkGetSemaphoreCounterValue = unsafe extern "system" fn(device: VkDevice, semaphore: VkSemaphore, pValue: *mut uint64_t) -> VkResult;


/// `vkGetSemaphoreCounterValueKHR` = `vkGetSemaphoreCounterValue`
pub type PFN_vkGetSemaphoreCounterValueKHR = PFN_vkGetSemaphoreCounterValue;

/// `vkGetSemaphoreCounterValueKHR` = `vkGetSemaphoreCounterValue`
pub type FN_vkGetSemaphoreCounterValueKHR = FN_vkGetSemaphoreCounterValue;

/// `vkGetSemaphoreFdKHR`
pub type PFN_vkGetSemaphoreFdKHR = Option<FN_vkGetSemaphoreFdKHR>;

/// `vkGetSemaphoreFdKHR`
pub type FN_vkGetSemaphoreFdKHR = unsafe extern "system" fn(device: VkDevice, pGetFdInfo: *const VkSemaphoreGetFdInfoKHR, pFd: *mut int) -> VkResult;


/// `vkGetSemaphoreSciSyncObjNV`
pub type PFN_vkGetSemaphoreSciSyncObjNV = Option<FN_vkGetSemaphoreSciSyncObjNV>;

/// `vkGetSemaphoreSciSyncObjNV`
pub type FN_vkGetSemaphoreSciSyncObjNV = unsafe extern "system" fn(device: VkDevice, pGetSciSyncInfo: *const VkSemaphoreGetSciSyncInfoNV, pHandle: *mut void) -> VkResult;


/// `vkGetSemaphoreWin32HandleKHR`
pub type PFN_vkGetSemaphoreWin32HandleKHR = Option<FN_vkGetSemaphoreWin32HandleKHR>;

/// `vkGetSemaphoreWin32HandleKHR`
pub type FN_vkGetSemaphoreWin32HandleKHR = unsafe extern "system" fn(device: VkDevice, pGetWin32HandleInfo: *const VkSemaphoreGetWin32HandleInfoKHR, pHandle: *mut HANDLE) -> VkResult;


/// `vkGetSemaphoreZirconHandleFUCHSIA`
pub type PFN_vkGetSemaphoreZirconHandleFUCHSIA = Option<FN_vkGetSemaphoreZirconHandleFUCHSIA>;

/// `vkGetSemaphoreZirconHandleFUCHSIA`
pub type FN_vkGetSemaphoreZirconHandleFUCHSIA = unsafe extern "system" fn(device: VkDevice, pGetZirconHandleInfo: *const VkSemaphoreGetZirconHandleInfoFUCHSIA, pZirconHandle: *mut zx_handle_t) -> VkResult;


/// `vkGetShaderBinaryDataEXT`
pub type PFN_vkGetShaderBinaryDataEXT = Option<FN_vkGetShaderBinaryDataEXT>;

/// `vkGetShaderBinaryDataEXT`
pub type FN_vkGetShaderBinaryDataEXT = unsafe extern "system" fn(device: VkDevice, shader: VkShaderEXT, pDataSize: *mut size_t, pData: *mut void) -> VkResult;


/// `vkGetShaderInfoAMD`
pub type PFN_vkGetShaderInfoAMD = Option<FN_vkGetShaderInfoAMD>;

/// `vkGetShaderInfoAMD`
pub type FN_vkGetShaderInfoAMD = unsafe extern "system" fn(device: VkDevice, pipeline: VkPipeline, shaderStage: VkShaderStageFlags, infoType: VkShaderInfoTypeAMD, pInfoSize: *mut size_t, pInfo: *mut void) -> VkResult;


/// `vkGetShaderInstrumentationValuesARM`
pub type PFN_vkGetShaderInstrumentationValuesARM = Option<FN_vkGetShaderInstrumentationValuesARM>;

/// `vkGetShaderInstrumentationValuesARM`
pub type FN_vkGetShaderInstrumentationValuesARM = unsafe extern "system" fn(device: VkDevice, instrumentation: VkShaderInstrumentationARM, pMetricBlockCount: *mut uint32_t, pMetricValues: *mut void, flags: VkShaderInstrumentationValuesFlagsARM) -> VkResult;


/// `vkGetShaderModuleCreateInfoIdentifierEXT`
pub type PFN_vkGetShaderModuleCreateInfoIdentifierEXT = Option<FN_vkGetShaderModuleCreateInfoIdentifierEXT>;

/// `vkGetShaderModuleCreateInfoIdentifierEXT`
pub type FN_vkGetShaderModuleCreateInfoIdentifierEXT = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkShaderModuleCreateInfo, pIdentifier: *mut VkShaderModuleIdentifierEXT) -> ();


/// `vkGetShaderModuleIdentifierEXT`
pub type PFN_vkGetShaderModuleIdentifierEXT = Option<FN_vkGetShaderModuleIdentifierEXT>;

/// `vkGetShaderModuleIdentifierEXT`
pub type FN_vkGetShaderModuleIdentifierEXT = unsafe extern "system" fn(device: VkDevice, shaderModule: VkShaderModule, pIdentifier: *mut VkShaderModuleIdentifierEXT) -> ();


/// `vkGetSwapchainCounterEXT`
pub type PFN_vkGetSwapchainCounterEXT = Option<FN_vkGetSwapchainCounterEXT>;

/// `vkGetSwapchainCounterEXT`
pub type FN_vkGetSwapchainCounterEXT = unsafe extern "system" fn(device: VkDevice, swapchain: VkSwapchainKHR, counter: VkSurfaceCounterFlagsEXT, pCounterValue: *mut uint64_t) -> VkResult;


/// `vkGetSwapchainGrallocUsage2ANDROID`
pub type PFN_vkGetSwapchainGrallocUsage2ANDROID = Option<FN_vkGetSwapchainGrallocUsage2ANDROID>;

/// `vkGetSwapchainGrallocUsage2ANDROID`
pub type FN_vkGetSwapchainGrallocUsage2ANDROID = unsafe extern "system" fn(device: VkDevice, format: VkFormat, imageUsage: VkImageUsageFlags, swapchainImageUsage: VkSwapchainImageUsageFlagsANDROID, grallocConsumerUsage: *mut uint64_t, grallocProducerUsage: *mut uint64_t) -> VkResult;


/// `vkGetSwapchainGrallocUsageANDROID`
pub type PFN_vkGetSwapchainGrallocUsageANDROID = Option<FN_vkGetSwapchainGrallocUsageANDROID>;

/// `vkGetSwapchainGrallocUsageANDROID`
pub type FN_vkGetSwapchainGrallocUsageANDROID = unsafe extern "system" fn(device: VkDevice, format: VkFormat, imageUsage: VkImageUsageFlags, grallocUsage: *mut int) -> VkResult;


/// `vkGetSwapchainGrallocUsageOHOS`
pub type PFN_vkGetSwapchainGrallocUsageOHOS = Option<FN_vkGetSwapchainGrallocUsageOHOS>;

/// `vkGetSwapchainGrallocUsageOHOS`
pub type FN_vkGetSwapchainGrallocUsageOHOS = unsafe extern "system" fn(device: VkDevice, format: VkFormat, imageUsage: VkImageUsageFlags, grallocUsage: *mut uint64_t) -> VkResult;


/// `vkGetSwapchainImagesKHR`
pub type PFN_vkGetSwapchainImagesKHR = Option<FN_vkGetSwapchainImagesKHR>;

/// `vkGetSwapchainImagesKHR`
pub type FN_vkGetSwapchainImagesKHR = unsafe extern "system" fn(device: VkDevice, swapchain: VkSwapchainKHR, pSwapchainImageCount: *mut uint32_t, pSwapchainImages: *mut VkImage) -> VkResult;


/// `vkGetSwapchainStatusKHR`
pub type PFN_vkGetSwapchainStatusKHR = Option<FN_vkGetSwapchainStatusKHR>;

/// `vkGetSwapchainStatusKHR`
pub type FN_vkGetSwapchainStatusKHR = unsafe extern "system" fn(device: VkDevice, swapchain: VkSwapchainKHR) -> VkResult;


/// `vkGetSwapchainTimeDomainPropertiesEXT`
pub type PFN_vkGetSwapchainTimeDomainPropertiesEXT = Option<FN_vkGetSwapchainTimeDomainPropertiesEXT>;

/// `vkGetSwapchainTimeDomainPropertiesEXT`
pub type FN_vkGetSwapchainTimeDomainPropertiesEXT = unsafe extern "system" fn(device: VkDevice, swapchain: VkSwapchainKHR, pSwapchainTimeDomainProperties: *mut VkSwapchainTimeDomainPropertiesEXT, pTimeDomainsCounter: *mut uint64_t) -> VkResult;


/// `vkGetSwapchainTimingPropertiesEXT`
pub type PFN_vkGetSwapchainTimingPropertiesEXT = Option<FN_vkGetSwapchainTimingPropertiesEXT>;

/// `vkGetSwapchainTimingPropertiesEXT`
pub type FN_vkGetSwapchainTimingPropertiesEXT = unsafe extern "system" fn(device: VkDevice, swapchain: VkSwapchainKHR, pSwapchainTimingProperties: *mut VkSwapchainTimingPropertiesEXT, pSwapchainTimingPropertiesCounter: *mut uint64_t) -> VkResult;


/// `vkGetTensorMemoryRequirementsARM`
pub type PFN_vkGetTensorMemoryRequirementsARM = Option<FN_vkGetTensorMemoryRequirementsARM>;

/// `vkGetTensorMemoryRequirementsARM`
pub type FN_vkGetTensorMemoryRequirementsARM = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkTensorMemoryRequirementsInfoARM, pMemoryRequirements: *mut VkMemoryRequirements2) -> ();


/// `vkGetTensorOpaqueCaptureDataARM`
pub type PFN_vkGetTensorOpaqueCaptureDataARM = Option<FN_vkGetTensorOpaqueCaptureDataARM>;

/// `vkGetTensorOpaqueCaptureDataARM`
pub type FN_vkGetTensorOpaqueCaptureDataARM = unsafe extern "system" fn(device: VkDevice, tensorCount: uint32_t, pTensors: *const VkTensorARM, pDatas: *mut VkHostAddressRangeEXT) -> VkResult;


/// `vkGetTensorOpaqueCaptureDescriptorDataARM`
pub type PFN_vkGetTensorOpaqueCaptureDescriptorDataARM = Option<FN_vkGetTensorOpaqueCaptureDescriptorDataARM>;

/// `vkGetTensorOpaqueCaptureDescriptorDataARM`
pub type FN_vkGetTensorOpaqueCaptureDescriptorDataARM = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkTensorCaptureDescriptorDataInfoARM, pData: *mut void) -> VkResult;


/// `vkGetTensorViewOpaqueCaptureDescriptorDataARM`
pub type PFN_vkGetTensorViewOpaqueCaptureDescriptorDataARM = Option<FN_vkGetTensorViewOpaqueCaptureDescriptorDataARM>;

/// `vkGetTensorViewOpaqueCaptureDescriptorDataARM`
pub type FN_vkGetTensorViewOpaqueCaptureDescriptorDataARM = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkTensorViewCaptureDescriptorDataInfoARM, pData: *mut void) -> VkResult;


/// `vkGetValidationCacheDataEXT`
pub type PFN_vkGetValidationCacheDataEXT = Option<FN_vkGetValidationCacheDataEXT>;

/// `vkGetValidationCacheDataEXT`
pub type FN_vkGetValidationCacheDataEXT = unsafe extern "system" fn(device: VkDevice, validationCache: VkValidationCacheEXT, pDataSize: *mut size_t, pData: *mut void) -> VkResult;


/// `vkGetVideoSessionMemoryRequirementsKHR`
pub type PFN_vkGetVideoSessionMemoryRequirementsKHR = Option<FN_vkGetVideoSessionMemoryRequirementsKHR>;

/// `vkGetVideoSessionMemoryRequirementsKHR`
pub type FN_vkGetVideoSessionMemoryRequirementsKHR = unsafe extern "system" fn(device: VkDevice, videoSession: VkVideoSessionKHR, pMemoryRequirementsCount: *mut uint32_t, pMemoryRequirements: *mut VkVideoSessionMemoryRequirementsKHR) -> VkResult;


/// `vkGetWinrtDisplayNV`
pub type PFN_vkGetWinrtDisplayNV = Option<FN_vkGetWinrtDisplayNV>;

/// `vkGetWinrtDisplayNV`
pub type FN_vkGetWinrtDisplayNV = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, deviceRelativeId: uint32_t, pDisplay: *mut VkDisplayKHR) -> VkResult;


/// `vkImportFenceFdKHR`
pub type PFN_vkImportFenceFdKHR = Option<FN_vkImportFenceFdKHR>;

/// `vkImportFenceFdKHR`
pub type FN_vkImportFenceFdKHR = unsafe extern "system" fn(device: VkDevice, pImportFenceFdInfo: *const VkImportFenceFdInfoKHR) -> VkResult;


/// `vkImportFenceSciSyncFenceNV`
pub type PFN_vkImportFenceSciSyncFenceNV = Option<FN_vkImportFenceSciSyncFenceNV>;

/// `vkImportFenceSciSyncFenceNV`
pub type FN_vkImportFenceSciSyncFenceNV = unsafe extern "system" fn(device: VkDevice, pImportFenceSciSyncInfo: *const VkImportFenceSciSyncInfoNV) -> VkResult;


/// `vkImportFenceSciSyncObjNV`
pub type PFN_vkImportFenceSciSyncObjNV = Option<FN_vkImportFenceSciSyncObjNV>;

/// `vkImportFenceSciSyncObjNV`
pub type FN_vkImportFenceSciSyncObjNV = unsafe extern "system" fn(device: VkDevice, pImportFenceSciSyncInfo: *const VkImportFenceSciSyncInfoNV) -> VkResult;


/// `vkImportFenceWin32HandleKHR`
pub type PFN_vkImportFenceWin32HandleKHR = Option<FN_vkImportFenceWin32HandleKHR>;

/// `vkImportFenceWin32HandleKHR`
pub type FN_vkImportFenceWin32HandleKHR = unsafe extern "system" fn(device: VkDevice, pImportFenceWin32HandleInfo: *const VkImportFenceWin32HandleInfoKHR) -> VkResult;


/// `vkImportSemaphoreFdKHR`
pub type PFN_vkImportSemaphoreFdKHR = Option<FN_vkImportSemaphoreFdKHR>;

/// `vkImportSemaphoreFdKHR`
pub type FN_vkImportSemaphoreFdKHR = unsafe extern "system" fn(device: VkDevice, pImportSemaphoreFdInfo: *const VkImportSemaphoreFdInfoKHR) -> VkResult;


/// `vkImportSemaphoreSciSyncObjNV`
pub type PFN_vkImportSemaphoreSciSyncObjNV = Option<FN_vkImportSemaphoreSciSyncObjNV>;

/// `vkImportSemaphoreSciSyncObjNV`
pub type FN_vkImportSemaphoreSciSyncObjNV = unsafe extern "system" fn(device: VkDevice, pImportSemaphoreSciSyncInfo: *const VkImportSemaphoreSciSyncInfoNV) -> VkResult;


/// `vkImportSemaphoreWin32HandleKHR`
pub type PFN_vkImportSemaphoreWin32HandleKHR = Option<FN_vkImportSemaphoreWin32HandleKHR>;

/// `vkImportSemaphoreWin32HandleKHR`
pub type FN_vkImportSemaphoreWin32HandleKHR = unsafe extern "system" fn(device: VkDevice, pImportSemaphoreWin32HandleInfo: *const VkImportSemaphoreWin32HandleInfoKHR) -> VkResult;


/// `vkImportSemaphoreZirconHandleFUCHSIA`
pub type PFN_vkImportSemaphoreZirconHandleFUCHSIA = Option<FN_vkImportSemaphoreZirconHandleFUCHSIA>;

/// `vkImportSemaphoreZirconHandleFUCHSIA`
pub type FN_vkImportSemaphoreZirconHandleFUCHSIA = unsafe extern "system" fn(device: VkDevice, pImportSemaphoreZirconHandleInfo: *const VkImportSemaphoreZirconHandleInfoFUCHSIA) -> VkResult;


/// `vkInitializePerformanceApiINTEL`
pub type PFN_vkInitializePerformanceApiINTEL = Option<FN_vkInitializePerformanceApiINTEL>;

/// `vkInitializePerformanceApiINTEL`
pub type FN_vkInitializePerformanceApiINTEL = unsafe extern "system" fn(device: VkDevice, pInitializeInfo: *const VkInitializePerformanceApiInfoINTEL) -> VkResult;


/// `vkInvalidateMappedMemoryRanges`
pub type PFN_vkInvalidateMappedMemoryRanges = Option<FN_vkInvalidateMappedMemoryRanges>;

/// `vkInvalidateMappedMemoryRanges`
pub type FN_vkInvalidateMappedMemoryRanges = unsafe extern "system" fn(device: VkDevice, memoryRangeCount: uint32_t, pMemoryRanges: *const VkMappedMemoryRange) -> VkResult;


/// `vkLatencySleepNV`
pub type PFN_vkLatencySleepNV = Option<FN_vkLatencySleepNV>;

/// `vkLatencySleepNV`
pub type FN_vkLatencySleepNV = unsafe extern "system" fn(device: VkDevice, swapchain: VkSwapchainKHR, pSleepInfo: *const VkLatencySleepInfoNV) -> VkResult;


/// `vkMapMemory`
pub type PFN_vkMapMemory = Option<FN_vkMapMemory>;

/// `vkMapMemory`
pub type FN_vkMapMemory = unsafe extern "system" fn(device: VkDevice, memory: VkDeviceMemory, offset: VkDeviceSize, size: VkDeviceSize, flags: VkMemoryMapFlags, ppData: *mut *mut void) -> VkResult;


/// `vkMapMemory2`
pub type PFN_vkMapMemory2 = Option<FN_vkMapMemory2>;

/// `vkMapMemory2`
pub type FN_vkMapMemory2 = unsafe extern "system" fn(device: VkDevice, pMemoryMapInfo: *const VkMemoryMapInfo, ppData: *mut *mut void) -> VkResult;


/// `vkMapMemory2KHR` = `vkMapMemory2`
pub type PFN_vkMapMemory2KHR = PFN_vkMapMemory2;

/// `vkMapMemory2KHR` = `vkMapMemory2`
pub type FN_vkMapMemory2KHR = FN_vkMapMemory2;

/// `vkMergePipelineCaches`
pub type PFN_vkMergePipelineCaches = Option<FN_vkMergePipelineCaches>;

/// `vkMergePipelineCaches`
pub type FN_vkMergePipelineCaches = unsafe extern "system" fn(device: VkDevice, dstCache: VkPipelineCache, srcCacheCount: uint32_t, pSrcCaches: *const VkPipelineCache) -> VkResult;


/// `vkMergeValidationCachesEXT`
pub type PFN_vkMergeValidationCachesEXT = Option<FN_vkMergeValidationCachesEXT>;

/// `vkMergeValidationCachesEXT`
pub type FN_vkMergeValidationCachesEXT = unsafe extern "system" fn(device: VkDevice, dstCache: VkValidationCacheEXT, srcCacheCount: uint32_t, pSrcCaches: *const VkValidationCacheEXT) -> VkResult;


/// `vkQueueBeginDebugUtilsLabelEXT`
pub type PFN_vkQueueBeginDebugUtilsLabelEXT = Option<FN_vkQueueBeginDebugUtilsLabelEXT>;

/// `vkQueueBeginDebugUtilsLabelEXT`
pub type FN_vkQueueBeginDebugUtilsLabelEXT = unsafe extern "system" fn(queue: VkQueue, pLabelInfo: *const VkDebugUtilsLabelEXT) -> ();


/// `vkQueueBindSparse`
pub type PFN_vkQueueBindSparse = Option<FN_vkQueueBindSparse>;

/// `vkQueueBindSparse`
pub type FN_vkQueueBindSparse = unsafe extern "system" fn(queue: VkQueue, bindInfoCount: uint32_t, pBindInfo: *const VkBindSparseInfo, fence: VkFence) -> VkResult;


/// `vkQueueEndDebugUtilsLabelEXT`
pub type PFN_vkQueueEndDebugUtilsLabelEXT = Option<FN_vkQueueEndDebugUtilsLabelEXT>;

/// `vkQueueEndDebugUtilsLabelEXT`
pub type FN_vkQueueEndDebugUtilsLabelEXT = unsafe extern "system" fn(queue: VkQueue) -> ();


/// `vkQueueInsertDebugUtilsLabelEXT`
pub type PFN_vkQueueInsertDebugUtilsLabelEXT = Option<FN_vkQueueInsertDebugUtilsLabelEXT>;

/// `vkQueueInsertDebugUtilsLabelEXT`
pub type FN_vkQueueInsertDebugUtilsLabelEXT = unsafe extern "system" fn(queue: VkQueue, pLabelInfo: *const VkDebugUtilsLabelEXT) -> ();


/// `vkQueueNotifyOutOfBandNV`
pub type PFN_vkQueueNotifyOutOfBandNV = Option<FN_vkQueueNotifyOutOfBandNV>;

/// `vkQueueNotifyOutOfBandNV`
pub type FN_vkQueueNotifyOutOfBandNV = unsafe extern "system" fn(queue: VkQueue, pQueueTypeInfo: *const VkOutOfBandQueueTypeInfoNV) -> ();


/// `vkQueuePresentKHR`
pub type PFN_vkQueuePresentKHR = Option<FN_vkQueuePresentKHR>;

/// `vkQueuePresentKHR`
pub type FN_vkQueuePresentKHR = unsafe extern "system" fn(queue: VkQueue, pPresentInfo: *const VkPresentInfoKHR) -> VkResult;


/// `vkQueueSetPerformanceConfigurationINTEL`
pub type PFN_vkQueueSetPerformanceConfigurationINTEL = Option<FN_vkQueueSetPerformanceConfigurationINTEL>;

/// `vkQueueSetPerformanceConfigurationINTEL`
pub type FN_vkQueueSetPerformanceConfigurationINTEL = unsafe extern "system" fn(queue: VkQueue, configuration: VkPerformanceConfigurationINTEL) -> VkResult;


/// `vkQueueSignalReleaseImageANDROID`
pub type PFN_vkQueueSignalReleaseImageANDROID = Option<FN_vkQueueSignalReleaseImageANDROID>;

/// `vkQueueSignalReleaseImageANDROID`
pub type FN_vkQueueSignalReleaseImageANDROID = unsafe extern "system" fn(queue: VkQueue, waitSemaphoreCount: uint32_t, pWaitSemaphores: *const VkSemaphore, image: VkImage, pNativeFenceFd: *mut int) -> VkResult;


/// `vkQueueSignalReleaseImageOHOS`
pub type PFN_vkQueueSignalReleaseImageOHOS = Option<FN_vkQueueSignalReleaseImageOHOS>;

/// `vkQueueSignalReleaseImageOHOS`
pub type FN_vkQueueSignalReleaseImageOHOS = unsafe extern "system" fn(queue: VkQueue, waitSemaphoreCount: uint32_t, pWaitSemaphores: *const VkSemaphore, image: VkImage, pNativeFenceFd: *mut int32_t) -> VkResult;


/// `vkQueueSubmit`
pub type PFN_vkQueueSubmit = Option<FN_vkQueueSubmit>;

/// `vkQueueSubmit`
pub type FN_vkQueueSubmit = unsafe extern "system" fn(queue: VkQueue, submitCount: uint32_t, pSubmits: *const VkSubmitInfo, fence: VkFence) -> VkResult;


/// `vkQueueSubmit2`
pub type PFN_vkQueueSubmit2 = Option<FN_vkQueueSubmit2>;

/// `vkQueueSubmit2`
pub type FN_vkQueueSubmit2 = unsafe extern "system" fn(queue: VkQueue, submitCount: uint32_t, pSubmits: *const VkSubmitInfo2, fence: VkFence) -> VkResult;


/// `vkQueueSubmit2KHR` = `vkQueueSubmit2`
pub type PFN_vkQueueSubmit2KHR = PFN_vkQueueSubmit2;

/// `vkQueueSubmit2KHR` = `vkQueueSubmit2`
pub type FN_vkQueueSubmit2KHR = FN_vkQueueSubmit2;

/// `vkQueueWaitIdle`
pub type PFN_vkQueueWaitIdle = Option<FN_vkQueueWaitIdle>;

/// `vkQueueWaitIdle`
pub type FN_vkQueueWaitIdle = unsafe extern "system" fn(queue: VkQueue) -> VkResult;


/// `vkRegisterCustomBorderColorEXT`
pub type PFN_vkRegisterCustomBorderColorEXT = Option<FN_vkRegisterCustomBorderColorEXT>;

/// `vkRegisterCustomBorderColorEXT`
pub type FN_vkRegisterCustomBorderColorEXT = unsafe extern "system" fn(device: VkDevice, pBorderColor: *const VkSamplerCustomBorderColorCreateInfoEXT, requestIndex: VkBool32, pIndex: *mut uint32_t) -> VkResult;


/// `vkRegisterDeviceEventEXT`
pub type PFN_vkRegisterDeviceEventEXT = Option<FN_vkRegisterDeviceEventEXT>;

/// `vkRegisterDeviceEventEXT`
pub type FN_vkRegisterDeviceEventEXT = unsafe extern "system" fn(device: VkDevice, pDeviceEventInfo: *const VkDeviceEventInfoEXT, pAllocator: *const VkAllocationCallbacks, pFence: *mut VkFence) -> VkResult;


/// `vkRegisterDisplayEventEXT`
pub type PFN_vkRegisterDisplayEventEXT = Option<FN_vkRegisterDisplayEventEXT>;

/// `vkRegisterDisplayEventEXT`
pub type FN_vkRegisterDisplayEventEXT = unsafe extern "system" fn(device: VkDevice, display: VkDisplayKHR, pDisplayEventInfo: *const VkDisplayEventInfoEXT, pAllocator: *const VkAllocationCallbacks, pFence: *mut VkFence) -> VkResult;


/// `vkReleaseCapturedPipelineDataKHR`
pub type PFN_vkReleaseCapturedPipelineDataKHR = Option<FN_vkReleaseCapturedPipelineDataKHR>;

/// `vkReleaseCapturedPipelineDataKHR`
pub type FN_vkReleaseCapturedPipelineDataKHR = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkReleaseCapturedPipelineDataInfoKHR, pAllocator: *const VkAllocationCallbacks) -> VkResult;


/// `vkReleaseDisplayEXT`
pub type PFN_vkReleaseDisplayEXT = Option<FN_vkReleaseDisplayEXT>;

/// `vkReleaseDisplayEXT`
pub type FN_vkReleaseDisplayEXT = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, display: VkDisplayKHR) -> VkResult;


/// `vkReleaseFullScreenExclusiveModeEXT`
pub type PFN_vkReleaseFullScreenExclusiveModeEXT = Option<FN_vkReleaseFullScreenExclusiveModeEXT>;

/// `vkReleaseFullScreenExclusiveModeEXT`
pub type FN_vkReleaseFullScreenExclusiveModeEXT = unsafe extern "system" fn(device: VkDevice, swapchain: VkSwapchainKHR) -> VkResult;


/// `vkReleasePerformanceConfigurationINTEL`
pub type PFN_vkReleasePerformanceConfigurationINTEL = Option<FN_vkReleasePerformanceConfigurationINTEL>;

/// `vkReleasePerformanceConfigurationINTEL`
pub type FN_vkReleasePerformanceConfigurationINTEL = unsafe extern "system" fn(device: VkDevice, configuration: VkPerformanceConfigurationINTEL) -> VkResult;


/// `vkReleaseProfilingLockKHR`
pub type PFN_vkReleaseProfilingLockKHR = Option<FN_vkReleaseProfilingLockKHR>;

/// `vkReleaseProfilingLockKHR`
pub type FN_vkReleaseProfilingLockKHR = unsafe extern "system" fn(device: VkDevice) -> ();


/// `vkReleaseSwapchainImagesEXT` = `vkReleaseSwapchainImagesKHR`
pub type PFN_vkReleaseSwapchainImagesEXT = PFN_vkReleaseSwapchainImagesKHR;

/// `vkReleaseSwapchainImagesEXT` = `vkReleaseSwapchainImagesKHR`
pub type FN_vkReleaseSwapchainImagesEXT = FN_vkReleaseSwapchainImagesKHR;

/// `vkReleaseSwapchainImagesKHR`
pub type PFN_vkReleaseSwapchainImagesKHR = Option<FN_vkReleaseSwapchainImagesKHR>;

/// `vkReleaseSwapchainImagesKHR`
pub type FN_vkReleaseSwapchainImagesKHR = unsafe extern "system" fn(device: VkDevice, pReleaseInfo: *const VkReleaseSwapchainImagesInfoKHR) -> VkResult;


/// `vkResetCommandBuffer`
pub type PFN_vkResetCommandBuffer = Option<FN_vkResetCommandBuffer>;

/// `vkResetCommandBuffer`
pub type FN_vkResetCommandBuffer = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, flags: VkCommandBufferResetFlags) -> VkResult;


/// `vkResetCommandPool`
pub type PFN_vkResetCommandPool = Option<FN_vkResetCommandPool>;

/// `vkResetCommandPool`
pub type FN_vkResetCommandPool = unsafe extern "system" fn(device: VkDevice, commandPool: VkCommandPool, flags: VkCommandPoolResetFlags) -> VkResult;


/// `vkResetDescriptorPool`
pub type PFN_vkResetDescriptorPool = Option<FN_vkResetDescriptorPool>;

/// `vkResetDescriptorPool`
pub type FN_vkResetDescriptorPool = unsafe extern "system" fn(device: VkDevice, descriptorPool: VkDescriptorPool, flags: VkDescriptorPoolResetFlags) -> VkResult;


/// `vkResetEvent`
pub type PFN_vkResetEvent = Option<FN_vkResetEvent>;

/// `vkResetEvent`
pub type FN_vkResetEvent = unsafe extern "system" fn(device: VkDevice, event: VkEvent) -> VkResult;


/// `vkResetFences`
pub type PFN_vkResetFences = Option<FN_vkResetFences>;

/// `vkResetFences`
pub type FN_vkResetFences = unsafe extern "system" fn(device: VkDevice, fenceCount: uint32_t, pFences: *const VkFence) -> VkResult;


/// `vkResetQueryPool`
pub type PFN_vkResetQueryPool = Option<FN_vkResetQueryPool>;

/// `vkResetQueryPool`
pub type FN_vkResetQueryPool = unsafe extern "system" fn(device: VkDevice, queryPool: VkQueryPool, firstQuery: uint32_t, queryCount: uint32_t) -> ();


/// `vkResetQueryPoolEXT` = `vkResetQueryPool`
pub type PFN_vkResetQueryPoolEXT = PFN_vkResetQueryPool;

/// `vkResetQueryPoolEXT` = `vkResetQueryPool`
pub type FN_vkResetQueryPoolEXT = FN_vkResetQueryPool;

/// `vkSetBufferCollectionBufferConstraintsFUCHSIA`
pub type PFN_vkSetBufferCollectionBufferConstraintsFUCHSIA = Option<FN_vkSetBufferCollectionBufferConstraintsFUCHSIA>;

/// `vkSetBufferCollectionBufferConstraintsFUCHSIA`
pub type FN_vkSetBufferCollectionBufferConstraintsFUCHSIA = unsafe extern "system" fn(device: VkDevice, collection: VkBufferCollectionFUCHSIA, pBufferConstraintsInfo: *const VkBufferConstraintsInfoFUCHSIA) -> VkResult;


/// `vkSetBufferCollectionImageConstraintsFUCHSIA`
pub type PFN_vkSetBufferCollectionImageConstraintsFUCHSIA = Option<FN_vkSetBufferCollectionImageConstraintsFUCHSIA>;

/// `vkSetBufferCollectionImageConstraintsFUCHSIA`
pub type FN_vkSetBufferCollectionImageConstraintsFUCHSIA = unsafe extern "system" fn(device: VkDevice, collection: VkBufferCollectionFUCHSIA, pImageConstraintsInfo: *const VkImageConstraintsInfoFUCHSIA) -> VkResult;


/// `vkSetDebugUtilsObjectNameEXT`
pub type PFN_vkSetDebugUtilsObjectNameEXT = Option<FN_vkSetDebugUtilsObjectNameEXT>;

/// `vkSetDebugUtilsObjectNameEXT`
pub type FN_vkSetDebugUtilsObjectNameEXT = unsafe extern "system" fn(device: VkDevice, pNameInfo: *const VkDebugUtilsObjectNameInfoEXT) -> VkResult;


/// `vkSetDebugUtilsObjectTagEXT`
pub type PFN_vkSetDebugUtilsObjectTagEXT = Option<FN_vkSetDebugUtilsObjectTagEXT>;

/// `vkSetDebugUtilsObjectTagEXT`
pub type FN_vkSetDebugUtilsObjectTagEXT = unsafe extern "system" fn(device: VkDevice, pTagInfo: *const VkDebugUtilsObjectTagInfoEXT) -> VkResult;


/// `vkSetDeviceMemoryPriorityEXT`
pub type PFN_vkSetDeviceMemoryPriorityEXT = Option<FN_vkSetDeviceMemoryPriorityEXT>;

/// `vkSetDeviceMemoryPriorityEXT`
pub type FN_vkSetDeviceMemoryPriorityEXT = unsafe extern "system" fn(device: VkDevice, memory: VkDeviceMemory, priority: float) -> ();


/// `vkSetEvent`
pub type PFN_vkSetEvent = Option<FN_vkSetEvent>;

/// `vkSetEvent`
pub type FN_vkSetEvent = unsafe extern "system" fn(device: VkDevice, event: VkEvent) -> VkResult;


/// `vkSetHdrMetadataEXT`
pub type PFN_vkSetHdrMetadataEXT = Option<FN_vkSetHdrMetadataEXT>;

/// `vkSetHdrMetadataEXT`
pub type FN_vkSetHdrMetadataEXT = unsafe extern "system" fn(device: VkDevice, swapchainCount: uint32_t, pSwapchains: *const VkSwapchainKHR, pMetadata: *const VkHdrMetadataEXT) -> ();


/// `vkSetLatencyMarkerNV`
pub type PFN_vkSetLatencyMarkerNV = Option<FN_vkSetLatencyMarkerNV>;

/// `vkSetLatencyMarkerNV`
pub type FN_vkSetLatencyMarkerNV = unsafe extern "system" fn(device: VkDevice, swapchain: VkSwapchainKHR, pLatencyMarkerInfo: *const VkSetLatencyMarkerInfoNV) -> ();


/// `vkSetLatencySleepModeNV`
pub type PFN_vkSetLatencySleepModeNV = Option<FN_vkSetLatencySleepModeNV>;

/// `vkSetLatencySleepModeNV`
pub type FN_vkSetLatencySleepModeNV = unsafe extern "system" fn(device: VkDevice, swapchain: VkSwapchainKHR, pSleepModeInfo: *const VkLatencySleepModeInfoNV) -> VkResult;


/// `vkSetLocalDimmingAMD`
pub type PFN_vkSetLocalDimmingAMD = Option<FN_vkSetLocalDimmingAMD>;

/// `vkSetLocalDimmingAMD`
pub type FN_vkSetLocalDimmingAMD = unsafe extern "system" fn(device: VkDevice, swapChain: VkSwapchainKHR, localDimmingEnable: VkBool32) -> ();


/// `vkSetPrivateData`
pub type PFN_vkSetPrivateData = Option<FN_vkSetPrivateData>;

/// `vkSetPrivateData`
pub type FN_vkSetPrivateData = unsafe extern "system" fn(device: VkDevice, objectType: VkObjectType, objectHandle: uint64_t, privateDataSlot: VkPrivateDataSlot, data: uint64_t) -> VkResult;


/// `vkSetPrivateDataEXT` = `vkSetPrivateData`
pub type PFN_vkSetPrivateDataEXT = PFN_vkSetPrivateData;

/// `vkSetPrivateDataEXT` = `vkSetPrivateData`
pub type FN_vkSetPrivateDataEXT = FN_vkSetPrivateData;

/// `vkSetSwapchainPresentTimingQueueSizeEXT`
pub type PFN_vkSetSwapchainPresentTimingQueueSizeEXT = Option<FN_vkSetSwapchainPresentTimingQueueSizeEXT>;

/// `vkSetSwapchainPresentTimingQueueSizeEXT`
pub type FN_vkSetSwapchainPresentTimingQueueSizeEXT = unsafe extern "system" fn(device: VkDevice, swapchain: VkSwapchainKHR, size: uint32_t) -> VkResult;


/// `vkSignalSemaphore`
pub type PFN_vkSignalSemaphore = Option<FN_vkSignalSemaphore>;

/// `vkSignalSemaphore`
pub type FN_vkSignalSemaphore = unsafe extern "system" fn(device: VkDevice, pSignalInfo: *const VkSemaphoreSignalInfo) -> VkResult;


/// `vkSignalSemaphoreKHR` = `vkSignalSemaphore`
pub type PFN_vkSignalSemaphoreKHR = PFN_vkSignalSemaphore;

/// `vkSignalSemaphoreKHR` = `vkSignalSemaphore`
pub type FN_vkSignalSemaphoreKHR = FN_vkSignalSemaphore;

/// `vkSubmitDebugUtilsMessageEXT`
pub type PFN_vkSubmitDebugUtilsMessageEXT = Option<FN_vkSubmitDebugUtilsMessageEXT>;

/// `vkSubmitDebugUtilsMessageEXT`
pub type FN_vkSubmitDebugUtilsMessageEXT = unsafe extern "system" fn(instance: VkInstance, messageSeverity: VkDebugUtilsMessageSeverityFlagsEXT, messageTypes: VkDebugUtilsMessageTypeFlagsEXT, pCallbackData: *const VkDebugUtilsMessengerCallbackDataEXT) -> ();


/// `vkTransitionImageLayout`
pub type PFN_vkTransitionImageLayout = Option<FN_vkTransitionImageLayout>;

/// `vkTransitionImageLayout`
pub type FN_vkTransitionImageLayout = unsafe extern "system" fn(device: VkDevice, transitionCount: uint32_t, pTransitions: *const VkHostImageLayoutTransitionInfo) -> VkResult;


/// `vkTransitionImageLayoutEXT` = `vkTransitionImageLayout`
pub type PFN_vkTransitionImageLayoutEXT = PFN_vkTransitionImageLayout;

/// `vkTransitionImageLayoutEXT` = `vkTransitionImageLayout`
pub type FN_vkTransitionImageLayoutEXT = FN_vkTransitionImageLayout;

/// `vkTrimCommandPool`
pub type PFN_vkTrimCommandPool = Option<FN_vkTrimCommandPool>;

/// `vkTrimCommandPool`
pub type FN_vkTrimCommandPool = unsafe extern "system" fn(device: VkDevice, commandPool: VkCommandPool, flags: VkCommandPoolTrimFlags) -> ();


/// `vkTrimCommandPoolKHR` = `vkTrimCommandPool`
pub type PFN_vkTrimCommandPoolKHR = PFN_vkTrimCommandPool;

/// `vkTrimCommandPoolKHR` = `vkTrimCommandPool`
pub type FN_vkTrimCommandPoolKHR = FN_vkTrimCommandPool;

/// `vkUninitializePerformanceApiINTEL`
pub type PFN_vkUninitializePerformanceApiINTEL = Option<FN_vkUninitializePerformanceApiINTEL>;

/// `vkUninitializePerformanceApiINTEL`
pub type FN_vkUninitializePerformanceApiINTEL = unsafe extern "system" fn(device: VkDevice) -> ();


/// `vkUnmapMemory`
pub type PFN_vkUnmapMemory = Option<FN_vkUnmapMemory>;

/// `vkUnmapMemory`
pub type FN_vkUnmapMemory = unsafe extern "system" fn(device: VkDevice, memory: VkDeviceMemory) -> ();


/// `vkUnmapMemory2`
pub type PFN_vkUnmapMemory2 = Option<FN_vkUnmapMemory2>;

/// `vkUnmapMemory2`
pub type FN_vkUnmapMemory2 = unsafe extern "system" fn(device: VkDevice, pMemoryUnmapInfo: *const VkMemoryUnmapInfo) -> VkResult;


/// `vkUnmapMemory2KHR` = `vkUnmapMemory2`
pub type PFN_vkUnmapMemory2KHR = PFN_vkUnmapMemory2;

/// `vkUnmapMemory2KHR` = `vkUnmapMemory2`
pub type FN_vkUnmapMemory2KHR = FN_vkUnmapMemory2;

/// `vkUnregisterCustomBorderColorEXT`
pub type PFN_vkUnregisterCustomBorderColorEXT = Option<FN_vkUnregisterCustomBorderColorEXT>;

/// `vkUnregisterCustomBorderColorEXT`
pub type FN_vkUnregisterCustomBorderColorEXT = unsafe extern "system" fn(device: VkDevice, index: uint32_t) -> ();


/// `vkUpdateDescriptorSets`
pub type PFN_vkUpdateDescriptorSets = Option<FN_vkUpdateDescriptorSets>;

/// `vkUpdateDescriptorSets`
pub type FN_vkUpdateDescriptorSets = unsafe extern "system" fn(device: VkDevice, descriptorWriteCount: uint32_t, pDescriptorWrites: *const VkWriteDescriptorSet, descriptorCopyCount: uint32_t, pDescriptorCopies: *const VkCopyDescriptorSet) -> ();


/// `vkUpdateDescriptorSetWithTemplate`
pub type PFN_vkUpdateDescriptorSetWithTemplate = Option<FN_vkUpdateDescriptorSetWithTemplate>;

/// `vkUpdateDescriptorSetWithTemplate`
pub type FN_vkUpdateDescriptorSetWithTemplate = unsafe extern "system" fn(device: VkDevice, descriptorSet: VkDescriptorSet, descriptorUpdateTemplate: VkDescriptorUpdateTemplate, pData: *const void) -> ();


/// `vkUpdateDescriptorSetWithTemplateKHR` = `vkUpdateDescriptorSetWithTemplate`
pub type PFN_vkUpdateDescriptorSetWithTemplateKHR = PFN_vkUpdateDescriptorSetWithTemplate;

/// `vkUpdateDescriptorSetWithTemplateKHR` = `vkUpdateDescriptorSetWithTemplate`
pub type FN_vkUpdateDescriptorSetWithTemplateKHR = FN_vkUpdateDescriptorSetWithTemplate;

/// `vkUpdateIndirectExecutionSetPipelineEXT`
pub type PFN_vkUpdateIndirectExecutionSetPipelineEXT = Option<FN_vkUpdateIndirectExecutionSetPipelineEXT>;

/// `vkUpdateIndirectExecutionSetPipelineEXT`
pub type FN_vkUpdateIndirectExecutionSetPipelineEXT = unsafe extern "system" fn(device: VkDevice, indirectExecutionSet: VkIndirectExecutionSetEXT, executionSetWriteCount: uint32_t, pExecutionSetWrites: *const VkWriteIndirectExecutionSetPipelineEXT) -> ();


/// `vkUpdateIndirectExecutionSetShaderEXT`
pub type PFN_vkUpdateIndirectExecutionSetShaderEXT = Option<FN_vkUpdateIndirectExecutionSetShaderEXT>;

/// `vkUpdateIndirectExecutionSetShaderEXT`
pub type FN_vkUpdateIndirectExecutionSetShaderEXT = unsafe extern "system" fn(device: VkDevice, indirectExecutionSet: VkIndirectExecutionSetEXT, executionSetWriteCount: uint32_t, pExecutionSetWrites: *const VkWriteIndirectExecutionSetShaderEXT) -> ();


/// `vkUpdateVideoSessionParametersKHR`
pub type PFN_vkUpdateVideoSessionParametersKHR = Option<FN_vkUpdateVideoSessionParametersKHR>;

/// `vkUpdateVideoSessionParametersKHR`
pub type FN_vkUpdateVideoSessionParametersKHR = unsafe extern "system" fn(device: VkDevice, videoSessionParameters: VkVideoSessionParametersKHR, pUpdateInfo: *const VkVideoSessionParametersUpdateInfoKHR) -> VkResult;


/// `vkWaitForFences`
pub type PFN_vkWaitForFences = Option<FN_vkWaitForFences>;

/// `vkWaitForFences`
pub type FN_vkWaitForFences = unsafe extern "system" fn(device: VkDevice, fenceCount: uint32_t, pFences: *const VkFence, waitAll: VkBool32, timeout: uint64_t) -> VkResult;


/// `vkWaitForPresent2KHR`
pub type PFN_vkWaitForPresent2KHR = Option<FN_vkWaitForPresent2KHR>;

/// `vkWaitForPresent2KHR`
pub type FN_vkWaitForPresent2KHR = unsafe extern "system" fn(device: VkDevice, swapchain: VkSwapchainKHR, pPresentWait2Info: *const VkPresentWait2InfoKHR) -> VkResult;


/// `vkWaitForPresentKHR`
pub type PFN_vkWaitForPresentKHR = Option<FN_vkWaitForPresentKHR>;

/// `vkWaitForPresentKHR`
pub type FN_vkWaitForPresentKHR = unsafe extern "system" fn(device: VkDevice, swapchain: VkSwapchainKHR, presentId: uint64_t, timeout: uint64_t) -> VkResult;


/// `vkWaitSemaphores`
pub type PFN_vkWaitSemaphores = Option<FN_vkWaitSemaphores>;

/// `vkWaitSemaphores`
pub type FN_vkWaitSemaphores = unsafe extern "system" fn(device: VkDevice, pWaitInfo: *const VkSemaphoreWaitInfo, timeout: uint64_t) -> VkResult;


/// `vkWaitSemaphoresKHR` = `vkWaitSemaphores`
pub type PFN_vkWaitSemaphoresKHR = PFN_vkWaitSemaphores;

/// `vkWaitSemaphoresKHR` = `vkWaitSemaphores`
pub type FN_vkWaitSemaphoresKHR = FN_vkWaitSemaphores;

/// `vkWriteAccelerationStructuresPropertiesKHR`
pub type PFN_vkWriteAccelerationStructuresPropertiesKHR = Option<FN_vkWriteAccelerationStructuresPropertiesKHR>;

/// `vkWriteAccelerationStructuresPropertiesKHR`
pub type FN_vkWriteAccelerationStructuresPropertiesKHR = unsafe extern "system" fn(device: VkDevice, accelerationStructureCount: uint32_t, pAccelerationStructures: *const VkAccelerationStructureKHR, queryType: VkQueryType, dataSize: size_t, pData: *mut void, stride: size_t) -> VkResult;


/// `vkWriteMicromapsPropertiesEXT`
pub type PFN_vkWriteMicromapsPropertiesEXT = Option<FN_vkWriteMicromapsPropertiesEXT>;

/// `vkWriteMicromapsPropertiesEXT`
pub type FN_vkWriteMicromapsPropertiesEXT = unsafe extern "system" fn(device: VkDevice, micromapCount: uint32_t, pMicromaps: *const VkMicromapEXT, queryType: VkQueryType, dataSize: size_t, pData: *mut void, stride: size_t) -> VkResult;


/// `vkWriteResourceDescriptorsEXT`
pub type PFN_vkWriteResourceDescriptorsEXT = Option<FN_vkWriteResourceDescriptorsEXT>;

/// `vkWriteResourceDescriptorsEXT`
pub type FN_vkWriteResourceDescriptorsEXT = unsafe extern "system" fn(device: VkDevice, resourceCount: uint32_t, pResources: *const VkResourceDescriptorInfoEXT, pDescriptors: *const VkHostAddressRangeEXT) -> VkResult;


/// `vkWriteSamplerDescriptorsEXT`
pub type PFN_vkWriteSamplerDescriptorsEXT = Option<FN_vkWriteSamplerDescriptorsEXT>;

/// `vkWriteSamplerDescriptorsEXT`
pub type FN_vkWriteSamplerDescriptorsEXT = unsafe extern "system" fn(device: VkDevice, samplerCount: uint32_t, pSamplers: *const VkSamplerCreateInfo, pDescriptors: *const VkHostAddressRangeEXT) -> VkResult;


pub(crate) mod vtbl_gen {
    use core::ffi::CStr;
    use crate::loader::{ProcAddr, LoadingError};
    use crate::vtbl::*;
    use crate::ffi::*;
    use crate::*;

    /// `Vulkan 1.0` InstanceCommands
    #[derive(Debug, Clone, Copy)]
    pub struct InstanceCommands_1_0 {
        pub vkCreateDevice: PFN_vkCreateDevice,
        pub vkDestroyInstance: PFN_vkDestroyInstance,
        pub vkEnumerateDeviceExtensionProperties: PFN_vkEnumerateDeviceExtensionProperties,
        pub vkEnumerateDeviceLayerProperties: PFN_vkEnumerateDeviceLayerProperties,
        pub vkEnumeratePhysicalDevices: PFN_vkEnumeratePhysicalDevices,
        pub vkGetDeviceProcAddr: PFN_vkGetDeviceProcAddr,
        pub vkGetInstanceProcAddr: PFN_vkGetInstanceProcAddr,
        pub vkGetPhysicalDeviceFeatures: PFN_vkGetPhysicalDeviceFeatures,
        pub vkGetPhysicalDeviceFormatProperties: PFN_vkGetPhysicalDeviceFormatProperties,
        pub vkGetPhysicalDeviceImageFormatProperties: PFN_vkGetPhysicalDeviceImageFormatProperties,
        pub vkGetPhysicalDeviceMemoryProperties: PFN_vkGetPhysicalDeviceMemoryProperties,
        pub vkGetPhysicalDeviceProperties: PFN_vkGetPhysicalDeviceProperties,
        pub vkGetPhysicalDeviceQueueFamilyProperties: PFN_vkGetPhysicalDeviceQueueFamilyProperties,
        pub vkGetPhysicalDeviceSparseImageFormatProperties: PFN_vkGetPhysicalDeviceSparseImageFormatProperties,
    }

    impl InstanceCommands_1_0 {
        pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
            unsafe { Self {
                vkCreateDevice: get(c!("vkCreateDevice")).map(|a| a.cast()),
                vkDestroyInstance: get(c!("vkDestroyInstance")).map(|a| a.cast()),
                vkEnumerateDeviceExtensionProperties: get(c!("vkEnumerateDeviceExtensionProperties")).map(|a| a.cast()),
                vkEnumerateDeviceLayerProperties: get(c!("vkEnumerateDeviceLayerProperties")).map(|a| a.cast()),
                vkEnumeratePhysicalDevices: get(c!("vkEnumeratePhysicalDevices")).map(|a| a.cast()),
                vkGetDeviceProcAddr: get(c!("vkGetDeviceProcAddr")).map(|a| a.cast()),
                vkGetInstanceProcAddr: get(c!("vkGetInstanceProcAddr")).map(|a| a.cast()),
                vkGetPhysicalDeviceFeatures: get(c!("vkGetPhysicalDeviceFeatures")).map(|a| a.cast()),
                vkGetPhysicalDeviceFormatProperties: get(c!("vkGetPhysicalDeviceFormatProperties")).map(|a| a.cast()),
                vkGetPhysicalDeviceImageFormatProperties: get(c!("vkGetPhysicalDeviceImageFormatProperties")).map(|a| a.cast()),
                vkGetPhysicalDeviceMemoryProperties: get(c!("vkGetPhysicalDeviceMemoryProperties")).map(|a| a.cast()),
                vkGetPhysicalDeviceProperties: get(c!("vkGetPhysicalDeviceProperties")).map(|a| a.cast()),
                vkGetPhysicalDeviceQueueFamilyProperties: get(c!("vkGetPhysicalDeviceQueueFamilyProperties")).map(|a| a.cast()),
                vkGetPhysicalDeviceSparseImageFormatProperties: get(c!("vkGetPhysicalDeviceSparseImageFormatProperties")).map(|a| a.cast()),
            } }
        }
    }

    impl InstanceCommands_1_0 {
        /// `vkCreateDevice`
        pub unsafe fn CreateDevice(&self, physicalDevice: VkPhysicalDevice, pCreateInfo: *const VkDeviceCreateInfo, pAllocator: *const VkAllocationCallbacks, pDevice: *mut VkDevice) -> VkResult {
            unsafe { (self.vkCreateDevice.expect("Unable to load vkCreateDevice"))(physicalDevice, pCreateInfo, pAllocator, pDevice) }
        }
        /// `vkDestroyInstance`
        pub unsafe fn DestroyInstance(&self, instance: VkInstance, pAllocator: *const VkAllocationCallbacks) -> () {
            unsafe { (self.vkDestroyInstance.expect("Unable to load vkDestroyInstance"))(instance, pAllocator) }
        }
        /// `vkEnumerateDeviceExtensionProperties`
        pub unsafe fn EnumerateDeviceExtensionProperties(&self, physicalDevice: VkPhysicalDevice, pLayerName: *const c_char, pPropertyCount: *mut uint32_t, pProperties: *mut VkExtensionProperties) -> VkResult {
            unsafe { (self.vkEnumerateDeviceExtensionProperties.expect("Unable to load vkEnumerateDeviceExtensionProperties"))(physicalDevice, pLayerName, pPropertyCount, pProperties) }
        }
        /// `vkEnumerateDeviceLayerProperties`
        pub unsafe fn EnumerateDeviceLayerProperties(&self, physicalDevice: VkPhysicalDevice, pPropertyCount: *mut uint32_t, pProperties: *mut VkLayerProperties) -> VkResult {
            unsafe { (self.vkEnumerateDeviceLayerProperties.expect("Unable to load vkEnumerateDeviceLayerProperties"))(physicalDevice, pPropertyCount, pProperties) }
        }
        /// `vkEnumeratePhysicalDevices`
        pub unsafe fn EnumeratePhysicalDevices(&self, instance: VkInstance, pPhysicalDeviceCount: *mut uint32_t, pPhysicalDevices: *mut VkPhysicalDevice) -> VkResult {
            unsafe { (self.vkEnumeratePhysicalDevices.expect("Unable to load vkEnumeratePhysicalDevices"))(instance, pPhysicalDeviceCount, pPhysicalDevices) }
        }
        /// `vkGetPhysicalDeviceFeatures`
        pub unsafe fn GetPhysicalDeviceFeatures(&self, physicalDevice: VkPhysicalDevice, pFeatures: *mut VkPhysicalDeviceFeatures) -> () {
            unsafe { (self.vkGetPhysicalDeviceFeatures.expect("Unable to load vkGetPhysicalDeviceFeatures"))(physicalDevice, pFeatures) }
        }
        /// `vkGetPhysicalDeviceFormatProperties`
        pub unsafe fn GetPhysicalDeviceFormatProperties(&self, physicalDevice: VkPhysicalDevice, format: VkFormat, pFormatProperties: *mut VkFormatProperties) -> () {
            unsafe { (self.vkGetPhysicalDeviceFormatProperties.expect("Unable to load vkGetPhysicalDeviceFormatProperties"))(physicalDevice, format, pFormatProperties) }
        }
        /// `vkGetPhysicalDeviceImageFormatProperties`
        pub unsafe fn GetPhysicalDeviceImageFormatProperties(&self, physicalDevice: VkPhysicalDevice, format: VkFormat, r#type: VkImageType, tiling: VkImageTiling, usage: VkImageUsageFlags, flags: VkImageCreateFlags, pImageFormatProperties: *mut VkImageFormatProperties) -> VkResult {
            unsafe { (self.vkGetPhysicalDeviceImageFormatProperties.expect("Unable to load vkGetPhysicalDeviceImageFormatProperties"))(physicalDevice, format, r#type, tiling, usage, flags, pImageFormatProperties) }
        }
        /// `vkGetPhysicalDeviceMemoryProperties`
        pub unsafe fn GetPhysicalDeviceMemoryProperties(&self, physicalDevice: VkPhysicalDevice, pMemoryProperties: *mut VkPhysicalDeviceMemoryProperties) -> () {
            unsafe { (self.vkGetPhysicalDeviceMemoryProperties.expect("Unable to load vkGetPhysicalDeviceMemoryProperties"))(physicalDevice, pMemoryProperties) }
        }
        /// `vkGetPhysicalDeviceProperties`
        pub unsafe fn GetPhysicalDeviceProperties(&self, physicalDevice: VkPhysicalDevice, pProperties: *mut VkPhysicalDeviceProperties) -> () {
            unsafe { (self.vkGetPhysicalDeviceProperties.expect("Unable to load vkGetPhysicalDeviceProperties"))(physicalDevice, pProperties) }
        }
        /// `vkGetPhysicalDeviceQueueFamilyProperties`
        pub unsafe fn GetPhysicalDeviceQueueFamilyProperties(&self, physicalDevice: VkPhysicalDevice, pQueueFamilyPropertyCount: *mut uint32_t, pQueueFamilyProperties: *mut VkQueueFamilyProperties) -> () {
            unsafe { (self.vkGetPhysicalDeviceQueueFamilyProperties.expect("Unable to load vkGetPhysicalDeviceQueueFamilyProperties"))(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties) }
        }
        /// `vkGetPhysicalDeviceSparseImageFormatProperties`
        pub unsafe fn GetPhysicalDeviceSparseImageFormatProperties(&self, physicalDevice: VkPhysicalDevice, format: VkFormat, r#type: VkImageType, samples: VkSampleCountFlags, usage: VkImageUsageFlags, tiling: VkImageTiling, pPropertyCount: *mut uint32_t, pProperties: *mut VkSparseImageFormatProperties) -> () {
            unsafe { (self.vkGetPhysicalDeviceSparseImageFormatProperties.expect("Unable to load vkGetPhysicalDeviceSparseImageFormatProperties"))(physicalDevice, format, r#type, samples, usage, tiling, pPropertyCount, pProperties) }
        }
    }

    /// `Vulkan 1.0` DeviceCommands
    #[derive(Debug, Clone, Copy)]
    pub struct DeviceCommands_1_0 {
        pub vkAllocateCommandBuffers: PFN_vkAllocateCommandBuffers,
        pub vkAllocateDescriptorSets: PFN_vkAllocateDescriptorSets,
        pub vkAllocateMemory: PFN_vkAllocateMemory,
        pub vkBeginCommandBuffer: PFN_vkBeginCommandBuffer,
        pub vkBindBufferMemory: PFN_vkBindBufferMemory,
        pub vkBindImageMemory: PFN_vkBindImageMemory,
        pub vkCmdBeginQuery: PFN_vkCmdBeginQuery,
        pub vkCmdBeginRenderPass: PFN_vkCmdBeginRenderPass,
        pub vkCmdBindDescriptorSets: PFN_vkCmdBindDescriptorSets,
        pub vkCmdBindIndexBuffer: PFN_vkCmdBindIndexBuffer,
        pub vkCmdBindPipeline: PFN_vkCmdBindPipeline,
        pub vkCmdBindVertexBuffers: PFN_vkCmdBindVertexBuffers,
        pub vkCmdBlitImage: PFN_vkCmdBlitImage,
        pub vkCmdClearAttachments: PFN_vkCmdClearAttachments,
        pub vkCmdClearColorImage: PFN_vkCmdClearColorImage,
        pub vkCmdClearDepthStencilImage: PFN_vkCmdClearDepthStencilImage,
        pub vkCmdCopyBuffer: PFN_vkCmdCopyBuffer,
        pub vkCmdCopyBufferToImage: PFN_vkCmdCopyBufferToImage,
        pub vkCmdCopyImage: PFN_vkCmdCopyImage,
        pub vkCmdCopyImageToBuffer: PFN_vkCmdCopyImageToBuffer,
        pub vkCmdCopyQueryPoolResults: PFN_vkCmdCopyQueryPoolResults,
        pub vkCmdDispatch: PFN_vkCmdDispatch,
        pub vkCmdDispatchIndirect: PFN_vkCmdDispatchIndirect,
        pub vkCmdDraw: PFN_vkCmdDraw,
        pub vkCmdDrawIndexed: PFN_vkCmdDrawIndexed,
        pub vkCmdDrawIndexedIndirect: PFN_vkCmdDrawIndexedIndirect,
        pub vkCmdDrawIndirect: PFN_vkCmdDrawIndirect,
        pub vkCmdEndQuery: PFN_vkCmdEndQuery,
        pub vkCmdEndRenderPass: PFN_vkCmdEndRenderPass,
        pub vkCmdExecuteCommands: PFN_vkCmdExecuteCommands,
        pub vkCmdFillBuffer: PFN_vkCmdFillBuffer,
        pub vkCmdNextSubpass: PFN_vkCmdNextSubpass,
        pub vkCmdPipelineBarrier: PFN_vkCmdPipelineBarrier,
        pub vkCmdPushConstants: PFN_vkCmdPushConstants,
        pub vkCmdResetEvent: PFN_vkCmdResetEvent,
        pub vkCmdResetQueryPool: PFN_vkCmdResetQueryPool,
        pub vkCmdResolveImage: PFN_vkCmdResolveImage,
        pub vkCmdSetBlendConstants: PFN_vkCmdSetBlendConstants,
        pub vkCmdSetDepthBias: PFN_vkCmdSetDepthBias,
        pub vkCmdSetDepthBounds: PFN_vkCmdSetDepthBounds,
        pub vkCmdSetEvent: PFN_vkCmdSetEvent,
        pub vkCmdSetLineWidth: PFN_vkCmdSetLineWidth,
        pub vkCmdSetScissor: PFN_vkCmdSetScissor,
        pub vkCmdSetStencilCompareMask: PFN_vkCmdSetStencilCompareMask,
        pub vkCmdSetStencilReference: PFN_vkCmdSetStencilReference,
        pub vkCmdSetStencilWriteMask: PFN_vkCmdSetStencilWriteMask,
        pub vkCmdSetViewport: PFN_vkCmdSetViewport,
        pub vkCmdUpdateBuffer: PFN_vkCmdUpdateBuffer,
        pub vkCmdWaitEvents: PFN_vkCmdWaitEvents,
        pub vkCmdWriteTimestamp: PFN_vkCmdWriteTimestamp,
        pub vkCreateBuffer: PFN_vkCreateBuffer,
        pub vkCreateBufferView: PFN_vkCreateBufferView,
        pub vkCreateCommandPool: PFN_vkCreateCommandPool,
        pub vkCreateComputePipelines: PFN_vkCreateComputePipelines,
        pub vkCreateDescriptorPool: PFN_vkCreateDescriptorPool,
        pub vkCreateDescriptorSetLayout: PFN_vkCreateDescriptorSetLayout,
        pub vkCreateEvent: PFN_vkCreateEvent,
        pub vkCreateFence: PFN_vkCreateFence,
        pub vkCreateFramebuffer: PFN_vkCreateFramebuffer,
        pub vkCreateGraphicsPipelines: PFN_vkCreateGraphicsPipelines,
        pub vkCreateImage: PFN_vkCreateImage,
        pub vkCreateImageView: PFN_vkCreateImageView,
        pub vkCreatePipelineCache: PFN_vkCreatePipelineCache,
        pub vkCreatePipelineLayout: PFN_vkCreatePipelineLayout,
        pub vkCreateQueryPool: PFN_vkCreateQueryPool,
        pub vkCreateRenderPass: PFN_vkCreateRenderPass,
        pub vkCreateSampler: PFN_vkCreateSampler,
        pub vkCreateSemaphore: PFN_vkCreateSemaphore,
        pub vkCreateShaderModule: PFN_vkCreateShaderModule,
        pub vkDestroyBuffer: PFN_vkDestroyBuffer,
        pub vkDestroyBufferView: PFN_vkDestroyBufferView,
        pub vkDestroyCommandPool: PFN_vkDestroyCommandPool,
        pub vkDestroyDescriptorPool: PFN_vkDestroyDescriptorPool,
        pub vkDestroyDescriptorSetLayout: PFN_vkDestroyDescriptorSetLayout,
        pub vkDestroyDevice: PFN_vkDestroyDevice,
        pub vkDestroyEvent: PFN_vkDestroyEvent,
        pub vkDestroyFence: PFN_vkDestroyFence,
        pub vkDestroyFramebuffer: PFN_vkDestroyFramebuffer,
        pub vkDestroyImage: PFN_vkDestroyImage,
        pub vkDestroyImageView: PFN_vkDestroyImageView,
        pub vkDestroyPipeline: PFN_vkDestroyPipeline,
        pub vkDestroyPipelineCache: PFN_vkDestroyPipelineCache,
        pub vkDestroyPipelineLayout: PFN_vkDestroyPipelineLayout,
        pub vkDestroyQueryPool: PFN_vkDestroyQueryPool,
        pub vkDestroyRenderPass: PFN_vkDestroyRenderPass,
        pub vkDestroySampler: PFN_vkDestroySampler,
        pub vkDestroySemaphore: PFN_vkDestroySemaphore,
        pub vkDestroyShaderModule: PFN_vkDestroyShaderModule,
        pub vkDeviceWaitIdle: PFN_vkDeviceWaitIdle,
        pub vkEndCommandBuffer: PFN_vkEndCommandBuffer,
        pub vkFlushMappedMemoryRanges: PFN_vkFlushMappedMemoryRanges,
        pub vkFreeCommandBuffers: PFN_vkFreeCommandBuffers,
        pub vkFreeDescriptorSets: PFN_vkFreeDescriptorSets,
        pub vkFreeMemory: PFN_vkFreeMemory,
        pub vkGetBufferMemoryRequirements: PFN_vkGetBufferMemoryRequirements,
        pub vkGetDeviceMemoryCommitment: PFN_vkGetDeviceMemoryCommitment,
        pub vkGetDeviceQueue: PFN_vkGetDeviceQueue,
        pub vkGetEventStatus: PFN_vkGetEventStatus,
        pub vkGetFenceStatus: PFN_vkGetFenceStatus,
        pub vkGetImageMemoryRequirements: PFN_vkGetImageMemoryRequirements,
        pub vkGetImageSparseMemoryRequirements: PFN_vkGetImageSparseMemoryRequirements,
        pub vkGetImageSubresourceLayout: PFN_vkGetImageSubresourceLayout,
        pub vkGetPipelineCacheData: PFN_vkGetPipelineCacheData,
        pub vkGetQueryPoolResults: PFN_vkGetQueryPoolResults,
        pub vkGetRenderAreaGranularity: PFN_vkGetRenderAreaGranularity,
        pub vkInvalidateMappedMemoryRanges: PFN_vkInvalidateMappedMemoryRanges,
        pub vkMapMemory: PFN_vkMapMemory,
        pub vkMergePipelineCaches: PFN_vkMergePipelineCaches,
        pub vkQueueBindSparse: PFN_vkQueueBindSparse,
        pub vkQueueSubmit: PFN_vkQueueSubmit,
        pub vkQueueWaitIdle: PFN_vkQueueWaitIdle,
        pub vkResetCommandBuffer: PFN_vkResetCommandBuffer,
        pub vkResetCommandPool: PFN_vkResetCommandPool,
        pub vkResetDescriptorPool: PFN_vkResetDescriptorPool,
        pub vkResetEvent: PFN_vkResetEvent,
        pub vkResetFences: PFN_vkResetFences,
        pub vkSetEvent: PFN_vkSetEvent,
        pub vkUnmapMemory: PFN_vkUnmapMemory,
        pub vkUpdateDescriptorSets: PFN_vkUpdateDescriptorSets,
        pub vkWaitForFences: PFN_vkWaitForFences,
    }

    impl DeviceCommands_1_0 {
        pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
            unsafe { Self {
                vkAllocateCommandBuffers: get(c!("vkAllocateCommandBuffers")).map(|a| a.cast()),
                vkAllocateDescriptorSets: get(c!("vkAllocateDescriptorSets")).map(|a| a.cast()),
                vkAllocateMemory: get(c!("vkAllocateMemory")).map(|a| a.cast()),
                vkBeginCommandBuffer: get(c!("vkBeginCommandBuffer")).map(|a| a.cast()),
                vkBindBufferMemory: get(c!("vkBindBufferMemory")).map(|a| a.cast()),
                vkBindImageMemory: get(c!("vkBindImageMemory")).map(|a| a.cast()),
                vkCmdBeginQuery: get(c!("vkCmdBeginQuery")).map(|a| a.cast()),
                vkCmdBeginRenderPass: get(c!("vkCmdBeginRenderPass")).map(|a| a.cast()),
                vkCmdBindDescriptorSets: get(c!("vkCmdBindDescriptorSets")).map(|a| a.cast()),
                vkCmdBindIndexBuffer: get(c!("vkCmdBindIndexBuffer")).map(|a| a.cast()),
                vkCmdBindPipeline: get(c!("vkCmdBindPipeline")).map(|a| a.cast()),
                vkCmdBindVertexBuffers: get(c!("vkCmdBindVertexBuffers")).map(|a| a.cast()),
                vkCmdBlitImage: get(c!("vkCmdBlitImage")).map(|a| a.cast()),
                vkCmdClearAttachments: get(c!("vkCmdClearAttachments")).map(|a| a.cast()),
                vkCmdClearColorImage: get(c!("vkCmdClearColorImage")).map(|a| a.cast()),
                vkCmdClearDepthStencilImage: get(c!("vkCmdClearDepthStencilImage")).map(|a| a.cast()),
                vkCmdCopyBuffer: get(c!("vkCmdCopyBuffer")).map(|a| a.cast()),
                vkCmdCopyBufferToImage: get(c!("vkCmdCopyBufferToImage")).map(|a| a.cast()),
                vkCmdCopyImage: get(c!("vkCmdCopyImage")).map(|a| a.cast()),
                vkCmdCopyImageToBuffer: get(c!("vkCmdCopyImageToBuffer")).map(|a| a.cast()),
                vkCmdCopyQueryPoolResults: get(c!("vkCmdCopyQueryPoolResults")).map(|a| a.cast()),
                vkCmdDispatch: get(c!("vkCmdDispatch")).map(|a| a.cast()),
                vkCmdDispatchIndirect: get(c!("vkCmdDispatchIndirect")).map(|a| a.cast()),
                vkCmdDraw: get(c!("vkCmdDraw")).map(|a| a.cast()),
                vkCmdDrawIndexed: get(c!("vkCmdDrawIndexed")).map(|a| a.cast()),
                vkCmdDrawIndexedIndirect: get(c!("vkCmdDrawIndexedIndirect")).map(|a| a.cast()),
                vkCmdDrawIndirect: get(c!("vkCmdDrawIndirect")).map(|a| a.cast()),
                vkCmdEndQuery: get(c!("vkCmdEndQuery")).map(|a| a.cast()),
                vkCmdEndRenderPass: get(c!("vkCmdEndRenderPass")).map(|a| a.cast()),
                vkCmdExecuteCommands: get(c!("vkCmdExecuteCommands")).map(|a| a.cast()),
                vkCmdFillBuffer: get(c!("vkCmdFillBuffer")).map(|a| a.cast()),
                vkCmdNextSubpass: get(c!("vkCmdNextSubpass")).map(|a| a.cast()),
                vkCmdPipelineBarrier: get(c!("vkCmdPipelineBarrier")).map(|a| a.cast()),
                vkCmdPushConstants: get(c!("vkCmdPushConstants")).map(|a| a.cast()),
                vkCmdResetEvent: get(c!("vkCmdResetEvent")).map(|a| a.cast()),
                vkCmdResetQueryPool: get(c!("vkCmdResetQueryPool")).map(|a| a.cast()),
                vkCmdResolveImage: get(c!("vkCmdResolveImage")).map(|a| a.cast()),
                vkCmdSetBlendConstants: get(c!("vkCmdSetBlendConstants")).map(|a| a.cast()),
                vkCmdSetDepthBias: get(c!("vkCmdSetDepthBias")).map(|a| a.cast()),
                vkCmdSetDepthBounds: get(c!("vkCmdSetDepthBounds")).map(|a| a.cast()),
                vkCmdSetEvent: get(c!("vkCmdSetEvent")).map(|a| a.cast()),
                vkCmdSetLineWidth: get(c!("vkCmdSetLineWidth")).map(|a| a.cast()),
                vkCmdSetScissor: get(c!("vkCmdSetScissor")).map(|a| a.cast()),
                vkCmdSetStencilCompareMask: get(c!("vkCmdSetStencilCompareMask")).map(|a| a.cast()),
                vkCmdSetStencilReference: get(c!("vkCmdSetStencilReference")).map(|a| a.cast()),
                vkCmdSetStencilWriteMask: get(c!("vkCmdSetStencilWriteMask")).map(|a| a.cast()),
                vkCmdSetViewport: get(c!("vkCmdSetViewport")).map(|a| a.cast()),
                vkCmdUpdateBuffer: get(c!("vkCmdUpdateBuffer")).map(|a| a.cast()),
                vkCmdWaitEvents: get(c!("vkCmdWaitEvents")).map(|a| a.cast()),
                vkCmdWriteTimestamp: get(c!("vkCmdWriteTimestamp")).map(|a| a.cast()),
                vkCreateBuffer: get(c!("vkCreateBuffer")).map(|a| a.cast()),
                vkCreateBufferView: get(c!("vkCreateBufferView")).map(|a| a.cast()),
                vkCreateCommandPool: get(c!("vkCreateCommandPool")).map(|a| a.cast()),
                vkCreateComputePipelines: get(c!("vkCreateComputePipelines")).map(|a| a.cast()),
                vkCreateDescriptorPool: get(c!("vkCreateDescriptorPool")).map(|a| a.cast()),
                vkCreateDescriptorSetLayout: get(c!("vkCreateDescriptorSetLayout")).map(|a| a.cast()),
                vkCreateEvent: get(c!("vkCreateEvent")).map(|a| a.cast()),
                vkCreateFence: get(c!("vkCreateFence")).map(|a| a.cast()),
                vkCreateFramebuffer: get(c!("vkCreateFramebuffer")).map(|a| a.cast()),
                vkCreateGraphicsPipelines: get(c!("vkCreateGraphicsPipelines")).map(|a| a.cast()),
                vkCreateImage: get(c!("vkCreateImage")).map(|a| a.cast()),
                vkCreateImageView: get(c!("vkCreateImageView")).map(|a| a.cast()),
                vkCreatePipelineCache: get(c!("vkCreatePipelineCache")).map(|a| a.cast()),
                vkCreatePipelineLayout: get(c!("vkCreatePipelineLayout")).map(|a| a.cast()),
                vkCreateQueryPool: get(c!("vkCreateQueryPool")).map(|a| a.cast()),
                vkCreateRenderPass: get(c!("vkCreateRenderPass")).map(|a| a.cast()),
                vkCreateSampler: get(c!("vkCreateSampler")).map(|a| a.cast()),
                vkCreateSemaphore: get(c!("vkCreateSemaphore")).map(|a| a.cast()),
                vkCreateShaderModule: get(c!("vkCreateShaderModule")).map(|a| a.cast()),
                vkDestroyBuffer: get(c!("vkDestroyBuffer")).map(|a| a.cast()),
                vkDestroyBufferView: get(c!("vkDestroyBufferView")).map(|a| a.cast()),
                vkDestroyCommandPool: get(c!("vkDestroyCommandPool")).map(|a| a.cast()),
                vkDestroyDescriptorPool: get(c!("vkDestroyDescriptorPool")).map(|a| a.cast()),
                vkDestroyDescriptorSetLayout: get(c!("vkDestroyDescriptorSetLayout")).map(|a| a.cast()),
                vkDestroyDevice: get(c!("vkDestroyDevice")).map(|a| a.cast()),
                vkDestroyEvent: get(c!("vkDestroyEvent")).map(|a| a.cast()),
                vkDestroyFence: get(c!("vkDestroyFence")).map(|a| a.cast()),
                vkDestroyFramebuffer: get(c!("vkDestroyFramebuffer")).map(|a| a.cast()),
                vkDestroyImage: get(c!("vkDestroyImage")).map(|a| a.cast()),
                vkDestroyImageView: get(c!("vkDestroyImageView")).map(|a| a.cast()),
                vkDestroyPipeline: get(c!("vkDestroyPipeline")).map(|a| a.cast()),
                vkDestroyPipelineCache: get(c!("vkDestroyPipelineCache")).map(|a| a.cast()),
                vkDestroyPipelineLayout: get(c!("vkDestroyPipelineLayout")).map(|a| a.cast()),
                vkDestroyQueryPool: get(c!("vkDestroyQueryPool")).map(|a| a.cast()),
                vkDestroyRenderPass: get(c!("vkDestroyRenderPass")).map(|a| a.cast()),
                vkDestroySampler: get(c!("vkDestroySampler")).map(|a| a.cast()),
                vkDestroySemaphore: get(c!("vkDestroySemaphore")).map(|a| a.cast()),
                vkDestroyShaderModule: get(c!("vkDestroyShaderModule")).map(|a| a.cast()),
                vkDeviceWaitIdle: get(c!("vkDeviceWaitIdle")).map(|a| a.cast()),
                vkEndCommandBuffer: get(c!("vkEndCommandBuffer")).map(|a| a.cast()),
                vkFlushMappedMemoryRanges: get(c!("vkFlushMappedMemoryRanges")).map(|a| a.cast()),
                vkFreeCommandBuffers: get(c!("vkFreeCommandBuffers")).map(|a| a.cast()),
                vkFreeDescriptorSets: get(c!("vkFreeDescriptorSets")).map(|a| a.cast()),
                vkFreeMemory: get(c!("vkFreeMemory")).map(|a| a.cast()),
                vkGetBufferMemoryRequirements: get(c!("vkGetBufferMemoryRequirements")).map(|a| a.cast()),
                vkGetDeviceMemoryCommitment: get(c!("vkGetDeviceMemoryCommitment")).map(|a| a.cast()),
                vkGetDeviceQueue: get(c!("vkGetDeviceQueue")).map(|a| a.cast()),
                vkGetEventStatus: get(c!("vkGetEventStatus")).map(|a| a.cast()),
                vkGetFenceStatus: get(c!("vkGetFenceStatus")).map(|a| a.cast()),
                vkGetImageMemoryRequirements: get(c!("vkGetImageMemoryRequirements")).map(|a| a.cast()),
                vkGetImageSparseMemoryRequirements: get(c!("vkGetImageSparseMemoryRequirements")).map(|a| a.cast()),
                vkGetImageSubresourceLayout: get(c!("vkGetImageSubresourceLayout")).map(|a| a.cast()),
                vkGetPipelineCacheData: get(c!("vkGetPipelineCacheData")).map(|a| a.cast()),
                vkGetQueryPoolResults: get(c!("vkGetQueryPoolResults")).map(|a| a.cast()),
                vkGetRenderAreaGranularity: get(c!("vkGetRenderAreaGranularity")).map(|a| a.cast()),
                vkInvalidateMappedMemoryRanges: get(c!("vkInvalidateMappedMemoryRanges")).map(|a| a.cast()),
                vkMapMemory: get(c!("vkMapMemory")).map(|a| a.cast()),
                vkMergePipelineCaches: get(c!("vkMergePipelineCaches")).map(|a| a.cast()),
                vkQueueBindSparse: get(c!("vkQueueBindSparse")).map(|a| a.cast()),
                vkQueueSubmit: get(c!("vkQueueSubmit")).map(|a| a.cast()),
                vkQueueWaitIdle: get(c!("vkQueueWaitIdle")).map(|a| a.cast()),
                vkResetCommandBuffer: get(c!("vkResetCommandBuffer")).map(|a| a.cast()),
                vkResetCommandPool: get(c!("vkResetCommandPool")).map(|a| a.cast()),
                vkResetDescriptorPool: get(c!("vkResetDescriptorPool")).map(|a| a.cast()),
                vkResetEvent: get(c!("vkResetEvent")).map(|a| a.cast()),
                vkResetFences: get(c!("vkResetFences")).map(|a| a.cast()),
                vkSetEvent: get(c!("vkSetEvent")).map(|a| a.cast()),
                vkUnmapMemory: get(c!("vkUnmapMemory")).map(|a| a.cast()),
                vkUpdateDescriptorSets: get(c!("vkUpdateDescriptorSets")).map(|a| a.cast()),
                vkWaitForFences: get(c!("vkWaitForFences")).map(|a| a.cast()),
            } }
        }
    }

    impl DeviceCommands_1_0 {
        /// `vkAllocateCommandBuffers`
        pub unsafe fn AllocateCommandBuffers(&self, device: VkDevice, pAllocateInfo: *const VkCommandBufferAllocateInfo, pCommandBuffers: *mut VkCommandBuffer) -> VkResult {
            unsafe { (self.vkAllocateCommandBuffers.expect("Unable to load vkAllocateCommandBuffers"))(device, pAllocateInfo, pCommandBuffers) }
        }
        /// `vkAllocateDescriptorSets`
        pub unsafe fn AllocateDescriptorSets(&self, device: VkDevice, pAllocateInfo: *const VkDescriptorSetAllocateInfo, pDescriptorSets: *mut VkDescriptorSet) -> VkResult {
            unsafe { (self.vkAllocateDescriptorSets.expect("Unable to load vkAllocateDescriptorSets"))(device, pAllocateInfo, pDescriptorSets) }
        }
        /// `vkAllocateMemory`
        pub unsafe fn AllocateMemory(&self, device: VkDevice, pAllocateInfo: *const VkMemoryAllocateInfo, pAllocator: *const VkAllocationCallbacks, pMemory: *mut VkDeviceMemory) -> VkResult {
            unsafe { (self.vkAllocateMemory.expect("Unable to load vkAllocateMemory"))(device, pAllocateInfo, pAllocator, pMemory) }
        }
        /// `vkBeginCommandBuffer`
        pub unsafe fn BeginCommandBuffer(&self, commandBuffer: VkCommandBuffer, pBeginInfo: *const VkCommandBufferBeginInfo) -> VkResult {
            unsafe { (self.vkBeginCommandBuffer.expect("Unable to load vkBeginCommandBuffer"))(commandBuffer, pBeginInfo) }
        }
        /// `vkBindBufferMemory`
        pub unsafe fn BindBufferMemory(&self, device: VkDevice, buffer: VkBuffer, memory: VkDeviceMemory, memoryOffset: VkDeviceSize) -> VkResult {
            unsafe { (self.vkBindBufferMemory.expect("Unable to load vkBindBufferMemory"))(device, buffer, memory, memoryOffset) }
        }
        /// `vkBindImageMemory`
        pub unsafe fn BindImageMemory(&self, device: VkDevice, image: VkImage, memory: VkDeviceMemory, memoryOffset: VkDeviceSize) -> VkResult {
            unsafe { (self.vkBindImageMemory.expect("Unable to load vkBindImageMemory"))(device, image, memory, memoryOffset) }
        }
        /// `vkCmdBeginQuery`
        pub unsafe fn CmdBeginQuery(&self, commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, query: uint32_t, flags: VkQueryControlFlags) -> () {
            unsafe { (self.vkCmdBeginQuery.expect("Unable to load vkCmdBeginQuery"))(commandBuffer, queryPool, query, flags) }
        }
        /// `vkCmdBeginRenderPass`
        pub unsafe fn CmdBeginRenderPass(&self, commandBuffer: VkCommandBuffer, pRenderPassBegin: *const VkRenderPassBeginInfo, contents: VkSubpassContents) -> () {
            unsafe { (self.vkCmdBeginRenderPass.expect("Unable to load vkCmdBeginRenderPass"))(commandBuffer, pRenderPassBegin, contents) }
        }
        /// `vkCmdBindDescriptorSets`
        pub unsafe fn CmdBindDescriptorSets(&self, commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, layout: VkPipelineLayout, firstSet: uint32_t, descriptorSetCount: uint32_t, pDescriptorSets: *const VkDescriptorSet, dynamicOffsetCount: uint32_t, pDynamicOffsets: *const uint32_t) -> () {
            unsafe { (self.vkCmdBindDescriptorSets.expect("Unable to load vkCmdBindDescriptorSets"))(commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets) }
        }
        /// `vkCmdBindIndexBuffer`
        pub unsafe fn CmdBindIndexBuffer(&self, commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, indexType: VkIndexType) -> () {
            unsafe { (self.vkCmdBindIndexBuffer.expect("Unable to load vkCmdBindIndexBuffer"))(commandBuffer, buffer, offset, indexType) }
        }
        /// `vkCmdBindPipeline`
        pub unsafe fn CmdBindPipeline(&self, commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, pipeline: VkPipeline) -> () {
            unsafe { (self.vkCmdBindPipeline.expect("Unable to load vkCmdBindPipeline"))(commandBuffer, pipelineBindPoint, pipeline) }
        }
        /// `vkCmdBindVertexBuffers`
        pub unsafe fn CmdBindVertexBuffers(&self, commandBuffer: VkCommandBuffer, firstBinding: uint32_t, bindingCount: uint32_t, pBuffers: *const VkBuffer, pOffsets: *const VkDeviceSize) -> () {
            unsafe { (self.vkCmdBindVertexBuffers.expect("Unable to load vkCmdBindVertexBuffers"))(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets) }
        }
        /// `vkCmdBlitImage`
        pub unsafe fn CmdBlitImage(&self, commandBuffer: VkCommandBuffer, srcImage: VkImage, srcImageLayout: VkImageLayout, dstImage: VkImage, dstImageLayout: VkImageLayout, regionCount: uint32_t, pRegions: *const VkImageBlit, filter: VkFilter) -> () {
            unsafe { (self.vkCmdBlitImage.expect("Unable to load vkCmdBlitImage"))(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter) }
        }
        /// `vkCmdClearAttachments`
        pub unsafe fn CmdClearAttachments(&self, commandBuffer: VkCommandBuffer, attachmentCount: uint32_t, pAttachments: *const VkClearAttachment, rectCount: uint32_t, pRects: *const VkClearRect) -> () {
            unsafe { (self.vkCmdClearAttachments.expect("Unable to load vkCmdClearAttachments"))(commandBuffer, attachmentCount, pAttachments, rectCount, pRects) }
        }
        /// `vkCmdClearColorImage`
        pub unsafe fn CmdClearColorImage(&self, commandBuffer: VkCommandBuffer, image: VkImage, imageLayout: VkImageLayout, pColor: *const VkClearColorValue, rangeCount: uint32_t, pRanges: *const VkImageSubresourceRange) -> () {
            unsafe { (self.vkCmdClearColorImage.expect("Unable to load vkCmdClearColorImage"))(commandBuffer, image, imageLayout, pColor, rangeCount, pRanges) }
        }
        /// `vkCmdClearDepthStencilImage`
        pub unsafe fn CmdClearDepthStencilImage(&self, commandBuffer: VkCommandBuffer, image: VkImage, imageLayout: VkImageLayout, pDepthStencil: *const VkClearDepthStencilValue, rangeCount: uint32_t, pRanges: *const VkImageSubresourceRange) -> () {
            unsafe { (self.vkCmdClearDepthStencilImage.expect("Unable to load vkCmdClearDepthStencilImage"))(commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges) }
        }
        /// `vkCmdCopyBuffer`
        pub unsafe fn CmdCopyBuffer(&self, commandBuffer: VkCommandBuffer, srcBuffer: VkBuffer, dstBuffer: VkBuffer, regionCount: uint32_t, pRegions: *const VkBufferCopy) -> () {
            unsafe { (self.vkCmdCopyBuffer.expect("Unable to load vkCmdCopyBuffer"))(commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions) }
        }
        /// `vkCmdCopyBufferToImage`
        pub unsafe fn CmdCopyBufferToImage(&self, commandBuffer: VkCommandBuffer, srcBuffer: VkBuffer, dstImage: VkImage, dstImageLayout: VkImageLayout, regionCount: uint32_t, pRegions: *const VkBufferImageCopy) -> () {
            unsafe { (self.vkCmdCopyBufferToImage.expect("Unable to load vkCmdCopyBufferToImage"))(commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions) }
        }
        /// `vkCmdCopyImage`
        pub unsafe fn CmdCopyImage(&self, commandBuffer: VkCommandBuffer, srcImage: VkImage, srcImageLayout: VkImageLayout, dstImage: VkImage, dstImageLayout: VkImageLayout, regionCount: uint32_t, pRegions: *const VkImageCopy) -> () {
            unsafe { (self.vkCmdCopyImage.expect("Unable to load vkCmdCopyImage"))(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions) }
        }
        /// `vkCmdCopyImageToBuffer`
        pub unsafe fn CmdCopyImageToBuffer(&self, commandBuffer: VkCommandBuffer, srcImage: VkImage, srcImageLayout: VkImageLayout, dstBuffer: VkBuffer, regionCount: uint32_t, pRegions: *const VkBufferImageCopy) -> () {
            unsafe { (self.vkCmdCopyImageToBuffer.expect("Unable to load vkCmdCopyImageToBuffer"))(commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions) }
        }
        /// `vkCmdCopyQueryPoolResults`
        pub unsafe fn CmdCopyQueryPoolResults(&self, commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, firstQuery: uint32_t, queryCount: uint32_t, dstBuffer: VkBuffer, dstOffset: VkDeviceSize, stride: VkDeviceSize, flags: VkQueryResultFlags) -> () {
            unsafe { (self.vkCmdCopyQueryPoolResults.expect("Unable to load vkCmdCopyQueryPoolResults"))(commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags) }
        }
        /// `vkCmdDispatch`
        pub unsafe fn CmdDispatch(&self, commandBuffer: VkCommandBuffer, groupCountX: uint32_t, groupCountY: uint32_t, groupCountZ: uint32_t) -> () {
            unsafe { (self.vkCmdDispatch.expect("Unable to load vkCmdDispatch"))(commandBuffer, groupCountX, groupCountY, groupCountZ) }
        }
        /// `vkCmdDispatchIndirect`
        pub unsafe fn CmdDispatchIndirect(&self, commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize) -> () {
            unsafe { (self.vkCmdDispatchIndirect.expect("Unable to load vkCmdDispatchIndirect"))(commandBuffer, buffer, offset) }
        }
        /// `vkCmdDraw`
        pub unsafe fn CmdDraw(&self, commandBuffer: VkCommandBuffer, vertexCount: uint32_t, instanceCount: uint32_t, firstVertex: uint32_t, firstInstance: uint32_t) -> () {
            unsafe { (self.vkCmdDraw.expect("Unable to load vkCmdDraw"))(commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance) }
        }
        /// `vkCmdDrawIndexed`
        pub unsafe fn CmdDrawIndexed(&self, commandBuffer: VkCommandBuffer, indexCount: uint32_t, instanceCount: uint32_t, firstIndex: uint32_t, vertexOffset: int32_t, firstInstance: uint32_t) -> () {
            unsafe { (self.vkCmdDrawIndexed.expect("Unable to load vkCmdDrawIndexed"))(commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance) }
        }
        /// `vkCmdDrawIndexedIndirect`
        pub unsafe fn CmdDrawIndexedIndirect(&self, commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, drawCount: uint32_t, stride: uint32_t) -> () {
            unsafe { (self.vkCmdDrawIndexedIndirect.expect("Unable to load vkCmdDrawIndexedIndirect"))(commandBuffer, buffer, offset, drawCount, stride) }
        }
        /// `vkCmdDrawIndirect`
        pub unsafe fn CmdDrawIndirect(&self, commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, drawCount: uint32_t, stride: uint32_t) -> () {
            unsafe { (self.vkCmdDrawIndirect.expect("Unable to load vkCmdDrawIndirect"))(commandBuffer, buffer, offset, drawCount, stride) }
        }
        /// `vkCmdEndQuery`
        pub unsafe fn CmdEndQuery(&self, commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, query: uint32_t) -> () {
            unsafe { (self.vkCmdEndQuery.expect("Unable to load vkCmdEndQuery"))(commandBuffer, queryPool, query) }
        }
        /// `vkCmdEndRenderPass`
        pub unsafe fn CmdEndRenderPass(&self, commandBuffer: VkCommandBuffer) -> () {
            unsafe { (self.vkCmdEndRenderPass.expect("Unable to load vkCmdEndRenderPass"))(commandBuffer) }
        }
        /// `vkCmdExecuteCommands`
        pub unsafe fn CmdExecuteCommands(&self, commandBuffer: VkCommandBuffer, commandBufferCount: uint32_t, pCommandBuffers: *const VkCommandBuffer) -> () {
            unsafe { (self.vkCmdExecuteCommands.expect("Unable to load vkCmdExecuteCommands"))(commandBuffer, commandBufferCount, pCommandBuffers) }
        }
        /// `vkCmdFillBuffer`
        pub unsafe fn CmdFillBuffer(&self, commandBuffer: VkCommandBuffer, dstBuffer: VkBuffer, dstOffset: VkDeviceSize, size: VkDeviceSize, data: uint32_t) -> () {
            unsafe { (self.vkCmdFillBuffer.expect("Unable to load vkCmdFillBuffer"))(commandBuffer, dstBuffer, dstOffset, size, data) }
        }
        /// `vkCmdNextSubpass`
        pub unsafe fn CmdNextSubpass(&self, commandBuffer: VkCommandBuffer, contents: VkSubpassContents) -> () {
            unsafe { (self.vkCmdNextSubpass.expect("Unable to load vkCmdNextSubpass"))(commandBuffer, contents) }
        }
        /// `vkCmdPipelineBarrier`
        pub unsafe fn CmdPipelineBarrier(&self, commandBuffer: VkCommandBuffer, srcStageMask: VkPipelineStageFlags, dstStageMask: VkPipelineStageFlags, dependencyFlags: VkDependencyFlags, memoryBarrierCount: uint32_t, pMemoryBarriers: *const VkMemoryBarrier, bufferMemoryBarrierCount: uint32_t, pBufferMemoryBarriers: *const VkBufferMemoryBarrier, imageMemoryBarrierCount: uint32_t, pImageMemoryBarriers: *const VkImageMemoryBarrier) -> () {
            unsafe { (self.vkCmdPipelineBarrier.expect("Unable to load vkCmdPipelineBarrier"))(commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers) }
        }
        /// `vkCmdPushConstants`
        pub unsafe fn CmdPushConstants(&self, commandBuffer: VkCommandBuffer, layout: VkPipelineLayout, stageFlags: VkShaderStageFlags, offset: uint32_t, size: uint32_t, pValues: *const void) -> () {
            unsafe { (self.vkCmdPushConstants.expect("Unable to load vkCmdPushConstants"))(commandBuffer, layout, stageFlags, offset, size, pValues) }
        }
        /// `vkCmdResetEvent`
        pub unsafe fn CmdResetEvent(&self, commandBuffer: VkCommandBuffer, event: VkEvent, stageMask: VkPipelineStageFlags) -> () {
            unsafe { (self.vkCmdResetEvent.expect("Unable to load vkCmdResetEvent"))(commandBuffer, event, stageMask) }
        }
        /// `vkCmdResetQueryPool`
        pub unsafe fn CmdResetQueryPool(&self, commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, firstQuery: uint32_t, queryCount: uint32_t) -> () {
            unsafe { (self.vkCmdResetQueryPool.expect("Unable to load vkCmdResetQueryPool"))(commandBuffer, queryPool, firstQuery, queryCount) }
        }
        /// `vkCmdResolveImage`
        pub unsafe fn CmdResolveImage(&self, commandBuffer: VkCommandBuffer, srcImage: VkImage, srcImageLayout: VkImageLayout, dstImage: VkImage, dstImageLayout: VkImageLayout, regionCount: uint32_t, pRegions: *const VkImageResolve) -> () {
            unsafe { (self.vkCmdResolveImage.expect("Unable to load vkCmdResolveImage"))(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions) }
        }
        /// `vkCmdSetBlendConstants`
        pub unsafe fn CmdSetBlendConstants(&self, commandBuffer: VkCommandBuffer, blendConstants: *const float) -> () {
            unsafe { (self.vkCmdSetBlendConstants.expect("Unable to load vkCmdSetBlendConstants"))(commandBuffer, blendConstants) }
        }
        /// `vkCmdSetDepthBias`
        pub unsafe fn CmdSetDepthBias(&self, commandBuffer: VkCommandBuffer, depthBiasConstantFactor: float, depthBiasClamp: float, depthBiasSlopeFactor: float) -> () {
            unsafe { (self.vkCmdSetDepthBias.expect("Unable to load vkCmdSetDepthBias"))(commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor) }
        }
        /// `vkCmdSetDepthBounds`
        pub unsafe fn CmdSetDepthBounds(&self, commandBuffer: VkCommandBuffer, minDepthBounds: float, maxDepthBounds: float) -> () {
            unsafe { (self.vkCmdSetDepthBounds.expect("Unable to load vkCmdSetDepthBounds"))(commandBuffer, minDepthBounds, maxDepthBounds) }
        }
        /// `vkCmdSetEvent`
        pub unsafe fn CmdSetEvent(&self, commandBuffer: VkCommandBuffer, event: VkEvent, stageMask: VkPipelineStageFlags) -> () {
            unsafe { (self.vkCmdSetEvent.expect("Unable to load vkCmdSetEvent"))(commandBuffer, event, stageMask) }
        }
        /// `vkCmdSetLineWidth`
        pub unsafe fn CmdSetLineWidth(&self, commandBuffer: VkCommandBuffer, lineWidth: float) -> () {
            unsafe { (self.vkCmdSetLineWidth.expect("Unable to load vkCmdSetLineWidth"))(commandBuffer, lineWidth) }
        }
        /// `vkCmdSetScissor`
        pub unsafe fn CmdSetScissor(&self, commandBuffer: VkCommandBuffer, firstScissor: uint32_t, scissorCount: uint32_t, pScissors: *const VkRect2D) -> () {
            unsafe { (self.vkCmdSetScissor.expect("Unable to load vkCmdSetScissor"))(commandBuffer, firstScissor, scissorCount, pScissors) }
        }
        /// `vkCmdSetStencilCompareMask`
        pub unsafe fn CmdSetStencilCompareMask(&self, commandBuffer: VkCommandBuffer, faceMask: VkStencilFaceFlags, compareMask: uint32_t) -> () {
            unsafe { (self.vkCmdSetStencilCompareMask.expect("Unable to load vkCmdSetStencilCompareMask"))(commandBuffer, faceMask, compareMask) }
        }
        /// `vkCmdSetStencilReference`
        pub unsafe fn CmdSetStencilReference(&self, commandBuffer: VkCommandBuffer, faceMask: VkStencilFaceFlags, reference: uint32_t) -> () {
            unsafe { (self.vkCmdSetStencilReference.expect("Unable to load vkCmdSetStencilReference"))(commandBuffer, faceMask, reference) }
        }
        /// `vkCmdSetStencilWriteMask`
        pub unsafe fn CmdSetStencilWriteMask(&self, commandBuffer: VkCommandBuffer, faceMask: VkStencilFaceFlags, writeMask: uint32_t) -> () {
            unsafe { (self.vkCmdSetStencilWriteMask.expect("Unable to load vkCmdSetStencilWriteMask"))(commandBuffer, faceMask, writeMask) }
        }
        /// `vkCmdSetViewport`
        pub unsafe fn CmdSetViewport(&self, commandBuffer: VkCommandBuffer, firstViewport: uint32_t, viewportCount: uint32_t, pViewports: *const VkViewport) -> () {
            unsafe { (self.vkCmdSetViewport.expect("Unable to load vkCmdSetViewport"))(commandBuffer, firstViewport, viewportCount, pViewports) }
        }
        /// `vkCmdUpdateBuffer`
        pub unsafe fn CmdUpdateBuffer(&self, commandBuffer: VkCommandBuffer, dstBuffer: VkBuffer, dstOffset: VkDeviceSize, dataSize: VkDeviceSize, pData: *const void) -> () {
            unsafe { (self.vkCmdUpdateBuffer.expect("Unable to load vkCmdUpdateBuffer"))(commandBuffer, dstBuffer, dstOffset, dataSize, pData) }
        }
        /// `vkCmdWaitEvents`
        pub unsafe fn CmdWaitEvents(&self, commandBuffer: VkCommandBuffer, eventCount: uint32_t, pEvents: *const VkEvent, srcStageMask: VkPipelineStageFlags, dstStageMask: VkPipelineStageFlags, memoryBarrierCount: uint32_t, pMemoryBarriers: *const VkMemoryBarrier, bufferMemoryBarrierCount: uint32_t, pBufferMemoryBarriers: *const VkBufferMemoryBarrier, imageMemoryBarrierCount: uint32_t, pImageMemoryBarriers: *const VkImageMemoryBarrier) -> () {
            unsafe { (self.vkCmdWaitEvents.expect("Unable to load vkCmdWaitEvents"))(commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers) }
        }
        /// `vkCmdWriteTimestamp`
        pub unsafe fn CmdWriteTimestamp(&self, commandBuffer: VkCommandBuffer, pipelineStage: VkPipelineStageFlags, queryPool: VkQueryPool, query: uint32_t) -> () {
            unsafe { (self.vkCmdWriteTimestamp.expect("Unable to load vkCmdWriteTimestamp"))(commandBuffer, pipelineStage, queryPool, query) }
        }
        /// `vkCreateBuffer`
        pub unsafe fn CreateBuffer(&self, device: VkDevice, pCreateInfo: *const VkBufferCreateInfo, pAllocator: *const VkAllocationCallbacks, pBuffer: *mut VkBuffer) -> VkResult {
            unsafe { (self.vkCreateBuffer.expect("Unable to load vkCreateBuffer"))(device, pCreateInfo, pAllocator, pBuffer) }
        }
        /// `vkCreateBufferView`
        pub unsafe fn CreateBufferView(&self, device: VkDevice, pCreateInfo: *const VkBufferViewCreateInfo, pAllocator: *const VkAllocationCallbacks, pView: *mut VkBufferView) -> VkResult {
            unsafe { (self.vkCreateBufferView.expect("Unable to load vkCreateBufferView"))(device, pCreateInfo, pAllocator, pView) }
        }
        /// `vkCreateCommandPool`
        pub unsafe fn CreateCommandPool(&self, device: VkDevice, pCreateInfo: *const VkCommandPoolCreateInfo, pAllocator: *const VkAllocationCallbacks, pCommandPool: *mut VkCommandPool) -> VkResult {
            unsafe { (self.vkCreateCommandPool.expect("Unable to load vkCreateCommandPool"))(device, pCreateInfo, pAllocator, pCommandPool) }
        }
        /// `vkCreateComputePipelines`
        pub unsafe fn CreateComputePipelines(&self, device: VkDevice, pipelineCache: VkPipelineCache, createInfoCount: uint32_t, pCreateInfos: *const VkComputePipelineCreateInfo, pAllocator: *const VkAllocationCallbacks, pPipelines: *mut VkPipeline) -> VkResult {
            unsafe { (self.vkCreateComputePipelines.expect("Unable to load vkCreateComputePipelines"))(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines) }
        }
        /// `vkCreateDescriptorPool`
        pub unsafe fn CreateDescriptorPool(&self, device: VkDevice, pCreateInfo: *const VkDescriptorPoolCreateInfo, pAllocator: *const VkAllocationCallbacks, pDescriptorPool: *mut VkDescriptorPool) -> VkResult {
            unsafe { (self.vkCreateDescriptorPool.expect("Unable to load vkCreateDescriptorPool"))(device, pCreateInfo, pAllocator, pDescriptorPool) }
        }
        /// `vkCreateDescriptorSetLayout`
        pub unsafe fn CreateDescriptorSetLayout(&self, device: VkDevice, pCreateInfo: *const VkDescriptorSetLayoutCreateInfo, pAllocator: *const VkAllocationCallbacks, pSetLayout: *mut VkDescriptorSetLayout) -> VkResult {
            unsafe { (self.vkCreateDescriptorSetLayout.expect("Unable to load vkCreateDescriptorSetLayout"))(device, pCreateInfo, pAllocator, pSetLayout) }
        }
        /// `vkCreateEvent`
        pub unsafe fn CreateEvent(&self, device: VkDevice, pCreateInfo: *const VkEventCreateInfo, pAllocator: *const VkAllocationCallbacks, pEvent: *mut VkEvent) -> VkResult {
            unsafe { (self.vkCreateEvent.expect("Unable to load vkCreateEvent"))(device, pCreateInfo, pAllocator, pEvent) }
        }
        /// `vkCreateFence`
        pub unsafe fn CreateFence(&self, device: VkDevice, pCreateInfo: *const VkFenceCreateInfo, pAllocator: *const VkAllocationCallbacks, pFence: *mut VkFence) -> VkResult {
            unsafe { (self.vkCreateFence.expect("Unable to load vkCreateFence"))(device, pCreateInfo, pAllocator, pFence) }
        }
        /// `vkCreateFramebuffer`
        pub unsafe fn CreateFramebuffer(&self, device: VkDevice, pCreateInfo: *const VkFramebufferCreateInfo, pAllocator: *const VkAllocationCallbacks, pFramebuffer: *mut VkFramebuffer) -> VkResult {
            unsafe { (self.vkCreateFramebuffer.expect("Unable to load vkCreateFramebuffer"))(device, pCreateInfo, pAllocator, pFramebuffer) }
        }
        /// `vkCreateGraphicsPipelines`
        pub unsafe fn CreateGraphicsPipelines(&self, device: VkDevice, pipelineCache: VkPipelineCache, createInfoCount: uint32_t, pCreateInfos: *const VkGraphicsPipelineCreateInfo, pAllocator: *const VkAllocationCallbacks, pPipelines: *mut VkPipeline) -> VkResult {
            unsafe { (self.vkCreateGraphicsPipelines.expect("Unable to load vkCreateGraphicsPipelines"))(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines) }
        }
        /// `vkCreateImage`
        pub unsafe fn CreateImage(&self, device: VkDevice, pCreateInfo: *const VkImageCreateInfo, pAllocator: *const VkAllocationCallbacks, pImage: *mut VkImage) -> VkResult {
            unsafe { (self.vkCreateImage.expect("Unable to load vkCreateImage"))(device, pCreateInfo, pAllocator, pImage) }
        }
        /// `vkCreateImageView`
        pub unsafe fn CreateImageView(&self, device: VkDevice, pCreateInfo: *const VkImageViewCreateInfo, pAllocator: *const VkAllocationCallbacks, pView: *mut VkImageView) -> VkResult {
            unsafe { (self.vkCreateImageView.expect("Unable to load vkCreateImageView"))(device, pCreateInfo, pAllocator, pView) }
        }
        /// `vkCreatePipelineCache`
        pub unsafe fn CreatePipelineCache(&self, device: VkDevice, pCreateInfo: *const VkPipelineCacheCreateInfo, pAllocator: *const VkAllocationCallbacks, pPipelineCache: *mut VkPipelineCache) -> VkResult {
            unsafe { (self.vkCreatePipelineCache.expect("Unable to load vkCreatePipelineCache"))(device, pCreateInfo, pAllocator, pPipelineCache) }
        }
        /// `vkCreatePipelineLayout`
        pub unsafe fn CreatePipelineLayout(&self, device: VkDevice, pCreateInfo: *const VkPipelineLayoutCreateInfo, pAllocator: *const VkAllocationCallbacks, pPipelineLayout: *mut VkPipelineLayout) -> VkResult {
            unsafe { (self.vkCreatePipelineLayout.expect("Unable to load vkCreatePipelineLayout"))(device, pCreateInfo, pAllocator, pPipelineLayout) }
        }
        /// `vkCreateQueryPool`
        pub unsafe fn CreateQueryPool(&self, device: VkDevice, pCreateInfo: *const VkQueryPoolCreateInfo, pAllocator: *const VkAllocationCallbacks, pQueryPool: *mut VkQueryPool) -> VkResult {
            unsafe { (self.vkCreateQueryPool.expect("Unable to load vkCreateQueryPool"))(device, pCreateInfo, pAllocator, pQueryPool) }
        }
        /// `vkCreateRenderPass`
        pub unsafe fn CreateRenderPass(&self, device: VkDevice, pCreateInfo: *const VkRenderPassCreateInfo, pAllocator: *const VkAllocationCallbacks, pRenderPass: *mut VkRenderPass) -> VkResult {
            unsafe { (self.vkCreateRenderPass.expect("Unable to load vkCreateRenderPass"))(device, pCreateInfo, pAllocator, pRenderPass) }
        }
        /// `vkCreateSampler`
        pub unsafe fn CreateSampler(&self, device: VkDevice, pCreateInfo: *const VkSamplerCreateInfo, pAllocator: *const VkAllocationCallbacks, pSampler: *mut VkSampler) -> VkResult {
            unsafe { (self.vkCreateSampler.expect("Unable to load vkCreateSampler"))(device, pCreateInfo, pAllocator, pSampler) }
        }
        /// `vkCreateSemaphore`
        pub unsafe fn CreateSemaphore(&self, device: VkDevice, pCreateInfo: *const VkSemaphoreCreateInfo, pAllocator: *const VkAllocationCallbacks, pSemaphore: *mut VkSemaphore) -> VkResult {
            unsafe { (self.vkCreateSemaphore.expect("Unable to load vkCreateSemaphore"))(device, pCreateInfo, pAllocator, pSemaphore) }
        }
        /// `vkCreateShaderModule`
        pub unsafe fn CreateShaderModule(&self, device: VkDevice, pCreateInfo: *const VkShaderModuleCreateInfo, pAllocator: *const VkAllocationCallbacks, pShaderModule: *mut VkShaderModule) -> VkResult {
            unsafe { (self.vkCreateShaderModule.expect("Unable to load vkCreateShaderModule"))(device, pCreateInfo, pAllocator, pShaderModule) }
        }
        /// `vkDestroyBuffer`
        pub unsafe fn DestroyBuffer(&self, device: VkDevice, buffer: VkBuffer, pAllocator: *const VkAllocationCallbacks) -> () {
            unsafe { (self.vkDestroyBuffer.expect("Unable to load vkDestroyBuffer"))(device, buffer, pAllocator) }
        }
        /// `vkDestroyBufferView`
        pub unsafe fn DestroyBufferView(&self, device: VkDevice, bufferView: VkBufferView, pAllocator: *const VkAllocationCallbacks) -> () {
            unsafe { (self.vkDestroyBufferView.expect("Unable to load vkDestroyBufferView"))(device, bufferView, pAllocator) }
        }
        /// `vkDestroyCommandPool`
        pub unsafe fn DestroyCommandPool(&self, device: VkDevice, commandPool: VkCommandPool, pAllocator: *const VkAllocationCallbacks) -> () {
            unsafe { (self.vkDestroyCommandPool.expect("Unable to load vkDestroyCommandPool"))(device, commandPool, pAllocator) }
        }
        /// `vkDestroyDescriptorPool`
        pub unsafe fn DestroyDescriptorPool(&self, device: VkDevice, descriptorPool: VkDescriptorPool, pAllocator: *const VkAllocationCallbacks) -> () {
            unsafe { (self.vkDestroyDescriptorPool.expect("Unable to load vkDestroyDescriptorPool"))(device, descriptorPool, pAllocator) }
        }
        /// `vkDestroyDescriptorSetLayout`
        pub unsafe fn DestroyDescriptorSetLayout(&self, device: VkDevice, descriptorSetLayout: VkDescriptorSetLayout, pAllocator: *const VkAllocationCallbacks) -> () {
            unsafe { (self.vkDestroyDescriptorSetLayout.expect("Unable to load vkDestroyDescriptorSetLayout"))(device, descriptorSetLayout, pAllocator) }
        }
        /// `vkDestroyDevice`
        pub unsafe fn DestroyDevice(&self, device: VkDevice, pAllocator: *const VkAllocationCallbacks) -> () {
            unsafe { (self.vkDestroyDevice.expect("Unable to load vkDestroyDevice"))(device, pAllocator) }
        }
        /// `vkDestroyEvent`
        pub unsafe fn DestroyEvent(&self, device: VkDevice, event: VkEvent, pAllocator: *const VkAllocationCallbacks) -> () {
            unsafe { (self.vkDestroyEvent.expect("Unable to load vkDestroyEvent"))(device, event, pAllocator) }
        }
        /// `vkDestroyFence`
        pub unsafe fn DestroyFence(&self, device: VkDevice, fence: VkFence, pAllocator: *const VkAllocationCallbacks) -> () {
            unsafe { (self.vkDestroyFence.expect("Unable to load vkDestroyFence"))(device, fence, pAllocator) }
        }
        /// `vkDestroyFramebuffer`
        pub unsafe fn DestroyFramebuffer(&self, device: VkDevice, framebuffer: VkFramebuffer, pAllocator: *const VkAllocationCallbacks) -> () {
            unsafe { (self.vkDestroyFramebuffer.expect("Unable to load vkDestroyFramebuffer"))(device, framebuffer, pAllocator) }
        }
        /// `vkDestroyImage`
        pub unsafe fn DestroyImage(&self, device: VkDevice, image: VkImage, pAllocator: *const VkAllocationCallbacks) -> () {
            unsafe { (self.vkDestroyImage.expect("Unable to load vkDestroyImage"))(device, image, pAllocator) }
        }
        /// `vkDestroyImageView`
        pub unsafe fn DestroyImageView(&self, device: VkDevice, imageView: VkImageView, pAllocator: *const VkAllocationCallbacks) -> () {
            unsafe { (self.vkDestroyImageView.expect("Unable to load vkDestroyImageView"))(device, imageView, pAllocator) }
        }
        /// `vkDestroyPipeline`
        pub unsafe fn DestroyPipeline(&self, device: VkDevice, pipeline: VkPipeline, pAllocator: *const VkAllocationCallbacks) -> () {
            unsafe { (self.vkDestroyPipeline.expect("Unable to load vkDestroyPipeline"))(device, pipeline, pAllocator) }
        }
        /// `vkDestroyPipelineCache`
        pub unsafe fn DestroyPipelineCache(&self, device: VkDevice, pipelineCache: VkPipelineCache, pAllocator: *const VkAllocationCallbacks) -> () {
            unsafe { (self.vkDestroyPipelineCache.expect("Unable to load vkDestroyPipelineCache"))(device, pipelineCache, pAllocator) }
        }
        /// `vkDestroyPipelineLayout`
        pub unsafe fn DestroyPipelineLayout(&self, device: VkDevice, pipelineLayout: VkPipelineLayout, pAllocator: *const VkAllocationCallbacks) -> () {
            unsafe { (self.vkDestroyPipelineLayout.expect("Unable to load vkDestroyPipelineLayout"))(device, pipelineLayout, pAllocator) }
        }
        /// `vkDestroyQueryPool`
        pub unsafe fn DestroyQueryPool(&self, device: VkDevice, queryPool: VkQueryPool, pAllocator: *const VkAllocationCallbacks) -> () {
            unsafe { (self.vkDestroyQueryPool.expect("Unable to load vkDestroyQueryPool"))(device, queryPool, pAllocator) }
        }
        /// `vkDestroyRenderPass`
        pub unsafe fn DestroyRenderPass(&self, device: VkDevice, renderPass: VkRenderPass, pAllocator: *const VkAllocationCallbacks) -> () {
            unsafe { (self.vkDestroyRenderPass.expect("Unable to load vkDestroyRenderPass"))(device, renderPass, pAllocator) }
        }
        /// `vkDestroySampler`
        pub unsafe fn DestroySampler(&self, device: VkDevice, sampler: VkSampler, pAllocator: *const VkAllocationCallbacks) -> () {
            unsafe { (self.vkDestroySampler.expect("Unable to load vkDestroySampler"))(device, sampler, pAllocator) }
        }
        /// `vkDestroySemaphore`
        pub unsafe fn DestroySemaphore(&self, device: VkDevice, semaphore: VkSemaphore, pAllocator: *const VkAllocationCallbacks) -> () {
            unsafe { (self.vkDestroySemaphore.expect("Unable to load vkDestroySemaphore"))(device, semaphore, pAllocator) }
        }
        /// `vkDestroyShaderModule`
        pub unsafe fn DestroyShaderModule(&self, device: VkDevice, shaderModule: VkShaderModule, pAllocator: *const VkAllocationCallbacks) -> () {
            unsafe { (self.vkDestroyShaderModule.expect("Unable to load vkDestroyShaderModule"))(device, shaderModule, pAllocator) }
        }
        /// `vkDeviceWaitIdle`
        pub unsafe fn DeviceWaitIdle(&self, device: VkDevice) -> VkResult {
            unsafe { (self.vkDeviceWaitIdle.expect("Unable to load vkDeviceWaitIdle"))(device) }
        }
        /// `vkEndCommandBuffer`
        pub unsafe fn EndCommandBuffer(&self, commandBuffer: VkCommandBuffer) -> VkResult {
            unsafe { (self.vkEndCommandBuffer.expect("Unable to load vkEndCommandBuffer"))(commandBuffer) }
        }
        /// `vkFlushMappedMemoryRanges`
        pub unsafe fn FlushMappedMemoryRanges(&self, device: VkDevice, memoryRangeCount: uint32_t, pMemoryRanges: *const VkMappedMemoryRange) -> VkResult {
            unsafe { (self.vkFlushMappedMemoryRanges.expect("Unable to load vkFlushMappedMemoryRanges"))(device, memoryRangeCount, pMemoryRanges) }
        }
        /// `vkFreeCommandBuffers`
        pub unsafe fn FreeCommandBuffers(&self, device: VkDevice, commandPool: VkCommandPool, commandBufferCount: uint32_t, pCommandBuffers: *const VkCommandBuffer) -> () {
            unsafe { (self.vkFreeCommandBuffers.expect("Unable to load vkFreeCommandBuffers"))(device, commandPool, commandBufferCount, pCommandBuffers) }
        }
        /// `vkFreeDescriptorSets`
        pub unsafe fn FreeDescriptorSets(&self, device: VkDevice, descriptorPool: VkDescriptorPool, descriptorSetCount: uint32_t, pDescriptorSets: *const VkDescriptorSet) -> VkResult {
            unsafe { (self.vkFreeDescriptorSets.expect("Unable to load vkFreeDescriptorSets"))(device, descriptorPool, descriptorSetCount, pDescriptorSets) }
        }
        /// `vkFreeMemory`
        pub unsafe fn FreeMemory(&self, device: VkDevice, memory: VkDeviceMemory, pAllocator: *const VkAllocationCallbacks) -> () {
            unsafe { (self.vkFreeMemory.expect("Unable to load vkFreeMemory"))(device, memory, pAllocator) }
        }
        /// `vkGetBufferMemoryRequirements`
        pub unsafe fn GetBufferMemoryRequirements(&self, device: VkDevice, buffer: VkBuffer, pMemoryRequirements: *mut VkMemoryRequirements) -> () {
            unsafe { (self.vkGetBufferMemoryRequirements.expect("Unable to load vkGetBufferMemoryRequirements"))(device, buffer, pMemoryRequirements) }
        }
        /// `vkGetDeviceMemoryCommitment`
        pub unsafe fn GetDeviceMemoryCommitment(&self, device: VkDevice, memory: VkDeviceMemory, pCommittedMemoryInBytes: *mut VkDeviceSize) -> () {
            unsafe { (self.vkGetDeviceMemoryCommitment.expect("Unable to load vkGetDeviceMemoryCommitment"))(device, memory, pCommittedMemoryInBytes) }
        }
        /// `vkGetDeviceQueue`
        pub unsafe fn GetDeviceQueue(&self, device: VkDevice, queueFamilyIndex: uint32_t, queueIndex: uint32_t, pQueue: *mut VkQueue) -> () {
            unsafe { (self.vkGetDeviceQueue.expect("Unable to load vkGetDeviceQueue"))(device, queueFamilyIndex, queueIndex, pQueue) }
        }
        /// `vkGetEventStatus`
        pub unsafe fn GetEventStatus(&self, device: VkDevice, event: VkEvent) -> VkResult {
            unsafe { (self.vkGetEventStatus.expect("Unable to load vkGetEventStatus"))(device, event) }
        }
        /// `vkGetFenceStatus`
        pub unsafe fn GetFenceStatus(&self, device: VkDevice, fence: VkFence) -> VkResult {
            unsafe { (self.vkGetFenceStatus.expect("Unable to load vkGetFenceStatus"))(device, fence) }
        }
        /// `vkGetImageMemoryRequirements`
        pub unsafe fn GetImageMemoryRequirements(&self, device: VkDevice, image: VkImage, pMemoryRequirements: *mut VkMemoryRequirements) -> () {
            unsafe { (self.vkGetImageMemoryRequirements.expect("Unable to load vkGetImageMemoryRequirements"))(device, image, pMemoryRequirements) }
        }
        /// `vkGetImageSparseMemoryRequirements`
        pub unsafe fn GetImageSparseMemoryRequirements(&self, device: VkDevice, image: VkImage, pSparseMemoryRequirementCount: *mut uint32_t, pSparseMemoryRequirements: *mut VkSparseImageMemoryRequirements) -> () {
            unsafe { (self.vkGetImageSparseMemoryRequirements.expect("Unable to load vkGetImageSparseMemoryRequirements"))(device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements) }
        }
        /// `vkGetImageSubresourceLayout`
        pub unsafe fn GetImageSubresourceLayout(&self, device: VkDevice, image: VkImage, pSubresource: *const VkImageSubresource, pLayout: *mut VkSubresourceLayout) -> () {
            unsafe { (self.vkGetImageSubresourceLayout.expect("Unable to load vkGetImageSubresourceLayout"))(device, image, pSubresource, pLayout) }
        }
        /// `vkGetPipelineCacheData`
        pub unsafe fn GetPipelineCacheData(&self, device: VkDevice, pipelineCache: VkPipelineCache, pDataSize: *mut size_t, pData: *mut void) -> VkResult {
            unsafe { (self.vkGetPipelineCacheData.expect("Unable to load vkGetPipelineCacheData"))(device, pipelineCache, pDataSize, pData) }
        }
        /// `vkGetQueryPoolResults`
        pub unsafe fn GetQueryPoolResults(&self, device: VkDevice, queryPool: VkQueryPool, firstQuery: uint32_t, queryCount: uint32_t, dataSize: size_t, pData: *mut void, stride: VkDeviceSize, flags: VkQueryResultFlags) -> VkResult {
            unsafe { (self.vkGetQueryPoolResults.expect("Unable to load vkGetQueryPoolResults"))(device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags) }
        }
        /// `vkGetRenderAreaGranularity`
        pub unsafe fn GetRenderAreaGranularity(&self, device: VkDevice, renderPass: VkRenderPass, pGranularity: *mut VkExtent2D) -> () {
            unsafe { (self.vkGetRenderAreaGranularity.expect("Unable to load vkGetRenderAreaGranularity"))(device, renderPass, pGranularity) }
        }
        /// `vkInvalidateMappedMemoryRanges`
        pub unsafe fn InvalidateMappedMemoryRanges(&self, device: VkDevice, memoryRangeCount: uint32_t, pMemoryRanges: *const VkMappedMemoryRange) -> VkResult {
            unsafe { (self.vkInvalidateMappedMemoryRanges.expect("Unable to load vkInvalidateMappedMemoryRanges"))(device, memoryRangeCount, pMemoryRanges) }
        }
        /// `vkMapMemory`
        pub unsafe fn MapMemory(&self, device: VkDevice, memory: VkDeviceMemory, offset: VkDeviceSize, size: VkDeviceSize, flags: VkMemoryMapFlags, ppData: *mut *mut void) -> VkResult {
            unsafe { (self.vkMapMemory.expect("Unable to load vkMapMemory"))(device, memory, offset, size, flags, ppData) }
        }
        /// `vkMergePipelineCaches`
        pub unsafe fn MergePipelineCaches(&self, device: VkDevice, dstCache: VkPipelineCache, srcCacheCount: uint32_t, pSrcCaches: *const VkPipelineCache) -> VkResult {
            unsafe { (self.vkMergePipelineCaches.expect("Unable to load vkMergePipelineCaches"))(device, dstCache, srcCacheCount, pSrcCaches) }
        }
        /// `vkQueueBindSparse`
        pub unsafe fn QueueBindSparse(&self, queue: VkQueue, bindInfoCount: uint32_t, pBindInfo: *const VkBindSparseInfo, fence: VkFence) -> VkResult {
            unsafe { (self.vkQueueBindSparse.expect("Unable to load vkQueueBindSparse"))(queue, bindInfoCount, pBindInfo, fence) }
        }
        /// `vkQueueSubmit`
        pub unsafe fn QueueSubmit(&self, queue: VkQueue, submitCount: uint32_t, pSubmits: *const VkSubmitInfo, fence: VkFence) -> VkResult {
            unsafe { (self.vkQueueSubmit.expect("Unable to load vkQueueSubmit"))(queue, submitCount, pSubmits, fence) }
        }
        /// `vkQueueWaitIdle`
        pub unsafe fn QueueWaitIdle(&self, queue: VkQueue) -> VkResult {
            unsafe { (self.vkQueueWaitIdle.expect("Unable to load vkQueueWaitIdle"))(queue) }
        }
        /// `vkResetCommandBuffer`
        pub unsafe fn ResetCommandBuffer(&self, commandBuffer: VkCommandBuffer, flags: VkCommandBufferResetFlags) -> VkResult {
            unsafe { (self.vkResetCommandBuffer.expect("Unable to load vkResetCommandBuffer"))(commandBuffer, flags) }
        }
        /// `vkResetCommandPool`
        pub unsafe fn ResetCommandPool(&self, device: VkDevice, commandPool: VkCommandPool, flags: VkCommandPoolResetFlags) -> VkResult {
            unsafe { (self.vkResetCommandPool.expect("Unable to load vkResetCommandPool"))(device, commandPool, flags) }
        }
        /// `vkResetDescriptorPool`
        pub unsafe fn ResetDescriptorPool(&self, device: VkDevice, descriptorPool: VkDescriptorPool, flags: VkDescriptorPoolResetFlags) -> VkResult {
            unsafe { (self.vkResetDescriptorPool.expect("Unable to load vkResetDescriptorPool"))(device, descriptorPool, flags) }
        }
        /// `vkResetEvent`
        pub unsafe fn ResetEvent(&self, device: VkDevice, event: VkEvent) -> VkResult {
            unsafe { (self.vkResetEvent.expect("Unable to load vkResetEvent"))(device, event) }
        }
        /// `vkResetFences`
        pub unsafe fn ResetFences(&self, device: VkDevice, fenceCount: uint32_t, pFences: *const VkFence) -> VkResult {
            unsafe { (self.vkResetFences.expect("Unable to load vkResetFences"))(device, fenceCount, pFences) }
        }
        /// `vkSetEvent`
        pub unsafe fn SetEvent(&self, device: VkDevice, event: VkEvent) -> VkResult {
            unsafe { (self.vkSetEvent.expect("Unable to load vkSetEvent"))(device, event) }
        }
        /// `vkUnmapMemory`
        pub unsafe fn UnmapMemory(&self, device: VkDevice, memory: VkDeviceMemory) -> () {
            unsafe { (self.vkUnmapMemory.expect("Unable to load vkUnmapMemory"))(device, memory) }
        }
        /// `vkUpdateDescriptorSets`
        pub unsafe fn UpdateDescriptorSets(&self, device: VkDevice, descriptorWriteCount: uint32_t, pDescriptorWrites: *const VkWriteDescriptorSet, descriptorCopyCount: uint32_t, pDescriptorCopies: *const VkCopyDescriptorSet) -> () {
            unsafe { (self.vkUpdateDescriptorSets.expect("Unable to load vkUpdateDescriptorSets"))(device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies) }
        }
        /// `vkWaitForFences`
        pub unsafe fn WaitForFences(&self, device: VkDevice, fenceCount: uint32_t, pFences: *const VkFence, waitAll: VkBool32, timeout: uint64_t) -> VkResult {
            unsafe { (self.vkWaitForFences.expect("Unable to load vkWaitForFences"))(device, fenceCount, pFences, waitAll, timeout) }
        }
    }

    /// `Vulkan 1.1` InstanceCommands
    #[derive(Debug, Clone, Copy)]
    pub struct InstanceCommands_1_1 {
        pub vkEnumeratePhysicalDeviceGroups: PFN_vkEnumeratePhysicalDeviceGroups,
        pub vkGetPhysicalDeviceExternalBufferProperties: PFN_vkGetPhysicalDeviceExternalBufferProperties,
        pub vkGetPhysicalDeviceExternalFenceProperties: PFN_vkGetPhysicalDeviceExternalFenceProperties,
        pub vkGetPhysicalDeviceExternalSemaphoreProperties: PFN_vkGetPhysicalDeviceExternalSemaphoreProperties,
        pub vkGetPhysicalDeviceFeatures2: PFN_vkGetPhysicalDeviceFeatures2,
        pub vkGetPhysicalDeviceFormatProperties2: PFN_vkGetPhysicalDeviceFormatProperties2,
        pub vkGetPhysicalDeviceImageFormatProperties2: PFN_vkGetPhysicalDeviceImageFormatProperties2,
        pub vkGetPhysicalDeviceMemoryProperties2: PFN_vkGetPhysicalDeviceMemoryProperties2,
        pub vkGetPhysicalDeviceProperties2: PFN_vkGetPhysicalDeviceProperties2,
        pub vkGetPhysicalDeviceQueueFamilyProperties2: PFN_vkGetPhysicalDeviceQueueFamilyProperties2,
        pub vkGetPhysicalDeviceSparseImageFormatProperties2: PFN_vkGetPhysicalDeviceSparseImageFormatProperties2,
    }

    impl InstanceCommands_1_1 {
        pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
            unsafe { Self {
                vkEnumeratePhysicalDeviceGroups: get(c!("vkEnumeratePhysicalDeviceGroups")).map(|a| a.cast()),
                vkGetPhysicalDeviceExternalBufferProperties: get(c!("vkGetPhysicalDeviceExternalBufferProperties")).map(|a| a.cast()),
                vkGetPhysicalDeviceExternalFenceProperties: get(c!("vkGetPhysicalDeviceExternalFenceProperties")).map(|a| a.cast()),
                vkGetPhysicalDeviceExternalSemaphoreProperties: get(c!("vkGetPhysicalDeviceExternalSemaphoreProperties")).map(|a| a.cast()),
                vkGetPhysicalDeviceFeatures2: get(c!("vkGetPhysicalDeviceFeatures2")).map(|a| a.cast()),
                vkGetPhysicalDeviceFormatProperties2: get(c!("vkGetPhysicalDeviceFormatProperties2")).map(|a| a.cast()),
                vkGetPhysicalDeviceImageFormatProperties2: get(c!("vkGetPhysicalDeviceImageFormatProperties2")).map(|a| a.cast()),
                vkGetPhysicalDeviceMemoryProperties2: get(c!("vkGetPhysicalDeviceMemoryProperties2")).map(|a| a.cast()),
                vkGetPhysicalDeviceProperties2: get(c!("vkGetPhysicalDeviceProperties2")).map(|a| a.cast()),
                vkGetPhysicalDeviceQueueFamilyProperties2: get(c!("vkGetPhysicalDeviceQueueFamilyProperties2")).map(|a| a.cast()),
                vkGetPhysicalDeviceSparseImageFormatProperties2: get(c!("vkGetPhysicalDeviceSparseImageFormatProperties2")).map(|a| a.cast()),
            } }
        }
    }

    impl InstanceCommands_1_1 {
        /// `vkEnumeratePhysicalDeviceGroups`
        pub unsafe fn EnumeratePhysicalDeviceGroups(&self, instance: VkInstance, pPhysicalDeviceGroupCount: *mut uint32_t, pPhysicalDeviceGroupProperties: *mut VkPhysicalDeviceGroupProperties) -> VkResult {
            unsafe { (self.vkEnumeratePhysicalDeviceGroups.expect("Unable to load vkEnumeratePhysicalDeviceGroups"))(instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties) }
        }
        /// `vkGetPhysicalDeviceExternalBufferProperties`
        pub unsafe fn GetPhysicalDeviceExternalBufferProperties(&self, physicalDevice: VkPhysicalDevice, pExternalBufferInfo: *const VkPhysicalDeviceExternalBufferInfo, pExternalBufferProperties: *mut VkExternalBufferProperties) -> () {
            unsafe { (self.vkGetPhysicalDeviceExternalBufferProperties.expect("Unable to load vkGetPhysicalDeviceExternalBufferProperties"))(physicalDevice, pExternalBufferInfo, pExternalBufferProperties) }
        }
        /// `vkGetPhysicalDeviceExternalFenceProperties`
        pub unsafe fn GetPhysicalDeviceExternalFenceProperties(&self, physicalDevice: VkPhysicalDevice, pExternalFenceInfo: *const VkPhysicalDeviceExternalFenceInfo, pExternalFenceProperties: *mut VkExternalFenceProperties) -> () {
            unsafe { (self.vkGetPhysicalDeviceExternalFenceProperties.expect("Unable to load vkGetPhysicalDeviceExternalFenceProperties"))(physicalDevice, pExternalFenceInfo, pExternalFenceProperties) }
        }
        /// `vkGetPhysicalDeviceExternalSemaphoreProperties`
        pub unsafe fn GetPhysicalDeviceExternalSemaphoreProperties(&self, physicalDevice: VkPhysicalDevice, pExternalSemaphoreInfo: *const VkPhysicalDeviceExternalSemaphoreInfo, pExternalSemaphoreProperties: *mut VkExternalSemaphoreProperties) -> () {
            unsafe { (self.vkGetPhysicalDeviceExternalSemaphoreProperties.expect("Unable to load vkGetPhysicalDeviceExternalSemaphoreProperties"))(physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties) }
        }
        /// `vkGetPhysicalDeviceFeatures2`
        pub unsafe fn GetPhysicalDeviceFeatures2(&self, physicalDevice: VkPhysicalDevice, pFeatures: *mut VkPhysicalDeviceFeatures2) -> () {
            unsafe { (self.vkGetPhysicalDeviceFeatures2.expect("Unable to load vkGetPhysicalDeviceFeatures2"))(physicalDevice, pFeatures) }
        }
        /// `vkGetPhysicalDeviceFormatProperties2`
        pub unsafe fn GetPhysicalDeviceFormatProperties2(&self, physicalDevice: VkPhysicalDevice, format: VkFormat, pFormatProperties: *mut VkFormatProperties2) -> () {
            unsafe { (self.vkGetPhysicalDeviceFormatProperties2.expect("Unable to load vkGetPhysicalDeviceFormatProperties2"))(physicalDevice, format, pFormatProperties) }
        }
        /// `vkGetPhysicalDeviceImageFormatProperties2`
        pub unsafe fn GetPhysicalDeviceImageFormatProperties2(&self, physicalDevice: VkPhysicalDevice, pImageFormatInfo: *const VkPhysicalDeviceImageFormatInfo2, pImageFormatProperties: *mut VkImageFormatProperties2) -> VkResult {
            unsafe { (self.vkGetPhysicalDeviceImageFormatProperties2.expect("Unable to load vkGetPhysicalDeviceImageFormatProperties2"))(physicalDevice, pImageFormatInfo, pImageFormatProperties) }
        }
        /// `vkGetPhysicalDeviceMemoryProperties2`
        pub unsafe fn GetPhysicalDeviceMemoryProperties2(&self, physicalDevice: VkPhysicalDevice, pMemoryProperties: *mut VkPhysicalDeviceMemoryProperties2) -> () {
            unsafe { (self.vkGetPhysicalDeviceMemoryProperties2.expect("Unable to load vkGetPhysicalDeviceMemoryProperties2"))(physicalDevice, pMemoryProperties) }
        }
        /// `vkGetPhysicalDeviceProperties2`
        pub unsafe fn GetPhysicalDeviceProperties2(&self, physicalDevice: VkPhysicalDevice, pProperties: *mut VkPhysicalDeviceProperties2) -> () {
            unsafe { (self.vkGetPhysicalDeviceProperties2.expect("Unable to load vkGetPhysicalDeviceProperties2"))(physicalDevice, pProperties) }
        }
        /// `vkGetPhysicalDeviceQueueFamilyProperties2`
        pub unsafe fn GetPhysicalDeviceQueueFamilyProperties2(&self, physicalDevice: VkPhysicalDevice, pQueueFamilyPropertyCount: *mut uint32_t, pQueueFamilyProperties: *mut VkQueueFamilyProperties2) -> () {
            unsafe { (self.vkGetPhysicalDeviceQueueFamilyProperties2.expect("Unable to load vkGetPhysicalDeviceQueueFamilyProperties2"))(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties) }
        }
        /// `vkGetPhysicalDeviceSparseImageFormatProperties2`
        pub unsafe fn GetPhysicalDeviceSparseImageFormatProperties2(&self, physicalDevice: VkPhysicalDevice, pFormatInfo: *const VkPhysicalDeviceSparseImageFormatInfo2, pPropertyCount: *mut uint32_t, pProperties: *mut VkSparseImageFormatProperties2) -> () {
            unsafe { (self.vkGetPhysicalDeviceSparseImageFormatProperties2.expect("Unable to load vkGetPhysicalDeviceSparseImageFormatProperties2"))(physicalDevice, pFormatInfo, pPropertyCount, pProperties) }
        }
    }

    /// `Vulkan 1.1` DeviceCommands
    #[derive(Debug, Clone, Copy)]
    pub struct DeviceCommands_1_1 {
        pub vkBindBufferMemory2: PFN_vkBindBufferMemory2,
        pub vkBindImageMemory2: PFN_vkBindImageMemory2,
        pub vkCmdDispatchBase: PFN_vkCmdDispatchBase,
        pub vkCmdSetDeviceMask: PFN_vkCmdSetDeviceMask,
        pub vkCreateDescriptorUpdateTemplate: PFN_vkCreateDescriptorUpdateTemplate,
        pub vkCreateSamplerYcbcrConversion: PFN_vkCreateSamplerYcbcrConversion,
        pub vkDestroyDescriptorUpdateTemplate: PFN_vkDestroyDescriptorUpdateTemplate,
        pub vkDestroySamplerYcbcrConversion: PFN_vkDestroySamplerYcbcrConversion,
        pub vkGetBufferMemoryRequirements2: PFN_vkGetBufferMemoryRequirements2,
        pub vkGetDescriptorSetLayoutSupport: PFN_vkGetDescriptorSetLayoutSupport,
        pub vkGetDeviceGroupPeerMemoryFeatures: PFN_vkGetDeviceGroupPeerMemoryFeatures,
        pub vkGetDeviceQueue2: PFN_vkGetDeviceQueue2,
        pub vkGetImageMemoryRequirements2: PFN_vkGetImageMemoryRequirements2,
        pub vkGetImageSparseMemoryRequirements2: PFN_vkGetImageSparseMemoryRequirements2,
        pub vkTrimCommandPool: PFN_vkTrimCommandPool,
        pub vkUpdateDescriptorSetWithTemplate: PFN_vkUpdateDescriptorSetWithTemplate,
    }

    impl DeviceCommands_1_1 {
        pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
            unsafe { Self {
                vkBindBufferMemory2: get(c!("vkBindBufferMemory2")).map(|a| a.cast()),
                vkBindImageMemory2: get(c!("vkBindImageMemory2")).map(|a| a.cast()),
                vkCmdDispatchBase: get(c!("vkCmdDispatchBase")).map(|a| a.cast()),
                vkCmdSetDeviceMask: get(c!("vkCmdSetDeviceMask")).map(|a| a.cast()),
                vkCreateDescriptorUpdateTemplate: get(c!("vkCreateDescriptorUpdateTemplate")).map(|a| a.cast()),
                vkCreateSamplerYcbcrConversion: get(c!("vkCreateSamplerYcbcrConversion")).map(|a| a.cast()),
                vkDestroyDescriptorUpdateTemplate: get(c!("vkDestroyDescriptorUpdateTemplate")).map(|a| a.cast()),
                vkDestroySamplerYcbcrConversion: get(c!("vkDestroySamplerYcbcrConversion")).map(|a| a.cast()),
                vkGetBufferMemoryRequirements2: get(c!("vkGetBufferMemoryRequirements2")).map(|a| a.cast()),
                vkGetDescriptorSetLayoutSupport: get(c!("vkGetDescriptorSetLayoutSupport")).map(|a| a.cast()),
                vkGetDeviceGroupPeerMemoryFeatures: get(c!("vkGetDeviceGroupPeerMemoryFeatures")).map(|a| a.cast()),
                vkGetDeviceQueue2: get(c!("vkGetDeviceQueue2")).map(|a| a.cast()),
                vkGetImageMemoryRequirements2: get(c!("vkGetImageMemoryRequirements2")).map(|a| a.cast()),
                vkGetImageSparseMemoryRequirements2: get(c!("vkGetImageSparseMemoryRequirements2")).map(|a| a.cast()),
                vkTrimCommandPool: get(c!("vkTrimCommandPool")).map(|a| a.cast()),
                vkUpdateDescriptorSetWithTemplate: get(c!("vkUpdateDescriptorSetWithTemplate")).map(|a| a.cast()),
            } }
        }
    }

    impl DeviceCommands_1_1 {
        /// `vkBindBufferMemory2`
        pub unsafe fn BindBufferMemory2(&self, device: VkDevice, bindInfoCount: uint32_t, pBindInfos: *const VkBindBufferMemoryInfo) -> VkResult {
            unsafe { (self.vkBindBufferMemory2.expect("Unable to load vkBindBufferMemory2"))(device, bindInfoCount, pBindInfos) }
        }
        /// `vkBindImageMemory2`
        pub unsafe fn BindImageMemory2(&self, device: VkDevice, bindInfoCount: uint32_t, pBindInfos: *const VkBindImageMemoryInfo) -> VkResult {
            unsafe { (self.vkBindImageMemory2.expect("Unable to load vkBindImageMemory2"))(device, bindInfoCount, pBindInfos) }
        }
        /// `vkCmdDispatchBase`
        pub unsafe fn CmdDispatchBase(&self, commandBuffer: VkCommandBuffer, baseGroupX: uint32_t, baseGroupY: uint32_t, baseGroupZ: uint32_t, groupCountX: uint32_t, groupCountY: uint32_t, groupCountZ: uint32_t) -> () {
            unsafe { (self.vkCmdDispatchBase.expect("Unable to load vkCmdDispatchBase"))(commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ) }
        }
        /// `vkCmdSetDeviceMask`
        pub unsafe fn CmdSetDeviceMask(&self, commandBuffer: VkCommandBuffer, deviceMask: uint32_t) -> () {
            unsafe { (self.vkCmdSetDeviceMask.expect("Unable to load vkCmdSetDeviceMask"))(commandBuffer, deviceMask) }
        }
        /// `vkCreateDescriptorUpdateTemplate`
        pub unsafe fn CreateDescriptorUpdateTemplate(&self, device: VkDevice, pCreateInfo: *const VkDescriptorUpdateTemplateCreateInfo, pAllocator: *const VkAllocationCallbacks, pDescriptorUpdateTemplate: *mut VkDescriptorUpdateTemplate) -> VkResult {
            unsafe { (self.vkCreateDescriptorUpdateTemplate.expect("Unable to load vkCreateDescriptorUpdateTemplate"))(device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate) }
        }
        /// `vkCreateSamplerYcbcrConversion`
        pub unsafe fn CreateSamplerYcbcrConversion(&self, device: VkDevice, pCreateInfo: *const VkSamplerYcbcrConversionCreateInfo, pAllocator: *const VkAllocationCallbacks, pYcbcrConversion: *mut VkSamplerYcbcrConversion) -> VkResult {
            unsafe { (self.vkCreateSamplerYcbcrConversion.expect("Unable to load vkCreateSamplerYcbcrConversion"))(device, pCreateInfo, pAllocator, pYcbcrConversion) }
        }
        /// `vkDestroyDescriptorUpdateTemplate`
        pub unsafe fn DestroyDescriptorUpdateTemplate(&self, device: VkDevice, descriptorUpdateTemplate: VkDescriptorUpdateTemplate, pAllocator: *const VkAllocationCallbacks) -> () {
            unsafe { (self.vkDestroyDescriptorUpdateTemplate.expect("Unable to load vkDestroyDescriptorUpdateTemplate"))(device, descriptorUpdateTemplate, pAllocator) }
        }
        /// `vkDestroySamplerYcbcrConversion`
        pub unsafe fn DestroySamplerYcbcrConversion(&self, device: VkDevice, ycbcrConversion: VkSamplerYcbcrConversion, pAllocator: *const VkAllocationCallbacks) -> () {
            unsafe { (self.vkDestroySamplerYcbcrConversion.expect("Unable to load vkDestroySamplerYcbcrConversion"))(device, ycbcrConversion, pAllocator) }
        }
        /// `vkGetBufferMemoryRequirements2`
        pub unsafe fn GetBufferMemoryRequirements2(&self, device: VkDevice, pInfo: *const VkBufferMemoryRequirementsInfo2, pMemoryRequirements: *mut VkMemoryRequirements2) -> () {
            unsafe { (self.vkGetBufferMemoryRequirements2.expect("Unable to load vkGetBufferMemoryRequirements2"))(device, pInfo, pMemoryRequirements) }
        }
        /// `vkGetDescriptorSetLayoutSupport`
        pub unsafe fn GetDescriptorSetLayoutSupport(&self, device: VkDevice, pCreateInfo: *const VkDescriptorSetLayoutCreateInfo, pSupport: *mut VkDescriptorSetLayoutSupport) -> () {
            unsafe { (self.vkGetDescriptorSetLayoutSupport.expect("Unable to load vkGetDescriptorSetLayoutSupport"))(device, pCreateInfo, pSupport) }
        }
        /// `vkGetDeviceGroupPeerMemoryFeatures`
        pub unsafe fn GetDeviceGroupPeerMemoryFeatures(&self, device: VkDevice, heapIndex: uint32_t, localDeviceIndex: uint32_t, remoteDeviceIndex: uint32_t, pPeerMemoryFeatures: *mut VkPeerMemoryFeatureFlags) -> () {
            unsafe { (self.vkGetDeviceGroupPeerMemoryFeatures.expect("Unable to load vkGetDeviceGroupPeerMemoryFeatures"))(device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures) }
        }
        /// `vkGetDeviceQueue2`
        pub unsafe fn GetDeviceQueue2(&self, device: VkDevice, pQueueInfo: *const VkDeviceQueueInfo2, pQueue: *mut VkQueue) -> () {
            unsafe { (self.vkGetDeviceQueue2.expect("Unable to load vkGetDeviceQueue2"))(device, pQueueInfo, pQueue) }
        }
        /// `vkGetImageMemoryRequirements2`
        pub unsafe fn GetImageMemoryRequirements2(&self, device: VkDevice, pInfo: *const VkImageMemoryRequirementsInfo2, pMemoryRequirements: *mut VkMemoryRequirements2) -> () {
            unsafe { (self.vkGetImageMemoryRequirements2.expect("Unable to load vkGetImageMemoryRequirements2"))(device, pInfo, pMemoryRequirements) }
        }
        /// `vkGetImageSparseMemoryRequirements2`
        pub unsafe fn GetImageSparseMemoryRequirements2(&self, device: VkDevice, pInfo: *const VkImageSparseMemoryRequirementsInfo2, pSparseMemoryRequirementCount: *mut uint32_t, pSparseMemoryRequirements: *mut VkSparseImageMemoryRequirements2) -> () {
            unsafe { (self.vkGetImageSparseMemoryRequirements2.expect("Unable to load vkGetImageSparseMemoryRequirements2"))(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements) }
        }
        /// `vkTrimCommandPool`
        pub unsafe fn TrimCommandPool(&self, device: VkDevice, commandPool: VkCommandPool, flags: VkCommandPoolTrimFlags) -> () {
            unsafe { (self.vkTrimCommandPool.expect("Unable to load vkTrimCommandPool"))(device, commandPool, flags) }
        }
        /// `vkUpdateDescriptorSetWithTemplate`
        pub unsafe fn UpdateDescriptorSetWithTemplate(&self, device: VkDevice, descriptorSet: VkDescriptorSet, descriptorUpdateTemplate: VkDescriptorUpdateTemplate, pData: *const void) -> () {
            unsafe { (self.vkUpdateDescriptorSetWithTemplate.expect("Unable to load vkUpdateDescriptorSetWithTemplate"))(device, descriptorSet, descriptorUpdateTemplate, pData) }
        }
    }

    /// `Vulkan 1.2` InstanceCommands
    #[derive(Debug, Clone, Copy)]
    pub struct InstanceCommands_1_2 {
    }

    impl InstanceCommands_1_2 {
        pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
            unsafe { Self {
            } }
        }
    }

    impl InstanceCommands_1_2 {
    }

    /// `Vulkan 1.2` DeviceCommands
    #[derive(Debug, Clone, Copy)]
    pub struct DeviceCommands_1_2 {
        pub vkCmdBeginRenderPass2: PFN_vkCmdBeginRenderPass2,
        pub vkCmdDrawIndexedIndirectCount: PFN_vkCmdDrawIndexedIndirectCount,
        pub vkCmdDrawIndirectCount: PFN_vkCmdDrawIndirectCount,
        pub vkCmdEndRenderPass2: PFN_vkCmdEndRenderPass2,
        pub vkCmdNextSubpass2: PFN_vkCmdNextSubpass2,
        pub vkCreateRenderPass2: PFN_vkCreateRenderPass2,
        pub vkGetBufferDeviceAddress: PFN_vkGetBufferDeviceAddress,
        pub vkGetBufferOpaqueCaptureAddress: PFN_vkGetBufferOpaqueCaptureAddress,
        pub vkGetDeviceMemoryOpaqueCaptureAddress: PFN_vkGetDeviceMemoryOpaqueCaptureAddress,
        pub vkGetSemaphoreCounterValue: PFN_vkGetSemaphoreCounterValue,
        pub vkResetQueryPool: PFN_vkResetQueryPool,
        pub vkSignalSemaphore: PFN_vkSignalSemaphore,
        pub vkWaitSemaphores: PFN_vkWaitSemaphores,
    }

    impl DeviceCommands_1_2 {
        pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
            unsafe { Self {
                vkCmdBeginRenderPass2: get(c!("vkCmdBeginRenderPass2")).map(|a| a.cast()),
                vkCmdDrawIndexedIndirectCount: get(c!("vkCmdDrawIndexedIndirectCount")).map(|a| a.cast()),
                vkCmdDrawIndirectCount: get(c!("vkCmdDrawIndirectCount")).map(|a| a.cast()),
                vkCmdEndRenderPass2: get(c!("vkCmdEndRenderPass2")).map(|a| a.cast()),
                vkCmdNextSubpass2: get(c!("vkCmdNextSubpass2")).map(|a| a.cast()),
                vkCreateRenderPass2: get(c!("vkCreateRenderPass2")).map(|a| a.cast()),
                vkGetBufferDeviceAddress: get(c!("vkGetBufferDeviceAddress")).map(|a| a.cast()),
                vkGetBufferOpaqueCaptureAddress: get(c!("vkGetBufferOpaqueCaptureAddress")).map(|a| a.cast()),
                vkGetDeviceMemoryOpaqueCaptureAddress: get(c!("vkGetDeviceMemoryOpaqueCaptureAddress")).map(|a| a.cast()),
                vkGetSemaphoreCounterValue: get(c!("vkGetSemaphoreCounterValue")).map(|a| a.cast()),
                vkResetQueryPool: get(c!("vkResetQueryPool")).map(|a| a.cast()),
                vkSignalSemaphore: get(c!("vkSignalSemaphore")).map(|a| a.cast()),
                vkWaitSemaphores: get(c!("vkWaitSemaphores")).map(|a| a.cast()),
            } }
        }
    }

    impl DeviceCommands_1_2 {
        /// `vkCmdBeginRenderPass2`
        pub unsafe fn CmdBeginRenderPass2(&self, commandBuffer: VkCommandBuffer, pRenderPassBegin: *const VkRenderPassBeginInfo, pSubpassBeginInfo: *const VkSubpassBeginInfo) -> () {
            unsafe { (self.vkCmdBeginRenderPass2.expect("Unable to load vkCmdBeginRenderPass2"))(commandBuffer, pRenderPassBegin, pSubpassBeginInfo) }
        }
        /// `vkCmdDrawIndexedIndirectCount`
        pub unsafe fn CmdDrawIndexedIndirectCount(&self, commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, countBuffer: VkBuffer, countBufferOffset: VkDeviceSize, maxDrawCount: uint32_t, stride: uint32_t) -> () {
            unsafe { (self.vkCmdDrawIndexedIndirectCount.expect("Unable to load vkCmdDrawIndexedIndirectCount"))(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride) }
        }
        /// `vkCmdDrawIndirectCount`
        pub unsafe fn CmdDrawIndirectCount(&self, commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, countBuffer: VkBuffer, countBufferOffset: VkDeviceSize, maxDrawCount: uint32_t, stride: uint32_t) -> () {
            unsafe { (self.vkCmdDrawIndirectCount.expect("Unable to load vkCmdDrawIndirectCount"))(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride) }
        }
        /// `vkCmdEndRenderPass2`
        pub unsafe fn CmdEndRenderPass2(&self, commandBuffer: VkCommandBuffer, pSubpassEndInfo: *const VkSubpassEndInfo) -> () {
            unsafe { (self.vkCmdEndRenderPass2.expect("Unable to load vkCmdEndRenderPass2"))(commandBuffer, pSubpassEndInfo) }
        }
        /// `vkCmdNextSubpass2`
        pub unsafe fn CmdNextSubpass2(&self, commandBuffer: VkCommandBuffer, pSubpassBeginInfo: *const VkSubpassBeginInfo, pSubpassEndInfo: *const VkSubpassEndInfo) -> () {
            unsafe { (self.vkCmdNextSubpass2.expect("Unable to load vkCmdNextSubpass2"))(commandBuffer, pSubpassBeginInfo, pSubpassEndInfo) }
        }
        /// `vkCreateRenderPass2`
        pub unsafe fn CreateRenderPass2(&self, device: VkDevice, pCreateInfo: *const VkRenderPassCreateInfo2, pAllocator: *const VkAllocationCallbacks, pRenderPass: *mut VkRenderPass) -> VkResult {
            unsafe { (self.vkCreateRenderPass2.expect("Unable to load vkCreateRenderPass2"))(device, pCreateInfo, pAllocator, pRenderPass) }
        }
        /// `vkGetBufferDeviceAddress`
        pub unsafe fn GetBufferDeviceAddress(&self, device: VkDevice, pInfo: *const VkBufferDeviceAddressInfo) -> VkDeviceAddress {
            unsafe { (self.vkGetBufferDeviceAddress.expect("Unable to load vkGetBufferDeviceAddress"))(device, pInfo) }
        }
        /// `vkGetBufferOpaqueCaptureAddress`
        pub unsafe fn GetBufferOpaqueCaptureAddress(&self, device: VkDevice, pInfo: *const VkBufferDeviceAddressInfo) -> uint64_t {
            unsafe { (self.vkGetBufferOpaqueCaptureAddress.expect("Unable to load vkGetBufferOpaqueCaptureAddress"))(device, pInfo) }
        }
        /// `vkGetDeviceMemoryOpaqueCaptureAddress`
        pub unsafe fn GetDeviceMemoryOpaqueCaptureAddress(&self, device: VkDevice, pInfo: *const VkDeviceMemoryOpaqueCaptureAddressInfo) -> uint64_t {
            unsafe { (self.vkGetDeviceMemoryOpaqueCaptureAddress.expect("Unable to load vkGetDeviceMemoryOpaqueCaptureAddress"))(device, pInfo) }
        }
        /// `vkGetSemaphoreCounterValue`
        pub unsafe fn GetSemaphoreCounterValue(&self, device: VkDevice, semaphore: VkSemaphore, pValue: *mut uint64_t) -> VkResult {
            unsafe { (self.vkGetSemaphoreCounterValue.expect("Unable to load vkGetSemaphoreCounterValue"))(device, semaphore, pValue) }
        }
        /// `vkResetQueryPool`
        pub unsafe fn ResetQueryPool(&self, device: VkDevice, queryPool: VkQueryPool, firstQuery: uint32_t, queryCount: uint32_t) -> () {
            unsafe { (self.vkResetQueryPool.expect("Unable to load vkResetQueryPool"))(device, queryPool, firstQuery, queryCount) }
        }
        /// `vkSignalSemaphore`
        pub unsafe fn SignalSemaphore(&self, device: VkDevice, pSignalInfo: *const VkSemaphoreSignalInfo) -> VkResult {
            unsafe { (self.vkSignalSemaphore.expect("Unable to load vkSignalSemaphore"))(device, pSignalInfo) }
        }
        /// `vkWaitSemaphores`
        pub unsafe fn WaitSemaphores(&self, device: VkDevice, pWaitInfo: *const VkSemaphoreWaitInfo, timeout: uint64_t) -> VkResult {
            unsafe { (self.vkWaitSemaphores.expect("Unable to load vkWaitSemaphores"))(device, pWaitInfo, timeout) }
        }
    }

    /// `Vulkan 1.3` InstanceCommands
    #[derive(Debug, Clone, Copy)]
    pub struct InstanceCommands_1_3 {
        pub vkGetPhysicalDeviceToolProperties: PFN_vkGetPhysicalDeviceToolProperties,
    }

    impl InstanceCommands_1_3 {
        pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
            unsafe { Self {
                vkGetPhysicalDeviceToolProperties: get(c!("vkGetPhysicalDeviceToolProperties")).map(|a| a.cast()),
            } }
        }
    }

    impl InstanceCommands_1_3 {
        /// `vkGetPhysicalDeviceToolProperties`
        pub unsafe fn GetPhysicalDeviceToolProperties(&self, physicalDevice: VkPhysicalDevice, pToolCount: *mut uint32_t, pToolProperties: *mut VkPhysicalDeviceToolProperties) -> VkResult {
            unsafe { (self.vkGetPhysicalDeviceToolProperties.expect("Unable to load vkGetPhysicalDeviceToolProperties"))(physicalDevice, pToolCount, pToolProperties) }
        }
    }

    /// `Vulkan 1.3` DeviceCommands
    #[derive(Debug, Clone, Copy)]
    pub struct DeviceCommands_1_3 {
        pub vkCmdBeginRendering: PFN_vkCmdBeginRendering,
        pub vkCmdBindVertexBuffers2: PFN_vkCmdBindVertexBuffers2,
        pub vkCmdBlitImage2: PFN_vkCmdBlitImage2,
        pub vkCmdCopyBuffer2: PFN_vkCmdCopyBuffer2,
        pub vkCmdCopyBufferToImage2: PFN_vkCmdCopyBufferToImage2,
        pub vkCmdCopyImage2: PFN_vkCmdCopyImage2,
        pub vkCmdCopyImageToBuffer2: PFN_vkCmdCopyImageToBuffer2,
        pub vkCmdEndRendering: PFN_vkCmdEndRendering,
        pub vkCmdPipelineBarrier2: PFN_vkCmdPipelineBarrier2,
        pub vkCmdResetEvent2: PFN_vkCmdResetEvent2,
        pub vkCmdResolveImage2: PFN_vkCmdResolveImage2,
        pub vkCmdSetCullMode: PFN_vkCmdSetCullMode,
        pub vkCmdSetDepthBiasEnable: PFN_vkCmdSetDepthBiasEnable,
        pub vkCmdSetDepthBoundsTestEnable: PFN_vkCmdSetDepthBoundsTestEnable,
        pub vkCmdSetDepthCompareOp: PFN_vkCmdSetDepthCompareOp,
        pub vkCmdSetDepthTestEnable: PFN_vkCmdSetDepthTestEnable,
        pub vkCmdSetDepthWriteEnable: PFN_vkCmdSetDepthWriteEnable,
        pub vkCmdSetEvent2: PFN_vkCmdSetEvent2,
        pub vkCmdSetFrontFace: PFN_vkCmdSetFrontFace,
        pub vkCmdSetPrimitiveRestartEnable: PFN_vkCmdSetPrimitiveRestartEnable,
        pub vkCmdSetPrimitiveTopology: PFN_vkCmdSetPrimitiveTopology,
        pub vkCmdSetRasterizerDiscardEnable: PFN_vkCmdSetRasterizerDiscardEnable,
        pub vkCmdSetScissorWithCount: PFN_vkCmdSetScissorWithCount,
        pub vkCmdSetStencilOp: PFN_vkCmdSetStencilOp,
        pub vkCmdSetStencilTestEnable: PFN_vkCmdSetStencilTestEnable,
        pub vkCmdSetViewportWithCount: PFN_vkCmdSetViewportWithCount,
        pub vkCmdWaitEvents2: PFN_vkCmdWaitEvents2,
        pub vkCmdWriteTimestamp2: PFN_vkCmdWriteTimestamp2,
        pub vkCreatePrivateDataSlot: PFN_vkCreatePrivateDataSlot,
        pub vkDestroyPrivateDataSlot: PFN_vkDestroyPrivateDataSlot,
        pub vkGetDeviceBufferMemoryRequirements: PFN_vkGetDeviceBufferMemoryRequirements,
        pub vkGetDeviceImageMemoryRequirements: PFN_vkGetDeviceImageMemoryRequirements,
        pub vkGetDeviceImageSparseMemoryRequirements: PFN_vkGetDeviceImageSparseMemoryRequirements,
        pub vkGetPrivateData: PFN_vkGetPrivateData,
        pub vkQueueSubmit2: PFN_vkQueueSubmit2,
        pub vkSetPrivateData: PFN_vkSetPrivateData,
    }

    impl DeviceCommands_1_3 {
        pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
            unsafe { Self {
                vkCmdBeginRendering: get(c!("vkCmdBeginRendering")).map(|a| a.cast()),
                vkCmdBindVertexBuffers2: get(c!("vkCmdBindVertexBuffers2")).map(|a| a.cast()),
                vkCmdBlitImage2: get(c!("vkCmdBlitImage2")).map(|a| a.cast()),
                vkCmdCopyBuffer2: get(c!("vkCmdCopyBuffer2")).map(|a| a.cast()),
                vkCmdCopyBufferToImage2: get(c!("vkCmdCopyBufferToImage2")).map(|a| a.cast()),
                vkCmdCopyImage2: get(c!("vkCmdCopyImage2")).map(|a| a.cast()),
                vkCmdCopyImageToBuffer2: get(c!("vkCmdCopyImageToBuffer2")).map(|a| a.cast()),
                vkCmdEndRendering: get(c!("vkCmdEndRendering")).map(|a| a.cast()),
                vkCmdPipelineBarrier2: get(c!("vkCmdPipelineBarrier2")).map(|a| a.cast()),
                vkCmdResetEvent2: get(c!("vkCmdResetEvent2")).map(|a| a.cast()),
                vkCmdResolveImage2: get(c!("vkCmdResolveImage2")).map(|a| a.cast()),
                vkCmdSetCullMode: get(c!("vkCmdSetCullMode")).map(|a| a.cast()),
                vkCmdSetDepthBiasEnable: get(c!("vkCmdSetDepthBiasEnable")).map(|a| a.cast()),
                vkCmdSetDepthBoundsTestEnable: get(c!("vkCmdSetDepthBoundsTestEnable")).map(|a| a.cast()),
                vkCmdSetDepthCompareOp: get(c!("vkCmdSetDepthCompareOp")).map(|a| a.cast()),
                vkCmdSetDepthTestEnable: get(c!("vkCmdSetDepthTestEnable")).map(|a| a.cast()),
                vkCmdSetDepthWriteEnable: get(c!("vkCmdSetDepthWriteEnable")).map(|a| a.cast()),
                vkCmdSetEvent2: get(c!("vkCmdSetEvent2")).map(|a| a.cast()),
                vkCmdSetFrontFace: get(c!("vkCmdSetFrontFace")).map(|a| a.cast()),
                vkCmdSetPrimitiveRestartEnable: get(c!("vkCmdSetPrimitiveRestartEnable")).map(|a| a.cast()),
                vkCmdSetPrimitiveTopology: get(c!("vkCmdSetPrimitiveTopology")).map(|a| a.cast()),
                vkCmdSetRasterizerDiscardEnable: get(c!("vkCmdSetRasterizerDiscardEnable")).map(|a| a.cast()),
                vkCmdSetScissorWithCount: get(c!("vkCmdSetScissorWithCount")).map(|a| a.cast()),
                vkCmdSetStencilOp: get(c!("vkCmdSetStencilOp")).map(|a| a.cast()),
                vkCmdSetStencilTestEnable: get(c!("vkCmdSetStencilTestEnable")).map(|a| a.cast()),
                vkCmdSetViewportWithCount: get(c!("vkCmdSetViewportWithCount")).map(|a| a.cast()),
                vkCmdWaitEvents2: get(c!("vkCmdWaitEvents2")).map(|a| a.cast()),
                vkCmdWriteTimestamp2: get(c!("vkCmdWriteTimestamp2")).map(|a| a.cast()),
                vkCreatePrivateDataSlot: get(c!("vkCreatePrivateDataSlot")).map(|a| a.cast()),
                vkDestroyPrivateDataSlot: get(c!("vkDestroyPrivateDataSlot")).map(|a| a.cast()),
                vkGetDeviceBufferMemoryRequirements: get(c!("vkGetDeviceBufferMemoryRequirements")).map(|a| a.cast()),
                vkGetDeviceImageMemoryRequirements: get(c!("vkGetDeviceImageMemoryRequirements")).map(|a| a.cast()),
                vkGetDeviceImageSparseMemoryRequirements: get(c!("vkGetDeviceImageSparseMemoryRequirements")).map(|a| a.cast()),
                vkGetPrivateData: get(c!("vkGetPrivateData")).map(|a| a.cast()),
                vkQueueSubmit2: get(c!("vkQueueSubmit2")).map(|a| a.cast()),
                vkSetPrivateData: get(c!("vkSetPrivateData")).map(|a| a.cast()),
            } }
        }
    }

    impl DeviceCommands_1_3 {
        /// `vkCmdBeginRendering`
        pub unsafe fn CmdBeginRendering(&self, commandBuffer: VkCommandBuffer, pRenderingInfo: *const VkRenderingInfo) -> () {
            unsafe { (self.vkCmdBeginRendering.expect("Unable to load vkCmdBeginRendering"))(commandBuffer, pRenderingInfo) }
        }
        /// `vkCmdBindVertexBuffers2`
        pub unsafe fn CmdBindVertexBuffers2(&self, commandBuffer: VkCommandBuffer, firstBinding: uint32_t, bindingCount: uint32_t, pBuffers: *const VkBuffer, pOffsets: *const VkDeviceSize, pSizes: *const VkDeviceSize, pStrides: *const VkDeviceSize) -> () {
            unsafe { (self.vkCmdBindVertexBuffers2.expect("Unable to load vkCmdBindVertexBuffers2"))(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides) }
        }
        /// `vkCmdBlitImage2`
        pub unsafe fn CmdBlitImage2(&self, commandBuffer: VkCommandBuffer, pBlitImageInfo: *const VkBlitImageInfo2) -> () {
            unsafe { (self.vkCmdBlitImage2.expect("Unable to load vkCmdBlitImage2"))(commandBuffer, pBlitImageInfo) }
        }
        /// `vkCmdCopyBuffer2`
        pub unsafe fn CmdCopyBuffer2(&self, commandBuffer: VkCommandBuffer, pCopyBufferInfo: *const VkCopyBufferInfo2) -> () {
            unsafe { (self.vkCmdCopyBuffer2.expect("Unable to load vkCmdCopyBuffer2"))(commandBuffer, pCopyBufferInfo) }
        }
        /// `vkCmdCopyBufferToImage2`
        pub unsafe fn CmdCopyBufferToImage2(&self, commandBuffer: VkCommandBuffer, pCopyBufferToImageInfo: *const VkCopyBufferToImageInfo2) -> () {
            unsafe { (self.vkCmdCopyBufferToImage2.expect("Unable to load vkCmdCopyBufferToImage2"))(commandBuffer, pCopyBufferToImageInfo) }
        }
        /// `vkCmdCopyImage2`
        pub unsafe fn CmdCopyImage2(&self, commandBuffer: VkCommandBuffer, pCopyImageInfo: *const VkCopyImageInfo2) -> () {
            unsafe { (self.vkCmdCopyImage2.expect("Unable to load vkCmdCopyImage2"))(commandBuffer, pCopyImageInfo) }
        }
        /// `vkCmdCopyImageToBuffer2`
        pub unsafe fn CmdCopyImageToBuffer2(&self, commandBuffer: VkCommandBuffer, pCopyImageToBufferInfo: *const VkCopyImageToBufferInfo2) -> () {
            unsafe { (self.vkCmdCopyImageToBuffer2.expect("Unable to load vkCmdCopyImageToBuffer2"))(commandBuffer, pCopyImageToBufferInfo) }
        }
        /// `vkCmdEndRendering`
        pub unsafe fn CmdEndRendering(&self, commandBuffer: VkCommandBuffer) -> () {
            unsafe { (self.vkCmdEndRendering.expect("Unable to load vkCmdEndRendering"))(commandBuffer) }
        }
        /// `vkCmdPipelineBarrier2`
        pub unsafe fn CmdPipelineBarrier2(&self, commandBuffer: VkCommandBuffer, pDependencyInfo: *const VkDependencyInfo) -> () {
            unsafe { (self.vkCmdPipelineBarrier2.expect("Unable to load vkCmdPipelineBarrier2"))(commandBuffer, pDependencyInfo) }
        }
        /// `vkCmdResetEvent2`
        pub unsafe fn CmdResetEvent2(&self, commandBuffer: VkCommandBuffer, event: VkEvent, stageMask: VkPipelineStageFlags2) -> () {
            unsafe { (self.vkCmdResetEvent2.expect("Unable to load vkCmdResetEvent2"))(commandBuffer, event, stageMask) }
        }
        /// `vkCmdResolveImage2`
        pub unsafe fn CmdResolveImage2(&self, commandBuffer: VkCommandBuffer, pResolveImageInfo: *const VkResolveImageInfo2) -> () {
            unsafe { (self.vkCmdResolveImage2.expect("Unable to load vkCmdResolveImage2"))(commandBuffer, pResolveImageInfo) }
        }
        /// `vkCmdSetCullMode`
        pub unsafe fn CmdSetCullMode(&self, commandBuffer: VkCommandBuffer, cullMode: VkCullModeFlags) -> () {
            unsafe { (self.vkCmdSetCullMode.expect("Unable to load vkCmdSetCullMode"))(commandBuffer, cullMode) }
        }
        /// `vkCmdSetDepthBiasEnable`
        pub unsafe fn CmdSetDepthBiasEnable(&self, commandBuffer: VkCommandBuffer, depthBiasEnable: VkBool32) -> () {
            unsafe { (self.vkCmdSetDepthBiasEnable.expect("Unable to load vkCmdSetDepthBiasEnable"))(commandBuffer, depthBiasEnable) }
        }
        /// `vkCmdSetDepthBoundsTestEnable`
        pub unsafe fn CmdSetDepthBoundsTestEnable(&self, commandBuffer: VkCommandBuffer, depthBoundsTestEnable: VkBool32) -> () {
            unsafe { (self.vkCmdSetDepthBoundsTestEnable.expect("Unable to load vkCmdSetDepthBoundsTestEnable"))(commandBuffer, depthBoundsTestEnable) }
        }
        /// `vkCmdSetDepthCompareOp`
        pub unsafe fn CmdSetDepthCompareOp(&self, commandBuffer: VkCommandBuffer, depthCompareOp: VkCompareOp) -> () {
            unsafe { (self.vkCmdSetDepthCompareOp.expect("Unable to load vkCmdSetDepthCompareOp"))(commandBuffer, depthCompareOp) }
        }
        /// `vkCmdSetDepthTestEnable`
        pub unsafe fn CmdSetDepthTestEnable(&self, commandBuffer: VkCommandBuffer, depthTestEnable: VkBool32) -> () {
            unsafe { (self.vkCmdSetDepthTestEnable.expect("Unable to load vkCmdSetDepthTestEnable"))(commandBuffer, depthTestEnable) }
        }
        /// `vkCmdSetDepthWriteEnable`
        pub unsafe fn CmdSetDepthWriteEnable(&self, commandBuffer: VkCommandBuffer, depthWriteEnable: VkBool32) -> () {
            unsafe { (self.vkCmdSetDepthWriteEnable.expect("Unable to load vkCmdSetDepthWriteEnable"))(commandBuffer, depthWriteEnable) }
        }
        /// `vkCmdSetEvent2`
        pub unsafe fn CmdSetEvent2(&self, commandBuffer: VkCommandBuffer, event: VkEvent, pDependencyInfo: *const VkDependencyInfo) -> () {
            unsafe { (self.vkCmdSetEvent2.expect("Unable to load vkCmdSetEvent2"))(commandBuffer, event, pDependencyInfo) }
        }
        /// `vkCmdSetFrontFace`
        pub unsafe fn CmdSetFrontFace(&self, commandBuffer: VkCommandBuffer, frontFace: VkFrontFace) -> () {
            unsafe { (self.vkCmdSetFrontFace.expect("Unable to load vkCmdSetFrontFace"))(commandBuffer, frontFace) }
        }
        /// `vkCmdSetPrimitiveRestartEnable`
        pub unsafe fn CmdSetPrimitiveRestartEnable(&self, commandBuffer: VkCommandBuffer, primitiveRestartEnable: VkBool32) -> () {
            unsafe { (self.vkCmdSetPrimitiveRestartEnable.expect("Unable to load vkCmdSetPrimitiveRestartEnable"))(commandBuffer, primitiveRestartEnable) }
        }
        /// `vkCmdSetPrimitiveTopology`
        pub unsafe fn CmdSetPrimitiveTopology(&self, commandBuffer: VkCommandBuffer, primitiveTopology: VkPrimitiveTopology) -> () {
            unsafe { (self.vkCmdSetPrimitiveTopology.expect("Unable to load vkCmdSetPrimitiveTopology"))(commandBuffer, primitiveTopology) }
        }
        /// `vkCmdSetRasterizerDiscardEnable`
        pub unsafe fn CmdSetRasterizerDiscardEnable(&self, commandBuffer: VkCommandBuffer, rasterizerDiscardEnable: VkBool32) -> () {
            unsafe { (self.vkCmdSetRasterizerDiscardEnable.expect("Unable to load vkCmdSetRasterizerDiscardEnable"))(commandBuffer, rasterizerDiscardEnable) }
        }
        /// `vkCmdSetScissorWithCount`
        pub unsafe fn CmdSetScissorWithCount(&self, commandBuffer: VkCommandBuffer, scissorCount: uint32_t, pScissors: *const VkRect2D) -> () {
            unsafe { (self.vkCmdSetScissorWithCount.expect("Unable to load vkCmdSetScissorWithCount"))(commandBuffer, scissorCount, pScissors) }
        }
        /// `vkCmdSetStencilOp`
        pub unsafe fn CmdSetStencilOp(&self, commandBuffer: VkCommandBuffer, faceMask: VkStencilFaceFlags, failOp: VkStencilOp, passOp: VkStencilOp, depthFailOp: VkStencilOp, compareOp: VkCompareOp) -> () {
            unsafe { (self.vkCmdSetStencilOp.expect("Unable to load vkCmdSetStencilOp"))(commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp) }
        }
        /// `vkCmdSetStencilTestEnable`
        pub unsafe fn CmdSetStencilTestEnable(&self, commandBuffer: VkCommandBuffer, stencilTestEnable: VkBool32) -> () {
            unsafe { (self.vkCmdSetStencilTestEnable.expect("Unable to load vkCmdSetStencilTestEnable"))(commandBuffer, stencilTestEnable) }
        }
        /// `vkCmdSetViewportWithCount`
        pub unsafe fn CmdSetViewportWithCount(&self, commandBuffer: VkCommandBuffer, viewportCount: uint32_t, pViewports: *const VkViewport) -> () {
            unsafe { (self.vkCmdSetViewportWithCount.expect("Unable to load vkCmdSetViewportWithCount"))(commandBuffer, viewportCount, pViewports) }
        }
        /// `vkCmdWaitEvents2`
        pub unsafe fn CmdWaitEvents2(&self, commandBuffer: VkCommandBuffer, eventCount: uint32_t, pEvents: *const VkEvent, pDependencyInfos: *const VkDependencyInfo) -> () {
            unsafe { (self.vkCmdWaitEvents2.expect("Unable to load vkCmdWaitEvents2"))(commandBuffer, eventCount, pEvents, pDependencyInfos) }
        }
        /// `vkCmdWriteTimestamp2`
        pub unsafe fn CmdWriteTimestamp2(&self, commandBuffer: VkCommandBuffer, stage: VkPipelineStageFlags2, queryPool: VkQueryPool, query: uint32_t) -> () {
            unsafe { (self.vkCmdWriteTimestamp2.expect("Unable to load vkCmdWriteTimestamp2"))(commandBuffer, stage, queryPool, query) }
        }
        /// `vkCreatePrivateDataSlot`
        pub unsafe fn CreatePrivateDataSlot(&self, device: VkDevice, pCreateInfo: *const VkPrivateDataSlotCreateInfo, pAllocator: *const VkAllocationCallbacks, pPrivateDataSlot: *mut VkPrivateDataSlot) -> VkResult {
            unsafe { (self.vkCreatePrivateDataSlot.expect("Unable to load vkCreatePrivateDataSlot"))(device, pCreateInfo, pAllocator, pPrivateDataSlot) }
        }
        /// `vkDestroyPrivateDataSlot`
        pub unsafe fn DestroyPrivateDataSlot(&self, device: VkDevice, privateDataSlot: VkPrivateDataSlot, pAllocator: *const VkAllocationCallbacks) -> () {
            unsafe { (self.vkDestroyPrivateDataSlot.expect("Unable to load vkDestroyPrivateDataSlot"))(device, privateDataSlot, pAllocator) }
        }
        /// `vkGetDeviceBufferMemoryRequirements`
        pub unsafe fn GetDeviceBufferMemoryRequirements(&self, device: VkDevice, pInfo: *const VkDeviceBufferMemoryRequirements, pMemoryRequirements: *mut VkMemoryRequirements2) -> () {
            unsafe { (self.vkGetDeviceBufferMemoryRequirements.expect("Unable to load vkGetDeviceBufferMemoryRequirements"))(device, pInfo, pMemoryRequirements) }
        }
        /// `vkGetDeviceImageMemoryRequirements`
        pub unsafe fn GetDeviceImageMemoryRequirements(&self, device: VkDevice, pInfo: *const VkDeviceImageMemoryRequirements, pMemoryRequirements: *mut VkMemoryRequirements2) -> () {
            unsafe { (self.vkGetDeviceImageMemoryRequirements.expect("Unable to load vkGetDeviceImageMemoryRequirements"))(device, pInfo, pMemoryRequirements) }
        }
        /// `vkGetDeviceImageSparseMemoryRequirements`
        pub unsafe fn GetDeviceImageSparseMemoryRequirements(&self, device: VkDevice, pInfo: *const VkDeviceImageMemoryRequirements, pSparseMemoryRequirementCount: *mut uint32_t, pSparseMemoryRequirements: *mut VkSparseImageMemoryRequirements2) -> () {
            unsafe { (self.vkGetDeviceImageSparseMemoryRequirements.expect("Unable to load vkGetDeviceImageSparseMemoryRequirements"))(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements) }
        }
        /// `vkGetPrivateData`
        pub unsafe fn GetPrivateData(&self, device: VkDevice, objectType: VkObjectType, objectHandle: uint64_t, privateDataSlot: VkPrivateDataSlot, pData: *mut uint64_t) -> () {
            unsafe { (self.vkGetPrivateData.expect("Unable to load vkGetPrivateData"))(device, objectType, objectHandle, privateDataSlot, pData) }
        }
        /// `vkQueueSubmit2`
        pub unsafe fn QueueSubmit2(&self, queue: VkQueue, submitCount: uint32_t, pSubmits: *const VkSubmitInfo2, fence: VkFence) -> VkResult {
            unsafe { (self.vkQueueSubmit2.expect("Unable to load vkQueueSubmit2"))(queue, submitCount, pSubmits, fence) }
        }
        /// `vkSetPrivateData`
        pub unsafe fn SetPrivateData(&self, device: VkDevice, objectType: VkObjectType, objectHandle: uint64_t, privateDataSlot: VkPrivateDataSlot, data: uint64_t) -> VkResult {
            unsafe { (self.vkSetPrivateData.expect("Unable to load vkSetPrivateData"))(device, objectType, objectHandle, privateDataSlot, data) }
        }
    }

    /// `Vulkan 1.4` InstanceCommands
    #[derive(Debug, Clone, Copy)]
    pub struct InstanceCommands_1_4 {
    }

    impl InstanceCommands_1_4 {
        pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
            unsafe { Self {
            } }
        }
    }

    impl InstanceCommands_1_4 {
    }

    /// `Vulkan 1.4` DeviceCommands
    #[derive(Debug, Clone, Copy)]
    pub struct DeviceCommands_1_4 {
        pub vkCmdBindDescriptorSets2: PFN_vkCmdBindDescriptorSets2,
        pub vkCmdBindIndexBuffer2: PFN_vkCmdBindIndexBuffer2,
        pub vkCmdPushConstants2: PFN_vkCmdPushConstants2,
        pub vkCmdPushDescriptorSet: PFN_vkCmdPushDescriptorSet,
        pub vkCmdPushDescriptorSet2: PFN_vkCmdPushDescriptorSet2,
        pub vkCmdPushDescriptorSetWithTemplate: PFN_vkCmdPushDescriptorSetWithTemplate,
        pub vkCmdPushDescriptorSetWithTemplate2: PFN_vkCmdPushDescriptorSetWithTemplate2,
        pub vkCmdSetLineStipple: PFN_vkCmdSetLineStipple,
        pub vkCmdSetRenderingAttachmentLocations: PFN_vkCmdSetRenderingAttachmentLocations,
        pub vkCmdSetRenderingInputAttachmentIndices: PFN_vkCmdSetRenderingInputAttachmentIndices,
        pub vkCopyImageToImage: PFN_vkCopyImageToImage,
        pub vkCopyImageToMemory: PFN_vkCopyImageToMemory,
        pub vkCopyMemoryToImage: PFN_vkCopyMemoryToImage,
        pub vkGetDeviceImageSubresourceLayout: PFN_vkGetDeviceImageSubresourceLayout,
        pub vkGetImageSubresourceLayout2: PFN_vkGetImageSubresourceLayout2,
        pub vkGetRenderingAreaGranularity: PFN_vkGetRenderingAreaGranularity,
        pub vkMapMemory2: PFN_vkMapMemory2,
        pub vkTransitionImageLayout: PFN_vkTransitionImageLayout,
        pub vkUnmapMemory2: PFN_vkUnmapMemory2,
    }

    impl DeviceCommands_1_4 {
        pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
            unsafe { Self {
                vkCmdBindDescriptorSets2: get(c!("vkCmdBindDescriptorSets2")).map(|a| a.cast()),
                vkCmdBindIndexBuffer2: get(c!("vkCmdBindIndexBuffer2")).map(|a| a.cast()),
                vkCmdPushConstants2: get(c!("vkCmdPushConstants2")).map(|a| a.cast()),
                vkCmdPushDescriptorSet: get(c!("vkCmdPushDescriptorSet")).map(|a| a.cast()),
                vkCmdPushDescriptorSet2: get(c!("vkCmdPushDescriptorSet2")).map(|a| a.cast()),
                vkCmdPushDescriptorSetWithTemplate: get(c!("vkCmdPushDescriptorSetWithTemplate")).map(|a| a.cast()),
                vkCmdPushDescriptorSetWithTemplate2: get(c!("vkCmdPushDescriptorSetWithTemplate2")).map(|a| a.cast()),
                vkCmdSetLineStipple: get(c!("vkCmdSetLineStipple")).map(|a| a.cast()),
                vkCmdSetRenderingAttachmentLocations: get(c!("vkCmdSetRenderingAttachmentLocations")).map(|a| a.cast()),
                vkCmdSetRenderingInputAttachmentIndices: get(c!("vkCmdSetRenderingInputAttachmentIndices")).map(|a| a.cast()),
                vkCopyImageToImage: get(c!("vkCopyImageToImage")).map(|a| a.cast()),
                vkCopyImageToMemory: get(c!("vkCopyImageToMemory")).map(|a| a.cast()),
                vkCopyMemoryToImage: get(c!("vkCopyMemoryToImage")).map(|a| a.cast()),
                vkGetDeviceImageSubresourceLayout: get(c!("vkGetDeviceImageSubresourceLayout")).map(|a| a.cast()),
                vkGetImageSubresourceLayout2: get(c!("vkGetImageSubresourceLayout2")).map(|a| a.cast()),
                vkGetRenderingAreaGranularity: get(c!("vkGetRenderingAreaGranularity")).map(|a| a.cast()),
                vkMapMemory2: get(c!("vkMapMemory2")).map(|a| a.cast()),
                vkTransitionImageLayout: get(c!("vkTransitionImageLayout")).map(|a| a.cast()),
                vkUnmapMemory2: get(c!("vkUnmapMemory2")).map(|a| a.cast()),
            } }
        }
    }

    impl DeviceCommands_1_4 {
        /// `vkCmdBindDescriptorSets2`
        pub unsafe fn CmdBindDescriptorSets2(&self, commandBuffer: VkCommandBuffer, pBindDescriptorSetsInfo: *const VkBindDescriptorSetsInfo) -> () {
            unsafe { (self.vkCmdBindDescriptorSets2.expect("Unable to load vkCmdBindDescriptorSets2"))(commandBuffer, pBindDescriptorSetsInfo) }
        }
        /// `vkCmdBindIndexBuffer2`
        pub unsafe fn CmdBindIndexBuffer2(&self, commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, size: VkDeviceSize, indexType: VkIndexType) -> () {
            unsafe { (self.vkCmdBindIndexBuffer2.expect("Unable to load vkCmdBindIndexBuffer2"))(commandBuffer, buffer, offset, size, indexType) }
        }
        /// `vkCmdPushConstants2`
        pub unsafe fn CmdPushConstants2(&self, commandBuffer: VkCommandBuffer, pPushConstantsInfo: *const VkPushConstantsInfo) -> () {
            unsafe { (self.vkCmdPushConstants2.expect("Unable to load vkCmdPushConstants2"))(commandBuffer, pPushConstantsInfo) }
        }
        /// `vkCmdPushDescriptorSet`
        pub unsafe fn CmdPushDescriptorSet(&self, commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, layout: VkPipelineLayout, set: uint32_t, descriptorWriteCount: uint32_t, pDescriptorWrites: *const VkWriteDescriptorSet) -> () {
            unsafe { (self.vkCmdPushDescriptorSet.expect("Unable to load vkCmdPushDescriptorSet"))(commandBuffer, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites) }
        }
        /// `vkCmdPushDescriptorSet2`
        pub unsafe fn CmdPushDescriptorSet2(&self, commandBuffer: VkCommandBuffer, pPushDescriptorSetInfo: *const VkPushDescriptorSetInfo) -> () {
            unsafe { (self.vkCmdPushDescriptorSet2.expect("Unable to load vkCmdPushDescriptorSet2"))(commandBuffer, pPushDescriptorSetInfo) }
        }
        /// `vkCmdPushDescriptorSetWithTemplate`
        pub unsafe fn CmdPushDescriptorSetWithTemplate(&self, commandBuffer: VkCommandBuffer, descriptorUpdateTemplate: VkDescriptorUpdateTemplate, layout: VkPipelineLayout, set: uint32_t, pData: *const void) -> () {
            unsafe { (self.vkCmdPushDescriptorSetWithTemplate.expect("Unable to load vkCmdPushDescriptorSetWithTemplate"))(commandBuffer, descriptorUpdateTemplate, layout, set, pData) }
        }
        /// `vkCmdPushDescriptorSetWithTemplate2`
        pub unsafe fn CmdPushDescriptorSetWithTemplate2(&self, commandBuffer: VkCommandBuffer, pPushDescriptorSetWithTemplateInfo: *const VkPushDescriptorSetWithTemplateInfo) -> () {
            unsafe { (self.vkCmdPushDescriptorSetWithTemplate2.expect("Unable to load vkCmdPushDescriptorSetWithTemplate2"))(commandBuffer, pPushDescriptorSetWithTemplateInfo) }
        }
        /// `vkCmdSetLineStipple`
        pub unsafe fn CmdSetLineStipple(&self, commandBuffer: VkCommandBuffer, lineStippleFactor: uint32_t, lineStipplePattern: uint16_t) -> () {
            unsafe { (self.vkCmdSetLineStipple.expect("Unable to load vkCmdSetLineStipple"))(commandBuffer, lineStippleFactor, lineStipplePattern) }
        }
        /// `vkCmdSetRenderingAttachmentLocations`
        pub unsafe fn CmdSetRenderingAttachmentLocations(&self, commandBuffer: VkCommandBuffer, pLocationInfo: *const VkRenderingAttachmentLocationInfo) -> () {
            unsafe { (self.vkCmdSetRenderingAttachmentLocations.expect("Unable to load vkCmdSetRenderingAttachmentLocations"))(commandBuffer, pLocationInfo) }
        }
        /// `vkCmdSetRenderingInputAttachmentIndices`
        pub unsafe fn CmdSetRenderingInputAttachmentIndices(&self, commandBuffer: VkCommandBuffer, pInputAttachmentIndexInfo: *const VkRenderingInputAttachmentIndexInfo) -> () {
            unsafe { (self.vkCmdSetRenderingInputAttachmentIndices.expect("Unable to load vkCmdSetRenderingInputAttachmentIndices"))(commandBuffer, pInputAttachmentIndexInfo) }
        }
        /// `vkCopyImageToImage`
        pub unsafe fn CopyImageToImage(&self, device: VkDevice, pCopyImageToImageInfo: *const VkCopyImageToImageInfo) -> VkResult {
            unsafe { (self.vkCopyImageToImage.expect("Unable to load vkCopyImageToImage"))(device, pCopyImageToImageInfo) }
        }
        /// `vkCopyImageToMemory`
        pub unsafe fn CopyImageToMemory(&self, device: VkDevice, pCopyImageToMemoryInfo: *const VkCopyImageToMemoryInfo) -> VkResult {
            unsafe { (self.vkCopyImageToMemory.expect("Unable to load vkCopyImageToMemory"))(device, pCopyImageToMemoryInfo) }
        }
        /// `vkCopyMemoryToImage`
        pub unsafe fn CopyMemoryToImage(&self, device: VkDevice, pCopyMemoryToImageInfo: *const VkCopyMemoryToImageInfo) -> VkResult {
            unsafe { (self.vkCopyMemoryToImage.expect("Unable to load vkCopyMemoryToImage"))(device, pCopyMemoryToImageInfo) }
        }
        /// `vkGetDeviceImageSubresourceLayout`
        pub unsafe fn GetDeviceImageSubresourceLayout(&self, device: VkDevice, pInfo: *const VkDeviceImageSubresourceInfo, pLayout: *mut VkSubresourceLayout2) -> () {
            unsafe { (self.vkGetDeviceImageSubresourceLayout.expect("Unable to load vkGetDeviceImageSubresourceLayout"))(device, pInfo, pLayout) }
        }
        /// `vkGetImageSubresourceLayout2`
        pub unsafe fn GetImageSubresourceLayout2(&self, device: VkDevice, image: VkImage, pSubresource: *const VkImageSubresource2, pLayout: *mut VkSubresourceLayout2) -> () {
            unsafe { (self.vkGetImageSubresourceLayout2.expect("Unable to load vkGetImageSubresourceLayout2"))(device, image, pSubresource, pLayout) }
        }
        /// `vkGetRenderingAreaGranularity`
        pub unsafe fn GetRenderingAreaGranularity(&self, device: VkDevice, pRenderingAreaInfo: *const VkRenderingAreaInfo, pGranularity: *mut VkExtent2D) -> () {
            unsafe { (self.vkGetRenderingAreaGranularity.expect("Unable to load vkGetRenderingAreaGranularity"))(device, pRenderingAreaInfo, pGranularity) }
        }
        /// `vkMapMemory2`
        pub unsafe fn MapMemory2(&self, device: VkDevice, pMemoryMapInfo: *const VkMemoryMapInfo, ppData: *mut *mut void) -> VkResult {
            unsafe { (self.vkMapMemory2.expect("Unable to load vkMapMemory2"))(device, pMemoryMapInfo, ppData) }
        }
        /// `vkTransitionImageLayout`
        pub unsafe fn TransitionImageLayout(&self, device: VkDevice, transitionCount: uint32_t, pTransitions: *const VkHostImageLayoutTransitionInfo) -> VkResult {
            unsafe { (self.vkTransitionImageLayout.expect("Unable to load vkTransitionImageLayout"))(device, transitionCount, pTransitions) }
        }
        /// `vkUnmapMemory2`
        pub unsafe fn UnmapMemory2(&self, device: VkDevice, pMemoryUnmapInfo: *const VkMemoryUnmapInfo) -> VkResult {
            unsafe { (self.vkUnmapMemory2.expect("Unable to load vkUnmapMemory2"))(device, pMemoryUnmapInfo) }
        }
    }
}

pub use extensions::*;
/// Extensions
pub mod extensions {
    /// `AMD` prefix extensions
    pub mod amd {
        use core::ffi::CStr;
        use crate::loader::*;
        use crate::ffi::*;
        use crate::*;

        /// `VK_AMD_rasterization_order`
        pub mod rasterization_order {
            use super::*;

            /// `VK_AMD_rasterization_order`
            pub const NAME: &'static CStr = c!("VK_AMD_rasterization_order");
        }

        /// `VK_AMD_shader_trinary_minmax`
        pub mod shader_trinary_minmax {
            use super::*;

            /// `VK_AMD_shader_trinary_minmax`
            pub const NAME: &'static CStr = c!("VK_AMD_shader_trinary_minmax");
        }

        /// `VK_AMD_shader_explicit_vertex_parameter`
        pub mod shader_explicit_vertex_parameter {
            use super::*;

            /// `VK_AMD_shader_explicit_vertex_parameter`
            pub const NAME: &'static CStr = c!("VK_AMD_shader_explicit_vertex_parameter");
        }

        /// `VK_AMD_gcn_shader`
        pub mod gcn_shader {
            use super::*;

            /// `VK_AMD_gcn_shader`
            pub const NAME: &'static CStr = c!("VK_AMD_gcn_shader");
        }

        /// `VK_AMD_draw_indirect_count`
        pub mod draw_indirect_count {
            use super::*;

            /// `VK_AMD_draw_indirect_count`
            pub const NAME: &'static CStr = c!("VK_AMD_draw_indirect_count");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkCmdDrawIndexedIndirectCountAMD: PFN_vkCmdDrawIndexedIndirectCountAMD,
                pub vkCmdDrawIndirectCountAMD: PFN_vkCmdDrawIndirectCountAMD,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkCmdDrawIndexedIndirectCountAMD: get(c!("vkCmdDrawIndexedIndirectCountAMD")).map(|a| a.cast()),
                        vkCmdDrawIndirectCountAMD: get(c!("vkCmdDrawIndirectCountAMD")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkCmdDrawIndexedIndirectCountAMD`
                pub unsafe fn CmdDrawIndexedIndirectCountAMD(&self, commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, countBuffer: VkBuffer, countBufferOffset: VkDeviceSize, maxDrawCount: uint32_t, stride: uint32_t) -> () {
                    unsafe { (self.vkCmdDrawIndexedIndirectCountAMD.expect("Unable to load vkCmdDrawIndexedIndirectCountAMD"))(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride) }
                }
                /// `vkCmdDrawIndirectCountAMD`
                pub unsafe fn CmdDrawIndirectCountAMD(&self, commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, countBuffer: VkBuffer, countBufferOffset: VkDeviceSize, maxDrawCount: uint32_t, stride: uint32_t) -> () {
                    unsafe { (self.vkCmdDrawIndirectCountAMD.expect("Unable to load vkCmdDrawIndirectCountAMD"))(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride) }
                }
            }
        }

        /// `VK_AMD_negative_viewport_height`
        pub mod negative_viewport_height {
            use super::*;

            /// `VK_AMD_negative_viewport_height`
            pub const NAME: &'static CStr = c!("VK_AMD_negative_viewport_height");
        }

        /// `VK_AMD_gpu_shader_half_float`
        pub mod gpu_shader_half_float {
            use super::*;

            /// `VK_AMD_gpu_shader_half_float`
            pub const NAME: &'static CStr = c!("VK_AMD_gpu_shader_half_float");
        }

        /// `VK_AMD_shader_ballot`
        pub mod shader_ballot {
            use super::*;

            /// `VK_AMD_shader_ballot`
            pub const NAME: &'static CStr = c!("VK_AMD_shader_ballot");
        }

        /// `VK_AMD_texture_gather_bias_lod`
        pub mod texture_gather_bias_lod {
            use super::*;

            /// `VK_AMD_texture_gather_bias_lod`
            pub const NAME: &'static CStr = c!("VK_AMD_texture_gather_bias_lod");
        }

        /// `VK_AMD_shader_info`
        pub mod shader_info {
            use super::*;

            /// `VK_AMD_shader_info`
            pub const NAME: &'static CStr = c!("VK_AMD_shader_info");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkGetShaderInfoAMD: PFN_vkGetShaderInfoAMD,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkGetShaderInfoAMD: get(c!("vkGetShaderInfoAMD")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkGetShaderInfoAMD`
                pub unsafe fn GetShaderInfoAMD(&self, device: VkDevice, pipeline: VkPipeline, shaderStage: VkShaderStageFlags, infoType: VkShaderInfoTypeAMD, pInfoSize: *mut size_t, pInfo: *mut void) -> VkResult {
                    unsafe { (self.vkGetShaderInfoAMD.expect("Unable to load vkGetShaderInfoAMD"))(device, pipeline, shaderStage, infoType, pInfoSize, pInfo) }
                }
            }
        }

        /// `VK_AMD_shader_image_load_store_lod`
        pub mod shader_image_load_store_lod {
            use super::*;

            /// `VK_AMD_shader_image_load_store_lod`
            pub const NAME: &'static CStr = c!("VK_AMD_shader_image_load_store_lod");
        }

        /// `VK_AMD_gpu_shader_int16`
        pub mod gpu_shader_int16 {
            use super::*;

            /// `VK_AMD_gpu_shader_int16`
            pub const NAME: &'static CStr = c!("VK_AMD_gpu_shader_int16");
        }

        /// `VK_AMD_mixed_attachment_samples`
        pub mod mixed_attachment_samples {
            use super::*;

            /// `VK_AMD_mixed_attachment_samples`
            pub const NAME: &'static CStr = c!("VK_AMD_mixed_attachment_samples");
        }

        /// `VK_AMD_shader_fragment_mask`
        pub mod shader_fragment_mask {
            use super::*;

            /// `VK_AMD_shader_fragment_mask`
            pub const NAME: &'static CStr = c!("VK_AMD_shader_fragment_mask");
        }

        /// `VK_AMD_buffer_marker`
        pub mod buffer_marker {
            use super::*;

            /// `VK_AMD_buffer_marker`
            pub const NAME: &'static CStr = c!("VK_AMD_buffer_marker");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkCmdWriteBufferMarker2AMD: PFN_vkCmdWriteBufferMarker2AMD,
                pub vkCmdWriteBufferMarkerAMD: PFN_vkCmdWriteBufferMarkerAMD,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkCmdWriteBufferMarker2AMD: get(c!("vkCmdWriteBufferMarker2AMD")).map(|a| a.cast()),
                        vkCmdWriteBufferMarkerAMD: get(c!("vkCmdWriteBufferMarkerAMD")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkCmdWriteBufferMarker2AMD`
                pub unsafe fn CmdWriteBufferMarker2AMD(&self, commandBuffer: VkCommandBuffer, stage: VkPipelineStageFlags2, dstBuffer: VkBuffer, dstOffset: VkDeviceSize, marker: uint32_t) -> () {
                    unsafe { (self.vkCmdWriteBufferMarker2AMD.expect("Unable to load vkCmdWriteBufferMarker2AMD"))(commandBuffer, stage, dstBuffer, dstOffset, marker) }
                }
                /// `vkCmdWriteBufferMarkerAMD`
                pub unsafe fn CmdWriteBufferMarkerAMD(&self, commandBuffer: VkCommandBuffer, pipelineStage: VkPipelineStageFlags, dstBuffer: VkBuffer, dstOffset: VkDeviceSize, marker: uint32_t) -> () {
                    unsafe { (self.vkCmdWriteBufferMarkerAMD.expect("Unable to load vkCmdWriteBufferMarkerAMD"))(commandBuffer, pipelineStage, dstBuffer, dstOffset, marker) }
                }
            }
        }

        /// `VK_AMD_pipeline_compiler_control`
        pub mod pipeline_compiler_control {
            use super::*;

            /// `VK_AMD_pipeline_compiler_control`
            pub const NAME: &'static CStr = c!("VK_AMD_pipeline_compiler_control");
        }

        /// `VK_AMD_shader_core_properties`
        pub mod shader_core_properties {
            use super::*;

            /// `VK_AMD_shader_core_properties`
            pub const NAME: &'static CStr = c!("VK_AMD_shader_core_properties");
        }

        /// `VK_AMD_memory_overallocation_behavior`
        pub mod memory_overallocation_behavior {
            use super::*;

            /// `VK_AMD_memory_overallocation_behavior`
            pub const NAME: &'static CStr = c!("VK_AMD_memory_overallocation_behavior");
        }

        /// `VK_AMD_display_native_hdr`
        pub mod display_native_hdr {
            use super::*;

            /// `VK_AMD_display_native_hdr`
            pub const NAME: &'static CStr = c!("VK_AMD_display_native_hdr");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkSetLocalDimmingAMD: PFN_vkSetLocalDimmingAMD,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkSetLocalDimmingAMD: get(c!("vkSetLocalDimmingAMD")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkSetLocalDimmingAMD`
                pub unsafe fn SetLocalDimmingAMD(&self, device: VkDevice, swapChain: VkSwapchainKHR, localDimmingEnable: VkBool32) -> () {
                    unsafe { (self.vkSetLocalDimmingAMD.expect("Unable to load vkSetLocalDimmingAMD"))(device, swapChain, localDimmingEnable) }
                }
            }
        }

        /// `VK_AMD_shader_core_properties2`
        pub mod shader_core_properties2 {
            use super::*;

            /// `VK_AMD_shader_core_properties2`
            pub const NAME: &'static CStr = c!("VK_AMD_shader_core_properties2");
        }

        /// `VK_AMD_device_coherent_memory`
        pub mod device_coherent_memory {
            use super::*;

            /// `VK_AMD_device_coherent_memory`
            pub const NAME: &'static CStr = c!("VK_AMD_device_coherent_memory");
        }

        /// `VK_AMD_shader_early_and_late_fragment_tests`
        pub mod shader_early_and_late_fragment_tests {
            use super::*;

            /// `VK_AMD_shader_early_and_late_fragment_tests`
            pub const NAME: &'static CStr = c!("VK_AMD_shader_early_and_late_fragment_tests");
        }

        /// `VK_AMD_anti_lag`
        pub mod anti_lag {
            use super::*;

            /// `VK_AMD_anti_lag`
            pub const NAME: &'static CStr = c!("VK_AMD_anti_lag");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkAntiLagUpdateAMD: PFN_vkAntiLagUpdateAMD,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkAntiLagUpdateAMD: get(c!("vkAntiLagUpdateAMD")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkAntiLagUpdateAMD`
                pub unsafe fn AntiLagUpdateAMD(&self, device: VkDevice, pData: *const VkAntiLagDataAMD) -> () {
                    unsafe { (self.vkAntiLagUpdateAMD.expect("Unable to load vkAntiLagUpdateAMD"))(device, pData) }
                }
            }
        }
    }
    /// `AMDX` prefix extensions
    pub mod amdx {
        use core::ffi::CStr;
        use crate::loader::*;
        use crate::ffi::*;
        use crate::*;

        /// `VK_AMDX_shader_enqueue`
        pub mod shader_enqueue {
            use super::*;

            /// `VK_AMDX_shader_enqueue`
            pub const NAME: &'static CStr = c!("VK_AMDX_shader_enqueue");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkCmdDispatchGraphAMDX: PFN_vkCmdDispatchGraphAMDX,
                pub vkCmdDispatchGraphIndirectAMDX: PFN_vkCmdDispatchGraphIndirectAMDX,
                pub vkCmdDispatchGraphIndirectCountAMDX: PFN_vkCmdDispatchGraphIndirectCountAMDX,
                pub vkCmdInitializeGraphScratchMemoryAMDX: PFN_vkCmdInitializeGraphScratchMemoryAMDX,
                pub vkCreateExecutionGraphPipelinesAMDX: PFN_vkCreateExecutionGraphPipelinesAMDX,
                pub vkGetExecutionGraphPipelineNodeIndexAMDX: PFN_vkGetExecutionGraphPipelineNodeIndexAMDX,
                pub vkGetExecutionGraphPipelineScratchSizeAMDX: PFN_vkGetExecutionGraphPipelineScratchSizeAMDX,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkCmdDispatchGraphAMDX: get(c!("vkCmdDispatchGraphAMDX")).map(|a| a.cast()),
                        vkCmdDispatchGraphIndirectAMDX: get(c!("vkCmdDispatchGraphIndirectAMDX")).map(|a| a.cast()),
                        vkCmdDispatchGraphIndirectCountAMDX: get(c!("vkCmdDispatchGraphIndirectCountAMDX")).map(|a| a.cast()),
                        vkCmdInitializeGraphScratchMemoryAMDX: get(c!("vkCmdInitializeGraphScratchMemoryAMDX")).map(|a| a.cast()),
                        vkCreateExecutionGraphPipelinesAMDX: get(c!("vkCreateExecutionGraphPipelinesAMDX")).map(|a| a.cast()),
                        vkGetExecutionGraphPipelineNodeIndexAMDX: get(c!("vkGetExecutionGraphPipelineNodeIndexAMDX")).map(|a| a.cast()),
                        vkGetExecutionGraphPipelineScratchSizeAMDX: get(c!("vkGetExecutionGraphPipelineScratchSizeAMDX")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkCmdDispatchGraphAMDX`
                pub unsafe fn CmdDispatchGraphAMDX(&self, commandBuffer: VkCommandBuffer, scratch: VkDeviceAddress, scratchSize: VkDeviceSize, pCountInfo: *const VkDispatchGraphCountInfoAMDX) -> () {
                    unsafe { (self.vkCmdDispatchGraphAMDX.expect("Unable to load vkCmdDispatchGraphAMDX"))(commandBuffer, scratch, scratchSize, pCountInfo) }
                }
                /// `vkCmdDispatchGraphIndirectAMDX`
                pub unsafe fn CmdDispatchGraphIndirectAMDX(&self, commandBuffer: VkCommandBuffer, scratch: VkDeviceAddress, scratchSize: VkDeviceSize, pCountInfo: *const VkDispatchGraphCountInfoAMDX) -> () {
                    unsafe { (self.vkCmdDispatchGraphIndirectAMDX.expect("Unable to load vkCmdDispatchGraphIndirectAMDX"))(commandBuffer, scratch, scratchSize, pCountInfo) }
                }
                /// `vkCmdDispatchGraphIndirectCountAMDX`
                pub unsafe fn CmdDispatchGraphIndirectCountAMDX(&self, commandBuffer: VkCommandBuffer, scratch: VkDeviceAddress, scratchSize: VkDeviceSize, countInfo: VkDeviceAddress) -> () {
                    unsafe { (self.vkCmdDispatchGraphIndirectCountAMDX.expect("Unable to load vkCmdDispatchGraphIndirectCountAMDX"))(commandBuffer, scratch, scratchSize, countInfo) }
                }
                /// `vkCmdInitializeGraphScratchMemoryAMDX`
                pub unsafe fn CmdInitializeGraphScratchMemoryAMDX(&self, commandBuffer: VkCommandBuffer, executionGraph: VkPipeline, scratch: VkDeviceAddress, scratchSize: VkDeviceSize) -> () {
                    unsafe { (self.vkCmdInitializeGraphScratchMemoryAMDX.expect("Unable to load vkCmdInitializeGraphScratchMemoryAMDX"))(commandBuffer, executionGraph, scratch, scratchSize) }
                }
                /// `vkCreateExecutionGraphPipelinesAMDX`
                pub unsafe fn CreateExecutionGraphPipelinesAMDX(&self, device: VkDevice, pipelineCache: VkPipelineCache, createInfoCount: uint32_t, pCreateInfos: *const VkExecutionGraphPipelineCreateInfoAMDX, pAllocator: *const VkAllocationCallbacks, pPipelines: *mut VkPipeline) -> VkResult {
                    unsafe { (self.vkCreateExecutionGraphPipelinesAMDX.expect("Unable to load vkCreateExecutionGraphPipelinesAMDX"))(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines) }
                }
                /// `vkGetExecutionGraphPipelineNodeIndexAMDX`
                pub unsafe fn GetExecutionGraphPipelineNodeIndexAMDX(&self, device: VkDevice, executionGraph: VkPipeline, pNodeInfo: *const VkPipelineShaderStageNodeCreateInfoAMDX, pNodeIndex: *mut uint32_t) -> VkResult {
                    unsafe { (self.vkGetExecutionGraphPipelineNodeIndexAMDX.expect("Unable to load vkGetExecutionGraphPipelineNodeIndexAMDX"))(device, executionGraph, pNodeInfo, pNodeIndex) }
                }
                /// `vkGetExecutionGraphPipelineScratchSizeAMDX`
                pub unsafe fn GetExecutionGraphPipelineScratchSizeAMDX(&self, device: VkDevice, executionGraph: VkPipeline, pSizeInfo: *mut VkExecutionGraphPipelineScratchSizeAMDX) -> VkResult {
                    unsafe { (self.vkGetExecutionGraphPipelineScratchSizeAMDX.expect("Unable to load vkGetExecutionGraphPipelineScratchSizeAMDX"))(device, executionGraph, pSizeInfo) }
                }
            }
        }

        /// `VK_AMDX_dense_geometry_format`
        pub mod dense_geometry_format {
            use super::*;

            /// `VK_AMDX_dense_geometry_format`
            pub const NAME: &'static CStr = c!("VK_AMDX_dense_geometry_format");
        }
    }
    /// `ANDROID` prefix extensions
    pub mod android {
        use core::ffi::CStr;
        use crate::loader::*;
        use crate::ffi::*;
        use crate::*;

        /// `VK_ANDROID_external_memory_android_hardware_buffer`
        pub mod external_memory_android_hardware_buffer {
            use super::*;

            /// `VK_ANDROID_external_memory_android_hardware_buffer`
            pub const NAME: &'static CStr = c!("VK_ANDROID_external_memory_android_hardware_buffer");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkGetAndroidHardwareBufferPropertiesANDROID: PFN_vkGetAndroidHardwareBufferPropertiesANDROID,
                pub vkGetMemoryAndroidHardwareBufferANDROID: PFN_vkGetMemoryAndroidHardwareBufferANDROID,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkGetAndroidHardwareBufferPropertiesANDROID: get(c!("vkGetAndroidHardwareBufferPropertiesANDROID")).map(|a| a.cast()),
                        vkGetMemoryAndroidHardwareBufferANDROID: get(c!("vkGetMemoryAndroidHardwareBufferANDROID")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkGetAndroidHardwareBufferPropertiesANDROID`
                pub unsafe fn GetAndroidHardwareBufferPropertiesANDROID(&self, device: VkDevice, buffer: *const AHardwareBuffer, pProperties: *mut VkAndroidHardwareBufferPropertiesANDROID) -> VkResult {
                    unsafe { (self.vkGetAndroidHardwareBufferPropertiesANDROID.expect("Unable to load vkGetAndroidHardwareBufferPropertiesANDROID"))(device, buffer, pProperties) }
                }
                /// `vkGetMemoryAndroidHardwareBufferANDROID`
                pub unsafe fn GetMemoryAndroidHardwareBufferANDROID(&self, device: VkDevice, pInfo: *const VkMemoryGetAndroidHardwareBufferInfoANDROID, pBuffer: *mut *mut AHardwareBuffer) -> VkResult {
                    unsafe { (self.vkGetMemoryAndroidHardwareBufferANDROID.expect("Unable to load vkGetMemoryAndroidHardwareBufferANDROID"))(device, pInfo, pBuffer) }
                }
            }
        }

        /// `VK_ANDROID_external_format_resolve`
        pub mod external_format_resolve {
            use super::*;

            /// `VK_ANDROID_external_format_resolve`
            pub const NAME: &'static CStr = c!("VK_ANDROID_external_format_resolve");
        }
    }
    /// `ARM` prefix extensions
    pub mod arm {
        use core::ffi::CStr;
        use crate::loader::*;
        use crate::ffi::*;
        use crate::*;

        /// `VK_ARM_rasterization_order_attachment_access`
        pub mod rasterization_order_attachment_access {
            use super::*;

            /// `VK_ARM_rasterization_order_attachment_access`
            pub const NAME: &'static CStr = c!("VK_ARM_rasterization_order_attachment_access");
        }

        /// `VK_ARM_shader_core_properties`
        pub mod shader_core_properties {
            use super::*;

            /// `VK_ARM_shader_core_properties`
            pub const NAME: &'static CStr = c!("VK_ARM_shader_core_properties");
        }

        /// `VK_ARM_scheduling_controls`
        pub mod scheduling_controls {
            use super::*;

            /// `VK_ARM_scheduling_controls`
            pub const NAME: &'static CStr = c!("VK_ARM_scheduling_controls");
        }

        /// `VK_ARM_render_pass_striped`
        pub mod render_pass_striped {
            use super::*;

            /// `VK_ARM_render_pass_striped`
            pub const NAME: &'static CStr = c!("VK_ARM_render_pass_striped");
        }

        /// `VK_ARM_tensors`
        pub mod tensors {
            use super::*;

            /// `VK_ARM_tensors`
            pub const NAME: &'static CStr = c!("VK_ARM_tensors");

            /// InstanceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct InstanceCommands {
                pub vkGetPhysicalDeviceExternalTensorPropertiesARM: PFN_vkGetPhysicalDeviceExternalTensorPropertiesARM,
            }

            impl InstanceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkGetPhysicalDeviceExternalTensorPropertiesARM: get(c!("vkGetPhysicalDeviceExternalTensorPropertiesARM")).map(|a| a.cast()),
                    } }
                }
            }

            impl InstanceCommands {
                /// `vkGetPhysicalDeviceExternalTensorPropertiesARM`
                pub unsafe fn GetPhysicalDeviceExternalTensorPropertiesARM(&self, physicalDevice: VkPhysicalDevice, pExternalTensorInfo: *const VkPhysicalDeviceExternalTensorInfoARM, pExternalTensorProperties: *mut VkExternalTensorPropertiesARM) -> () {
                    unsafe { (self.vkGetPhysicalDeviceExternalTensorPropertiesARM.expect("Unable to load vkGetPhysicalDeviceExternalTensorPropertiesARM"))(physicalDevice, pExternalTensorInfo, pExternalTensorProperties) }
                }
            }

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkBindTensorMemoryARM: PFN_vkBindTensorMemoryARM,
                pub vkCmdCopyTensorARM: PFN_vkCmdCopyTensorARM,
                pub vkCreateTensorARM: PFN_vkCreateTensorARM,
                pub vkCreateTensorViewARM: PFN_vkCreateTensorViewARM,
                pub vkDestroyTensorARM: PFN_vkDestroyTensorARM,
                pub vkDestroyTensorViewARM: PFN_vkDestroyTensorViewARM,
                pub vkGetDeviceTensorMemoryRequirementsARM: PFN_vkGetDeviceTensorMemoryRequirementsARM,
                pub vkGetTensorMemoryRequirementsARM: PFN_vkGetTensorMemoryRequirementsARM,
                pub vkGetTensorOpaqueCaptureDescriptorDataARM: PFN_vkGetTensorOpaqueCaptureDescriptorDataARM,
                pub vkGetTensorViewOpaqueCaptureDescriptorDataARM: PFN_vkGetTensorViewOpaqueCaptureDescriptorDataARM,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkBindTensorMemoryARM: get(c!("vkBindTensorMemoryARM")).map(|a| a.cast()),
                        vkCmdCopyTensorARM: get(c!("vkCmdCopyTensorARM")).map(|a| a.cast()),
                        vkCreateTensorARM: get(c!("vkCreateTensorARM")).map(|a| a.cast()),
                        vkCreateTensorViewARM: get(c!("vkCreateTensorViewARM")).map(|a| a.cast()),
                        vkDestroyTensorARM: get(c!("vkDestroyTensorARM")).map(|a| a.cast()),
                        vkDestroyTensorViewARM: get(c!("vkDestroyTensorViewARM")).map(|a| a.cast()),
                        vkGetDeviceTensorMemoryRequirementsARM: get(c!("vkGetDeviceTensorMemoryRequirementsARM")).map(|a| a.cast()),
                        vkGetTensorMemoryRequirementsARM: get(c!("vkGetTensorMemoryRequirementsARM")).map(|a| a.cast()),
                        vkGetTensorOpaqueCaptureDescriptorDataARM: get(c!("vkGetTensorOpaqueCaptureDescriptorDataARM")).map(|a| a.cast()),
                        vkGetTensorViewOpaqueCaptureDescriptorDataARM: get(c!("vkGetTensorViewOpaqueCaptureDescriptorDataARM")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkBindTensorMemoryARM`
                pub unsafe fn BindTensorMemoryARM(&self, device: VkDevice, bindInfoCount: uint32_t, pBindInfos: *const VkBindTensorMemoryInfoARM) -> VkResult {
                    unsafe { (self.vkBindTensorMemoryARM.expect("Unable to load vkBindTensorMemoryARM"))(device, bindInfoCount, pBindInfos) }
                }
                /// `vkCmdCopyTensorARM`
                pub unsafe fn CmdCopyTensorARM(&self, commandBuffer: VkCommandBuffer, pCopyTensorInfo: *const VkCopyTensorInfoARM) -> () {
                    unsafe { (self.vkCmdCopyTensorARM.expect("Unable to load vkCmdCopyTensorARM"))(commandBuffer, pCopyTensorInfo) }
                }
                /// `vkCreateTensorARM`
                pub unsafe fn CreateTensorARM(&self, device: VkDevice, pCreateInfo: *const VkTensorCreateInfoARM, pAllocator: *const VkAllocationCallbacks, pTensor: *mut VkTensorARM) -> VkResult {
                    unsafe { (self.vkCreateTensorARM.expect("Unable to load vkCreateTensorARM"))(device, pCreateInfo, pAllocator, pTensor) }
                }
                /// `vkCreateTensorViewARM`
                pub unsafe fn CreateTensorViewARM(&self, device: VkDevice, pCreateInfo: *const VkTensorViewCreateInfoARM, pAllocator: *const VkAllocationCallbacks, pView: *mut VkTensorViewARM) -> VkResult {
                    unsafe { (self.vkCreateTensorViewARM.expect("Unable to load vkCreateTensorViewARM"))(device, pCreateInfo, pAllocator, pView) }
                }
                /// `vkDestroyTensorARM`
                pub unsafe fn DestroyTensorARM(&self, device: VkDevice, tensor: VkTensorARM, pAllocator: *const VkAllocationCallbacks) -> () {
                    unsafe { (self.vkDestroyTensorARM.expect("Unable to load vkDestroyTensorARM"))(device, tensor, pAllocator) }
                }
                /// `vkDestroyTensorViewARM`
                pub unsafe fn DestroyTensorViewARM(&self, device: VkDevice, tensorView: VkTensorViewARM, pAllocator: *const VkAllocationCallbacks) -> () {
                    unsafe { (self.vkDestroyTensorViewARM.expect("Unable to load vkDestroyTensorViewARM"))(device, tensorView, pAllocator) }
                }
                /// `vkGetDeviceTensorMemoryRequirementsARM`
                pub unsafe fn GetDeviceTensorMemoryRequirementsARM(&self, device: VkDevice, pInfo: *const VkDeviceTensorMemoryRequirementsARM, pMemoryRequirements: *mut VkMemoryRequirements2) -> () {
                    unsafe { (self.vkGetDeviceTensorMemoryRequirementsARM.expect("Unable to load vkGetDeviceTensorMemoryRequirementsARM"))(device, pInfo, pMemoryRequirements) }
                }
                /// `vkGetTensorMemoryRequirementsARM`
                pub unsafe fn GetTensorMemoryRequirementsARM(&self, device: VkDevice, pInfo: *const VkTensorMemoryRequirementsInfoARM, pMemoryRequirements: *mut VkMemoryRequirements2) -> () {
                    unsafe { (self.vkGetTensorMemoryRequirementsARM.expect("Unable to load vkGetTensorMemoryRequirementsARM"))(device, pInfo, pMemoryRequirements) }
                }
                /// `vkGetTensorOpaqueCaptureDescriptorDataARM`
                pub unsafe fn GetTensorOpaqueCaptureDescriptorDataARM(&self, device: VkDevice, pInfo: *const VkTensorCaptureDescriptorDataInfoARM, pData: *mut void) -> VkResult {
                    unsafe { (self.vkGetTensorOpaqueCaptureDescriptorDataARM.expect("Unable to load vkGetTensorOpaqueCaptureDescriptorDataARM"))(device, pInfo, pData) }
                }
                /// `vkGetTensorViewOpaqueCaptureDescriptorDataARM`
                pub unsafe fn GetTensorViewOpaqueCaptureDescriptorDataARM(&self, device: VkDevice, pInfo: *const VkTensorViewCaptureDescriptorDataInfoARM, pData: *mut void) -> VkResult {
                    unsafe { (self.vkGetTensorViewOpaqueCaptureDescriptorDataARM.expect("Unable to load vkGetTensorViewOpaqueCaptureDescriptorDataARM"))(device, pInfo, pData) }
                }
            }
        }

        /// `VK_ARM_shader_core_builtins`
        pub mod shader_core_builtins {
            use super::*;

            /// `VK_ARM_shader_core_builtins`
            pub const NAME: &'static CStr = c!("VK_ARM_shader_core_builtins");
        }

        /// `VK_ARM_data_graph`
        pub mod data_graph {
            use super::*;

            /// `VK_ARM_data_graph`
            pub const NAME: &'static CStr = c!("VK_ARM_data_graph");

            /// InstanceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct InstanceCommands {
                pub vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM: PFN_vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM,
                pub vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM: PFN_vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM,
            }

            impl InstanceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM: get(c!("vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM")).map(|a| a.cast()),
                        vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM: get(c!("vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM")).map(|a| a.cast()),
                    } }
                }
            }

            impl InstanceCommands {
                /// `vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM`
                pub unsafe fn GetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM(&self, physicalDevice: VkPhysicalDevice, pQueueFamilyDataGraphProcessingEngineInfo: *const VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM, pQueueFamilyDataGraphProcessingEngineProperties: *mut VkQueueFamilyDataGraphProcessingEnginePropertiesARM) -> () {
                    unsafe { (self.vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM.expect("Unable to load vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM"))(physicalDevice, pQueueFamilyDataGraphProcessingEngineInfo, pQueueFamilyDataGraphProcessingEngineProperties) }
                }
                /// `vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM`
                pub unsafe fn GetPhysicalDeviceQueueFamilyDataGraphPropertiesARM(&self, physicalDevice: VkPhysicalDevice, queueFamilyIndex: uint32_t, pQueueFamilyDataGraphPropertyCount: *mut uint32_t, pQueueFamilyDataGraphProperties: *mut VkQueueFamilyDataGraphPropertiesARM) -> VkResult {
                    unsafe { (self.vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM.expect("Unable to load vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM"))(physicalDevice, queueFamilyIndex, pQueueFamilyDataGraphPropertyCount, pQueueFamilyDataGraphProperties) }
                }
            }

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkBindDataGraphPipelineSessionMemoryARM: PFN_vkBindDataGraphPipelineSessionMemoryARM,
                pub vkCmdDispatchDataGraphARM: PFN_vkCmdDispatchDataGraphARM,
                pub vkCreateDataGraphPipelineSessionARM: PFN_vkCreateDataGraphPipelineSessionARM,
                pub vkCreateDataGraphPipelinesARM: PFN_vkCreateDataGraphPipelinesARM,
                pub vkDestroyDataGraphPipelineSessionARM: PFN_vkDestroyDataGraphPipelineSessionARM,
                pub vkGetDataGraphPipelineAvailablePropertiesARM: PFN_vkGetDataGraphPipelineAvailablePropertiesARM,
                pub vkGetDataGraphPipelinePropertiesARM: PFN_vkGetDataGraphPipelinePropertiesARM,
                pub vkGetDataGraphPipelineSessionBindPointRequirementsARM: PFN_vkGetDataGraphPipelineSessionBindPointRequirementsARM,
                pub vkGetDataGraphPipelineSessionMemoryRequirementsARM: PFN_vkGetDataGraphPipelineSessionMemoryRequirementsARM,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkBindDataGraphPipelineSessionMemoryARM: get(c!("vkBindDataGraphPipelineSessionMemoryARM")).map(|a| a.cast()),
                        vkCmdDispatchDataGraphARM: get(c!("vkCmdDispatchDataGraphARM")).map(|a| a.cast()),
                        vkCreateDataGraphPipelineSessionARM: get(c!("vkCreateDataGraphPipelineSessionARM")).map(|a| a.cast()),
                        vkCreateDataGraphPipelinesARM: get(c!("vkCreateDataGraphPipelinesARM")).map(|a| a.cast()),
                        vkDestroyDataGraphPipelineSessionARM: get(c!("vkDestroyDataGraphPipelineSessionARM")).map(|a| a.cast()),
                        vkGetDataGraphPipelineAvailablePropertiesARM: get(c!("vkGetDataGraphPipelineAvailablePropertiesARM")).map(|a| a.cast()),
                        vkGetDataGraphPipelinePropertiesARM: get(c!("vkGetDataGraphPipelinePropertiesARM")).map(|a| a.cast()),
                        vkGetDataGraphPipelineSessionBindPointRequirementsARM: get(c!("vkGetDataGraphPipelineSessionBindPointRequirementsARM")).map(|a| a.cast()),
                        vkGetDataGraphPipelineSessionMemoryRequirementsARM: get(c!("vkGetDataGraphPipelineSessionMemoryRequirementsARM")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkBindDataGraphPipelineSessionMemoryARM`
                pub unsafe fn BindDataGraphPipelineSessionMemoryARM(&self, device: VkDevice, bindInfoCount: uint32_t, pBindInfos: *const VkBindDataGraphPipelineSessionMemoryInfoARM) -> VkResult {
                    unsafe { (self.vkBindDataGraphPipelineSessionMemoryARM.expect("Unable to load vkBindDataGraphPipelineSessionMemoryARM"))(device, bindInfoCount, pBindInfos) }
                }
                /// `vkCmdDispatchDataGraphARM`
                pub unsafe fn CmdDispatchDataGraphARM(&self, commandBuffer: VkCommandBuffer, session: VkDataGraphPipelineSessionARM, pInfo: *const VkDataGraphPipelineDispatchInfoARM) -> () {
                    unsafe { (self.vkCmdDispatchDataGraphARM.expect("Unable to load vkCmdDispatchDataGraphARM"))(commandBuffer, session, pInfo) }
                }
                /// `vkCreateDataGraphPipelineSessionARM`
                pub unsafe fn CreateDataGraphPipelineSessionARM(&self, device: VkDevice, pCreateInfo: *const VkDataGraphPipelineSessionCreateInfoARM, pAllocator: *const VkAllocationCallbacks, pSession: *mut VkDataGraphPipelineSessionARM) -> VkResult {
                    unsafe { (self.vkCreateDataGraphPipelineSessionARM.expect("Unable to load vkCreateDataGraphPipelineSessionARM"))(device, pCreateInfo, pAllocator, pSession) }
                }
                /// `vkCreateDataGraphPipelinesARM`
                pub unsafe fn CreateDataGraphPipelinesARM(&self, device: VkDevice, deferredOperation: VkDeferredOperationKHR, pipelineCache: VkPipelineCache, createInfoCount: uint32_t, pCreateInfos: *const VkDataGraphPipelineCreateInfoARM, pAllocator: *const VkAllocationCallbacks, pPipelines: *mut VkPipeline) -> VkResult {
                    unsafe { (self.vkCreateDataGraphPipelinesARM.expect("Unable to load vkCreateDataGraphPipelinesARM"))(device, deferredOperation, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines) }
                }
                /// `vkDestroyDataGraphPipelineSessionARM`
                pub unsafe fn DestroyDataGraphPipelineSessionARM(&self, device: VkDevice, session: VkDataGraphPipelineSessionARM, pAllocator: *const VkAllocationCallbacks) -> () {
                    unsafe { (self.vkDestroyDataGraphPipelineSessionARM.expect("Unable to load vkDestroyDataGraphPipelineSessionARM"))(device, session, pAllocator) }
                }
                /// `vkGetDataGraphPipelineAvailablePropertiesARM`
                pub unsafe fn GetDataGraphPipelineAvailablePropertiesARM(&self, device: VkDevice, pPipelineInfo: *const VkDataGraphPipelineInfoARM, pPropertiesCount: *mut uint32_t, pProperties: *mut VkDataGraphPipelinePropertyARM) -> VkResult {
                    unsafe { (self.vkGetDataGraphPipelineAvailablePropertiesARM.expect("Unable to load vkGetDataGraphPipelineAvailablePropertiesARM"))(device, pPipelineInfo, pPropertiesCount, pProperties) }
                }
                /// `vkGetDataGraphPipelinePropertiesARM`
                pub unsafe fn GetDataGraphPipelinePropertiesARM(&self, device: VkDevice, pPipelineInfo: *const VkDataGraphPipelineInfoARM, propertiesCount: uint32_t, pProperties: *mut VkDataGraphPipelinePropertyQueryResultARM) -> VkResult {
                    unsafe { (self.vkGetDataGraphPipelinePropertiesARM.expect("Unable to load vkGetDataGraphPipelinePropertiesARM"))(device, pPipelineInfo, propertiesCount, pProperties) }
                }
                /// `vkGetDataGraphPipelineSessionBindPointRequirementsARM`
                pub unsafe fn GetDataGraphPipelineSessionBindPointRequirementsARM(&self, device: VkDevice, pInfo: *const VkDataGraphPipelineSessionBindPointRequirementsInfoARM, pBindPointRequirementCount: *mut uint32_t, pBindPointRequirements: *mut VkDataGraphPipelineSessionBindPointRequirementARM) -> VkResult {
                    unsafe { (self.vkGetDataGraphPipelineSessionBindPointRequirementsARM.expect("Unable to load vkGetDataGraphPipelineSessionBindPointRequirementsARM"))(device, pInfo, pBindPointRequirementCount, pBindPointRequirements) }
                }
                /// `vkGetDataGraphPipelineSessionMemoryRequirementsARM`
                pub unsafe fn GetDataGraphPipelineSessionMemoryRequirementsARM(&self, device: VkDevice, pInfo: *const VkDataGraphPipelineSessionMemoryRequirementsInfoARM, pMemoryRequirements: *mut VkMemoryRequirements2) -> () {
                    unsafe { (self.vkGetDataGraphPipelineSessionMemoryRequirementsARM.expect("Unable to load vkGetDataGraphPipelineSessionMemoryRequirementsARM"))(device, pInfo, pMemoryRequirements) }
                }
            }
        }

        /// `VK_ARM_pipeline_opacity_micromap`
        pub mod pipeline_opacity_micromap {
            use super::*;

            /// `VK_ARM_pipeline_opacity_micromap`
            pub const NAME: &'static CStr = c!("VK_ARM_pipeline_opacity_micromap");
        }

        /// `VK_ARM_performance_counters_by_region`
        pub mod performance_counters_by_region {
            use super::*;

            /// `VK_ARM_performance_counters_by_region`
            pub const NAME: &'static CStr = c!("VK_ARM_performance_counters_by_region");

            /// InstanceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct InstanceCommands {
                pub vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM: PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM,
            }

            impl InstanceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM: get(c!("vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM")).map(|a| a.cast()),
                    } }
                }
            }

            impl InstanceCommands {
                /// `vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM`
                pub unsafe fn EnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM(&self, physicalDevice: VkPhysicalDevice, queueFamilyIndex: uint32_t, pCounterCount: *mut uint32_t, pCounters: *mut VkPerformanceCounterARM, pCounterDescriptions: *mut VkPerformanceCounterDescriptionARM) -> VkResult {
                    unsafe { (self.vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM.expect("Unable to load vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM"))(physicalDevice, queueFamilyIndex, pCounterCount, pCounters, pCounterDescriptions) }
                }
            }
        }

        /// `VK_ARM_shader_instrumentation`
        pub mod shader_instrumentation {
            use super::*;

            /// `VK_ARM_shader_instrumentation`
            pub const NAME: &'static CStr = c!("VK_ARM_shader_instrumentation");

            /// InstanceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct InstanceCommands {
                pub vkEnumeratePhysicalDeviceShaderInstrumentationMetricsARM: PFN_vkEnumeratePhysicalDeviceShaderInstrumentationMetricsARM,
            }

            impl InstanceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkEnumeratePhysicalDeviceShaderInstrumentationMetricsARM: get(c!("vkEnumeratePhysicalDeviceShaderInstrumentationMetricsARM")).map(|a| a.cast()),
                    } }
                }
            }

            impl InstanceCommands {
                /// `vkEnumeratePhysicalDeviceShaderInstrumentationMetricsARM`
                pub unsafe fn EnumeratePhysicalDeviceShaderInstrumentationMetricsARM(&self, physicalDevice: VkPhysicalDevice, pDescriptionCount: *mut uint32_t, pDescriptions: *mut VkShaderInstrumentationMetricDescriptionARM) -> VkResult {
                    unsafe { (self.vkEnumeratePhysicalDeviceShaderInstrumentationMetricsARM.expect("Unable to load vkEnumeratePhysicalDeviceShaderInstrumentationMetricsARM"))(physicalDevice, pDescriptionCount, pDescriptions) }
                }
            }

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkClearShaderInstrumentationMetricsARM: PFN_vkClearShaderInstrumentationMetricsARM,
                pub vkCmdBeginShaderInstrumentationARM: PFN_vkCmdBeginShaderInstrumentationARM,
                pub vkCmdEndShaderInstrumentationARM: PFN_vkCmdEndShaderInstrumentationARM,
                pub vkCreateShaderInstrumentationARM: PFN_vkCreateShaderInstrumentationARM,
                pub vkDestroyShaderInstrumentationARM: PFN_vkDestroyShaderInstrumentationARM,
                pub vkGetShaderInstrumentationValuesARM: PFN_vkGetShaderInstrumentationValuesARM,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkClearShaderInstrumentationMetricsARM: get(c!("vkClearShaderInstrumentationMetricsARM")).map(|a| a.cast()),
                        vkCmdBeginShaderInstrumentationARM: get(c!("vkCmdBeginShaderInstrumentationARM")).map(|a| a.cast()),
                        vkCmdEndShaderInstrumentationARM: get(c!("vkCmdEndShaderInstrumentationARM")).map(|a| a.cast()),
                        vkCreateShaderInstrumentationARM: get(c!("vkCreateShaderInstrumentationARM")).map(|a| a.cast()),
                        vkDestroyShaderInstrumentationARM: get(c!("vkDestroyShaderInstrumentationARM")).map(|a| a.cast()),
                        vkGetShaderInstrumentationValuesARM: get(c!("vkGetShaderInstrumentationValuesARM")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkClearShaderInstrumentationMetricsARM`
                pub unsafe fn ClearShaderInstrumentationMetricsARM(&self, device: VkDevice, instrumentation: VkShaderInstrumentationARM) -> () {
                    unsafe { (self.vkClearShaderInstrumentationMetricsARM.expect("Unable to load vkClearShaderInstrumentationMetricsARM"))(device, instrumentation) }
                }
                /// `vkCmdBeginShaderInstrumentationARM`
                pub unsafe fn CmdBeginShaderInstrumentationARM(&self, commandBuffer: VkCommandBuffer, instrumentation: VkShaderInstrumentationARM) -> () {
                    unsafe { (self.vkCmdBeginShaderInstrumentationARM.expect("Unable to load vkCmdBeginShaderInstrumentationARM"))(commandBuffer, instrumentation) }
                }
                /// `vkCmdEndShaderInstrumentationARM`
                pub unsafe fn CmdEndShaderInstrumentationARM(&self, commandBuffer: VkCommandBuffer) -> () {
                    unsafe { (self.vkCmdEndShaderInstrumentationARM.expect("Unable to load vkCmdEndShaderInstrumentationARM"))(commandBuffer) }
                }
                /// `vkCreateShaderInstrumentationARM`
                pub unsafe fn CreateShaderInstrumentationARM(&self, device: VkDevice, pCreateInfo: *const VkShaderInstrumentationCreateInfoARM, pAllocator: *const VkAllocationCallbacks, pInstrumentation: *mut VkShaderInstrumentationARM) -> VkResult {
                    unsafe { (self.vkCreateShaderInstrumentationARM.expect("Unable to load vkCreateShaderInstrumentationARM"))(device, pCreateInfo, pAllocator, pInstrumentation) }
                }
                /// `vkDestroyShaderInstrumentationARM`
                pub unsafe fn DestroyShaderInstrumentationARM(&self, device: VkDevice, instrumentation: VkShaderInstrumentationARM, pAllocator: *const VkAllocationCallbacks) -> () {
                    unsafe { (self.vkDestroyShaderInstrumentationARM.expect("Unable to load vkDestroyShaderInstrumentationARM"))(device, instrumentation, pAllocator) }
                }
                /// `vkGetShaderInstrumentationValuesARM`
                pub unsafe fn GetShaderInstrumentationValuesARM(&self, device: VkDevice, instrumentation: VkShaderInstrumentationARM, pMetricBlockCount: *mut uint32_t, pMetricValues: *mut void, flags: VkShaderInstrumentationValuesFlagsARM) -> VkResult {
                    unsafe { (self.vkGetShaderInstrumentationValuesARM.expect("Unable to load vkGetShaderInstrumentationValuesARM"))(device, instrumentation, pMetricBlockCount, pMetricValues, flags) }
                }
            }
        }

        /// `VK_ARM_format_pack`
        pub mod format_pack {
            use super::*;

            /// `VK_ARM_format_pack`
            pub const NAME: &'static CStr = c!("VK_ARM_format_pack");
        }
    }
    /// `EXT` prefix extensions
    pub mod ext {
        use core::ffi::CStr;
        use crate::loader::*;
        use crate::ffi::*;
        use crate::*;

        /// `VK_EXT_debug_report`
        pub mod debug_report {
            use super::*;

            /// `VK_EXT_debug_report`
            pub const NAME: &'static CStr = c!("VK_EXT_debug_report");

            /// InstanceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct InstanceCommands {
                pub vkCreateDebugReportCallbackEXT: PFN_vkCreateDebugReportCallbackEXT,
                pub vkDebugReportMessageEXT: PFN_vkDebugReportMessageEXT,
                pub vkDestroyDebugReportCallbackEXT: PFN_vkDestroyDebugReportCallbackEXT,
            }

            impl InstanceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkCreateDebugReportCallbackEXT: get(c!("vkCreateDebugReportCallbackEXT")).map(|a| a.cast()),
                        vkDebugReportMessageEXT: get(c!("vkDebugReportMessageEXT")).map(|a| a.cast()),
                        vkDestroyDebugReportCallbackEXT: get(c!("vkDestroyDebugReportCallbackEXT")).map(|a| a.cast()),
                    } }
                }
            }

            impl InstanceCommands {
                /// `vkCreateDebugReportCallbackEXT`
                pub unsafe fn CreateDebugReportCallbackEXT(&self, instance: VkInstance, pCreateInfo: *const VkDebugReportCallbackCreateInfoEXT, pAllocator: *const VkAllocationCallbacks, pCallback: *mut VkDebugReportCallbackEXT) -> VkResult {
                    unsafe { (self.vkCreateDebugReportCallbackEXT.expect("Unable to load vkCreateDebugReportCallbackEXT"))(instance, pCreateInfo, pAllocator, pCallback) }
                }
                /// `vkDebugReportMessageEXT`
                pub unsafe fn DebugReportMessageEXT(&self, instance: VkInstance, flags: VkDebugReportFlagsEXT, objectType: VkDebugReportObjectTypeEXT, object: uint64_t, location: size_t, messageCode: int32_t, pLayerPrefix: *const c_char, pMessage: *const c_char) -> () {
                    unsafe { (self.vkDebugReportMessageEXT.expect("Unable to load vkDebugReportMessageEXT"))(instance, flags, objectType, object, location, messageCode, pLayerPrefix, pMessage) }
                }
                /// `vkDestroyDebugReportCallbackEXT`
                pub unsafe fn DestroyDebugReportCallbackEXT(&self, instance: VkInstance, callback: VkDebugReportCallbackEXT, pAllocator: *const VkAllocationCallbacks) -> () {
                    unsafe { (self.vkDestroyDebugReportCallbackEXT.expect("Unable to load vkDestroyDebugReportCallbackEXT"))(instance, callback, pAllocator) }
                }
            }
        }

        /// `VK_EXT_depth_range_unrestricted`
        pub mod depth_range_unrestricted {
            use super::*;

            /// `VK_EXT_depth_range_unrestricted`
            pub const NAME: &'static CStr = c!("VK_EXT_depth_range_unrestricted");
        }

        /// `VK_EXT_debug_marker`
        pub mod debug_marker {
            use super::*;

            /// `VK_EXT_debug_marker`
            pub const NAME: &'static CStr = c!("VK_EXT_debug_marker");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkCmdDebugMarkerBeginEXT: PFN_vkCmdDebugMarkerBeginEXT,
                pub vkCmdDebugMarkerEndEXT: PFN_vkCmdDebugMarkerEndEXT,
                pub vkCmdDebugMarkerInsertEXT: PFN_vkCmdDebugMarkerInsertEXT,
                pub vkDebugMarkerSetObjectNameEXT: PFN_vkDebugMarkerSetObjectNameEXT,
                pub vkDebugMarkerSetObjectTagEXT: PFN_vkDebugMarkerSetObjectTagEXT,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkCmdDebugMarkerBeginEXT: get(c!("vkCmdDebugMarkerBeginEXT")).map(|a| a.cast()),
                        vkCmdDebugMarkerEndEXT: get(c!("vkCmdDebugMarkerEndEXT")).map(|a| a.cast()),
                        vkCmdDebugMarkerInsertEXT: get(c!("vkCmdDebugMarkerInsertEXT")).map(|a| a.cast()),
                        vkDebugMarkerSetObjectNameEXT: get(c!("vkDebugMarkerSetObjectNameEXT")).map(|a| a.cast()),
                        vkDebugMarkerSetObjectTagEXT: get(c!("vkDebugMarkerSetObjectTagEXT")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkCmdDebugMarkerBeginEXT`
                pub unsafe fn CmdDebugMarkerBeginEXT(&self, commandBuffer: VkCommandBuffer, pMarkerInfo: *const VkDebugMarkerMarkerInfoEXT) -> () {
                    unsafe { (self.vkCmdDebugMarkerBeginEXT.expect("Unable to load vkCmdDebugMarkerBeginEXT"))(commandBuffer, pMarkerInfo) }
                }
                /// `vkCmdDebugMarkerEndEXT`
                pub unsafe fn CmdDebugMarkerEndEXT(&self, commandBuffer: VkCommandBuffer) -> () {
                    unsafe { (self.vkCmdDebugMarkerEndEXT.expect("Unable to load vkCmdDebugMarkerEndEXT"))(commandBuffer) }
                }
                /// `vkCmdDebugMarkerInsertEXT`
                pub unsafe fn CmdDebugMarkerInsertEXT(&self, commandBuffer: VkCommandBuffer, pMarkerInfo: *const VkDebugMarkerMarkerInfoEXT) -> () {
                    unsafe { (self.vkCmdDebugMarkerInsertEXT.expect("Unable to load vkCmdDebugMarkerInsertEXT"))(commandBuffer, pMarkerInfo) }
                }
                /// `vkDebugMarkerSetObjectNameEXT`
                pub unsafe fn DebugMarkerSetObjectNameEXT(&self, device: VkDevice, pNameInfo: *const VkDebugMarkerObjectNameInfoEXT) -> VkResult {
                    unsafe { (self.vkDebugMarkerSetObjectNameEXT.expect("Unable to load vkDebugMarkerSetObjectNameEXT"))(device, pNameInfo) }
                }
                /// `vkDebugMarkerSetObjectTagEXT`
                pub unsafe fn DebugMarkerSetObjectTagEXT(&self, device: VkDevice, pTagInfo: *const VkDebugMarkerObjectTagInfoEXT) -> VkResult {
                    unsafe { (self.vkDebugMarkerSetObjectTagEXT.expect("Unable to load vkDebugMarkerSetObjectTagEXT"))(device, pTagInfo) }
                }
            }
        }

        /// `VK_EXT_transform_feedback`
        pub mod transform_feedback {
            use super::*;

            /// `VK_EXT_transform_feedback`
            pub const NAME: &'static CStr = c!("VK_EXT_transform_feedback");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkCmdBeginQueryIndexedEXT: PFN_vkCmdBeginQueryIndexedEXT,
                pub vkCmdBeginTransformFeedbackEXT: PFN_vkCmdBeginTransformFeedbackEXT,
                pub vkCmdBindTransformFeedbackBuffersEXT: PFN_vkCmdBindTransformFeedbackBuffersEXT,
                pub vkCmdDrawIndirectByteCountEXT: PFN_vkCmdDrawIndirectByteCountEXT,
                pub vkCmdEndQueryIndexedEXT: PFN_vkCmdEndQueryIndexedEXT,
                pub vkCmdEndTransformFeedbackEXT: PFN_vkCmdEndTransformFeedbackEXT,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkCmdBeginQueryIndexedEXT: get(c!("vkCmdBeginQueryIndexedEXT")).map(|a| a.cast()),
                        vkCmdBeginTransformFeedbackEXT: get(c!("vkCmdBeginTransformFeedbackEXT")).map(|a| a.cast()),
                        vkCmdBindTransformFeedbackBuffersEXT: get(c!("vkCmdBindTransformFeedbackBuffersEXT")).map(|a| a.cast()),
                        vkCmdDrawIndirectByteCountEXT: get(c!("vkCmdDrawIndirectByteCountEXT")).map(|a| a.cast()),
                        vkCmdEndQueryIndexedEXT: get(c!("vkCmdEndQueryIndexedEXT")).map(|a| a.cast()),
                        vkCmdEndTransformFeedbackEXT: get(c!("vkCmdEndTransformFeedbackEXT")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkCmdBeginQueryIndexedEXT`
                pub unsafe fn CmdBeginQueryIndexedEXT(&self, commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, query: uint32_t, flags: VkQueryControlFlags, index: uint32_t) -> () {
                    unsafe { (self.vkCmdBeginQueryIndexedEXT.expect("Unable to load vkCmdBeginQueryIndexedEXT"))(commandBuffer, queryPool, query, flags, index) }
                }
                /// `vkCmdBeginTransformFeedbackEXT`
                pub unsafe fn CmdBeginTransformFeedbackEXT(&self, commandBuffer: VkCommandBuffer, firstCounterBuffer: uint32_t, counterBufferCount: uint32_t, pCounterBuffers: *const VkBuffer, pCounterBufferOffsets: *const VkDeviceSize) -> () {
                    unsafe { (self.vkCmdBeginTransformFeedbackEXT.expect("Unable to load vkCmdBeginTransformFeedbackEXT"))(commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets) }
                }
                /// `vkCmdBindTransformFeedbackBuffersEXT`
                pub unsafe fn CmdBindTransformFeedbackBuffersEXT(&self, commandBuffer: VkCommandBuffer, firstBinding: uint32_t, bindingCount: uint32_t, pBuffers: *const VkBuffer, pOffsets: *const VkDeviceSize, pSizes: *const VkDeviceSize) -> () {
                    unsafe { (self.vkCmdBindTransformFeedbackBuffersEXT.expect("Unable to load vkCmdBindTransformFeedbackBuffersEXT"))(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes) }
                }
                /// `vkCmdDrawIndirectByteCountEXT`
                pub unsafe fn CmdDrawIndirectByteCountEXT(&self, commandBuffer: VkCommandBuffer, instanceCount: uint32_t, firstInstance: uint32_t, counterBuffer: VkBuffer, counterBufferOffset: VkDeviceSize, counterOffset: uint32_t, vertexStride: uint32_t) -> () {
                    unsafe { (self.vkCmdDrawIndirectByteCountEXT.expect("Unable to load vkCmdDrawIndirectByteCountEXT"))(commandBuffer, instanceCount, firstInstance, counterBuffer, counterBufferOffset, counterOffset, vertexStride) }
                }
                /// `vkCmdEndQueryIndexedEXT`
                pub unsafe fn CmdEndQueryIndexedEXT(&self, commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, query: uint32_t, index: uint32_t) -> () {
                    unsafe { (self.vkCmdEndQueryIndexedEXT.expect("Unable to load vkCmdEndQueryIndexedEXT"))(commandBuffer, queryPool, query, index) }
                }
                /// `vkCmdEndTransformFeedbackEXT`
                pub unsafe fn CmdEndTransformFeedbackEXT(&self, commandBuffer: VkCommandBuffer, firstCounterBuffer: uint32_t, counterBufferCount: uint32_t, pCounterBuffers: *const VkBuffer, pCounterBufferOffsets: *const VkDeviceSize) -> () {
                    unsafe { (self.vkCmdEndTransformFeedbackEXT.expect("Unable to load vkCmdEndTransformFeedbackEXT"))(commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets) }
                }
            }
        }

        /// `VK_EXT_validation_flags`
        pub mod validation_flags {
            use super::*;

            /// `VK_EXT_validation_flags`
            pub const NAME: &'static CStr = c!("VK_EXT_validation_flags");
        }

        /// `VK_EXT_shader_subgroup_ballot`
        pub mod shader_subgroup_ballot {
            use super::*;

            /// `VK_EXT_shader_subgroup_ballot`
            pub const NAME: &'static CStr = c!("VK_EXT_shader_subgroup_ballot");
        }

        /// `VK_EXT_shader_subgroup_vote`
        pub mod shader_subgroup_vote {
            use super::*;

            /// `VK_EXT_shader_subgroup_vote`
            pub const NAME: &'static CStr = c!("VK_EXT_shader_subgroup_vote");
        }

        /// `VK_EXT_texture_compression_astc_hdr`
        pub mod texture_compression_astc_hdr {
            use super::*;

            /// `VK_EXT_texture_compression_astc_hdr`
            pub const NAME: &'static CStr = c!("VK_EXT_texture_compression_astc_hdr");
        }

        /// `VK_EXT_astc_decode_mode`
        pub mod astc_decode_mode {
            use super::*;

            /// `VK_EXT_astc_decode_mode`
            pub const NAME: &'static CStr = c!("VK_EXT_astc_decode_mode");
        }

        /// `VK_EXT_pipeline_robustness`
        pub mod pipeline_robustness {
            use super::*;

            /// `VK_EXT_pipeline_robustness`
            pub const NAME: &'static CStr = c!("VK_EXT_pipeline_robustness");
        }

        /// `VK_EXT_conditional_rendering`
        pub mod conditional_rendering {
            use super::*;

            /// `VK_EXT_conditional_rendering`
            pub const NAME: &'static CStr = c!("VK_EXT_conditional_rendering");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkCmdBeginConditionalRenderingEXT: PFN_vkCmdBeginConditionalRenderingEXT,
                pub vkCmdEndConditionalRenderingEXT: PFN_vkCmdEndConditionalRenderingEXT,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkCmdBeginConditionalRenderingEXT: get(c!("vkCmdBeginConditionalRenderingEXT")).map(|a| a.cast()),
                        vkCmdEndConditionalRenderingEXT: get(c!("vkCmdEndConditionalRenderingEXT")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkCmdBeginConditionalRenderingEXT`
                pub unsafe fn CmdBeginConditionalRenderingEXT(&self, commandBuffer: VkCommandBuffer, pConditionalRenderingBegin: *const VkConditionalRenderingBeginInfoEXT) -> () {
                    unsafe { (self.vkCmdBeginConditionalRenderingEXT.expect("Unable to load vkCmdBeginConditionalRenderingEXT"))(commandBuffer, pConditionalRenderingBegin) }
                }
                /// `vkCmdEndConditionalRenderingEXT`
                pub unsafe fn CmdEndConditionalRenderingEXT(&self, commandBuffer: VkCommandBuffer) -> () {
                    unsafe { (self.vkCmdEndConditionalRenderingEXT.expect("Unable to load vkCmdEndConditionalRenderingEXT"))(commandBuffer) }
                }
            }
        }

        /// `VK_EXT_direct_mode_display`
        pub mod direct_mode_display {
            use super::*;

            /// `VK_EXT_direct_mode_display`
            pub const NAME: &'static CStr = c!("VK_EXT_direct_mode_display");

            /// InstanceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct InstanceCommands {
                pub vkReleaseDisplayEXT: PFN_vkReleaseDisplayEXT,
            }

            impl InstanceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkReleaseDisplayEXT: get(c!("vkReleaseDisplayEXT")).map(|a| a.cast()),
                    } }
                }
            }

            impl InstanceCommands {
                /// `vkReleaseDisplayEXT`
                pub unsafe fn ReleaseDisplayEXT(&self, physicalDevice: VkPhysicalDevice, display: VkDisplayKHR) -> VkResult {
                    unsafe { (self.vkReleaseDisplayEXT.expect("Unable to load vkReleaseDisplayEXT"))(physicalDevice, display) }
                }
            }
        }

        /// `VK_EXT_acquire_xlib_display`
        pub mod acquire_xlib_display {
            use super::*;

            /// `VK_EXT_acquire_xlib_display`
            pub const NAME: &'static CStr = c!("VK_EXT_acquire_xlib_display");

            /// InstanceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct InstanceCommands {
                pub vkAcquireXlibDisplayEXT: PFN_vkAcquireXlibDisplayEXT,
                pub vkGetRandROutputDisplayEXT: PFN_vkGetRandROutputDisplayEXT,
            }

            impl InstanceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkAcquireXlibDisplayEXT: get(c!("vkAcquireXlibDisplayEXT")).map(|a| a.cast()),
                        vkGetRandROutputDisplayEXT: get(c!("vkGetRandROutputDisplayEXT")).map(|a| a.cast()),
                    } }
                }
            }

            impl InstanceCommands {
                /// `vkAcquireXlibDisplayEXT`
                pub unsafe fn AcquireXlibDisplayEXT(&self, physicalDevice: VkPhysicalDevice, dpy: *mut Display, display: VkDisplayKHR) -> VkResult {
                    unsafe { (self.vkAcquireXlibDisplayEXT.expect("Unable to load vkAcquireXlibDisplayEXT"))(physicalDevice, dpy, display) }
                }
                /// `vkGetRandROutputDisplayEXT`
                pub unsafe fn GetRandROutputDisplayEXT(&self, physicalDevice: VkPhysicalDevice, dpy: *mut Display, rrOutput: RROutput, pDisplay: *mut VkDisplayKHR) -> VkResult {
                    unsafe { (self.vkGetRandROutputDisplayEXT.expect("Unable to load vkGetRandROutputDisplayEXT"))(physicalDevice, dpy, rrOutput, pDisplay) }
                }
            }
        }

        /// `VK_EXT_display_surface_counter`
        pub mod display_surface_counter {
            use super::*;

            /// `VK_EXT_display_surface_counter`
            pub const NAME: &'static CStr = c!("VK_EXT_display_surface_counter");

            /// InstanceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct InstanceCommands {
                pub vkGetPhysicalDeviceSurfaceCapabilities2EXT: PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT,
            }

            impl InstanceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkGetPhysicalDeviceSurfaceCapabilities2EXT: get(c!("vkGetPhysicalDeviceSurfaceCapabilities2EXT")).map(|a| a.cast()),
                    } }
                }
            }

            impl InstanceCommands {
                /// `vkGetPhysicalDeviceSurfaceCapabilities2EXT`
                pub unsafe fn GetPhysicalDeviceSurfaceCapabilities2EXT(&self, physicalDevice: VkPhysicalDevice, surface: VkSurfaceKHR, pSurfaceCapabilities: *mut VkSurfaceCapabilities2EXT) -> VkResult {
                    unsafe { (self.vkGetPhysicalDeviceSurfaceCapabilities2EXT.expect("Unable to load vkGetPhysicalDeviceSurfaceCapabilities2EXT"))(physicalDevice, surface, pSurfaceCapabilities) }
                }
            }
        }

        /// `VK_EXT_display_control`
        pub mod display_control {
            use super::*;

            /// `VK_EXT_display_control`
            pub const NAME: &'static CStr = c!("VK_EXT_display_control");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkDisplayPowerControlEXT: PFN_vkDisplayPowerControlEXT,
                pub vkGetSwapchainCounterEXT: PFN_vkGetSwapchainCounterEXT,
                pub vkRegisterDeviceEventEXT: PFN_vkRegisterDeviceEventEXT,
                pub vkRegisterDisplayEventEXT: PFN_vkRegisterDisplayEventEXT,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkDisplayPowerControlEXT: get(c!("vkDisplayPowerControlEXT")).map(|a| a.cast()),
                        vkGetSwapchainCounterEXT: get(c!("vkGetSwapchainCounterEXT")).map(|a| a.cast()),
                        vkRegisterDeviceEventEXT: get(c!("vkRegisterDeviceEventEXT")).map(|a| a.cast()),
                        vkRegisterDisplayEventEXT: get(c!("vkRegisterDisplayEventEXT")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkDisplayPowerControlEXT`
                pub unsafe fn DisplayPowerControlEXT(&self, device: VkDevice, display: VkDisplayKHR, pDisplayPowerInfo: *const VkDisplayPowerInfoEXT) -> VkResult {
                    unsafe { (self.vkDisplayPowerControlEXT.expect("Unable to load vkDisplayPowerControlEXT"))(device, display, pDisplayPowerInfo) }
                }
                /// `vkGetSwapchainCounterEXT`
                pub unsafe fn GetSwapchainCounterEXT(&self, device: VkDevice, swapchain: VkSwapchainKHR, counter: VkSurfaceCounterFlagsEXT, pCounterValue: *mut uint64_t) -> VkResult {
                    unsafe { (self.vkGetSwapchainCounterEXT.expect("Unable to load vkGetSwapchainCounterEXT"))(device, swapchain, counter, pCounterValue) }
                }
                /// `vkRegisterDeviceEventEXT`
                pub unsafe fn RegisterDeviceEventEXT(&self, device: VkDevice, pDeviceEventInfo: *const VkDeviceEventInfoEXT, pAllocator: *const VkAllocationCallbacks, pFence: *mut VkFence) -> VkResult {
                    unsafe { (self.vkRegisterDeviceEventEXT.expect("Unable to load vkRegisterDeviceEventEXT"))(device, pDeviceEventInfo, pAllocator, pFence) }
                }
                /// `vkRegisterDisplayEventEXT`
                pub unsafe fn RegisterDisplayEventEXT(&self, device: VkDevice, display: VkDisplayKHR, pDisplayEventInfo: *const VkDisplayEventInfoEXT, pAllocator: *const VkAllocationCallbacks, pFence: *mut VkFence) -> VkResult {
                    unsafe { (self.vkRegisterDisplayEventEXT.expect("Unable to load vkRegisterDisplayEventEXT"))(device, display, pDisplayEventInfo, pAllocator, pFence) }
                }
            }
        }

        /// `VK_EXT_discard_rectangles`
        pub mod discard_rectangles {
            use super::*;

            /// `VK_EXT_discard_rectangles`
            pub const NAME: &'static CStr = c!("VK_EXT_discard_rectangles");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkCmdSetDiscardRectangleEXT: PFN_vkCmdSetDiscardRectangleEXT,
                pub vkCmdSetDiscardRectangleEnableEXT: PFN_vkCmdSetDiscardRectangleEnableEXT,
                pub vkCmdSetDiscardRectangleModeEXT: PFN_vkCmdSetDiscardRectangleModeEXT,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkCmdSetDiscardRectangleEXT: get(c!("vkCmdSetDiscardRectangleEXT")).map(|a| a.cast()),
                        vkCmdSetDiscardRectangleEnableEXT: get(c!("vkCmdSetDiscardRectangleEnableEXT")).map(|a| a.cast()),
                        vkCmdSetDiscardRectangleModeEXT: get(c!("vkCmdSetDiscardRectangleModeEXT")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkCmdSetDiscardRectangleEXT`
                pub unsafe fn CmdSetDiscardRectangleEXT(&self, commandBuffer: VkCommandBuffer, firstDiscardRectangle: uint32_t, discardRectangleCount: uint32_t, pDiscardRectangles: *const VkRect2D) -> () {
                    unsafe { (self.vkCmdSetDiscardRectangleEXT.expect("Unable to load vkCmdSetDiscardRectangleEXT"))(commandBuffer, firstDiscardRectangle, discardRectangleCount, pDiscardRectangles) }
                }
                /// `vkCmdSetDiscardRectangleEnableEXT`
                pub unsafe fn CmdSetDiscardRectangleEnableEXT(&self, commandBuffer: VkCommandBuffer, discardRectangleEnable: VkBool32) -> () {
                    unsafe { (self.vkCmdSetDiscardRectangleEnableEXT.expect("Unable to load vkCmdSetDiscardRectangleEnableEXT"))(commandBuffer, discardRectangleEnable) }
                }
                /// `vkCmdSetDiscardRectangleModeEXT`
                pub unsafe fn CmdSetDiscardRectangleModeEXT(&self, commandBuffer: VkCommandBuffer, discardRectangleMode: VkDiscardRectangleModeEXT) -> () {
                    unsafe { (self.vkCmdSetDiscardRectangleModeEXT.expect("Unable to load vkCmdSetDiscardRectangleModeEXT"))(commandBuffer, discardRectangleMode) }
                }
            }
        }

        /// `VK_EXT_conservative_rasterization`
        pub mod conservative_rasterization {
            use super::*;

            /// `VK_EXT_conservative_rasterization`
            pub const NAME: &'static CStr = c!("VK_EXT_conservative_rasterization");
        }

        /// `VK_EXT_depth_clip_enable`
        pub mod depth_clip_enable {
            use super::*;

            /// `VK_EXT_depth_clip_enable`
            pub const NAME: &'static CStr = c!("VK_EXT_depth_clip_enable");
        }

        /// `VK_EXT_swapchain_colorspace`
        pub mod swapchain_colorspace {
            use super::*;

            /// `VK_EXT_swapchain_colorspace`
            pub const NAME: &'static CStr = c!("VK_EXT_swapchain_colorspace");
        }

        /// `VK_EXT_hdr_metadata`
        pub mod hdr_metadata {
            use super::*;

            /// `VK_EXT_hdr_metadata`
            pub const NAME: &'static CStr = c!("VK_EXT_hdr_metadata");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkSetHdrMetadataEXT: PFN_vkSetHdrMetadataEXT,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkSetHdrMetadataEXT: get(c!("vkSetHdrMetadataEXT")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkSetHdrMetadataEXT`
                pub unsafe fn SetHdrMetadataEXT(&self, device: VkDevice, swapchainCount: uint32_t, pSwapchains: *const VkSwapchainKHR, pMetadata: *const VkHdrMetadataEXT) -> () {
                    unsafe { (self.vkSetHdrMetadataEXT.expect("Unable to load vkSetHdrMetadataEXT"))(device, swapchainCount, pSwapchains, pMetadata) }
                }
            }
        }

        /// `VK_EXT_external_memory_dma_buf`
        pub mod external_memory_dma_buf {
            use super::*;

            /// `VK_EXT_external_memory_dma_buf`
            pub const NAME: &'static CStr = c!("VK_EXT_external_memory_dma_buf");
        }

        /// `VK_EXT_queue_family_foreign`
        pub mod queue_family_foreign {
            use super::*;

            /// `VK_EXT_queue_family_foreign`
            pub const NAME: &'static CStr = c!("VK_EXT_queue_family_foreign");
        }

        /// `VK_EXT_debug_utils`
        pub mod debug_utils {
            use super::*;

            /// `VK_EXT_debug_utils`
            pub const NAME: &'static CStr = c!("VK_EXT_debug_utils");

            /// InstanceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct InstanceCommands {
                pub vkCreateDebugUtilsMessengerEXT: PFN_vkCreateDebugUtilsMessengerEXT,
                pub vkDestroyDebugUtilsMessengerEXT: PFN_vkDestroyDebugUtilsMessengerEXT,
                pub vkSubmitDebugUtilsMessageEXT: PFN_vkSubmitDebugUtilsMessageEXT,
            }

            impl InstanceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkCreateDebugUtilsMessengerEXT: get(c!("vkCreateDebugUtilsMessengerEXT")).map(|a| a.cast()),
                        vkDestroyDebugUtilsMessengerEXT: get(c!("vkDestroyDebugUtilsMessengerEXT")).map(|a| a.cast()),
                        vkSubmitDebugUtilsMessageEXT: get(c!("vkSubmitDebugUtilsMessageEXT")).map(|a| a.cast()),
                    } }
                }
            }

            impl InstanceCommands {
                /// `vkCreateDebugUtilsMessengerEXT`
                pub unsafe fn CreateDebugUtilsMessengerEXT(&self, instance: VkInstance, pCreateInfo: *const VkDebugUtilsMessengerCreateInfoEXT, pAllocator: *const VkAllocationCallbacks, pMessenger: *mut VkDebugUtilsMessengerEXT) -> VkResult {
                    unsafe { (self.vkCreateDebugUtilsMessengerEXT.expect("Unable to load vkCreateDebugUtilsMessengerEXT"))(instance, pCreateInfo, pAllocator, pMessenger) }
                }
                /// `vkDestroyDebugUtilsMessengerEXT`
                pub unsafe fn DestroyDebugUtilsMessengerEXT(&self, instance: VkInstance, messenger: VkDebugUtilsMessengerEXT, pAllocator: *const VkAllocationCallbacks) -> () {
                    unsafe { (self.vkDestroyDebugUtilsMessengerEXT.expect("Unable to load vkDestroyDebugUtilsMessengerEXT"))(instance, messenger, pAllocator) }
                }
                /// `vkSubmitDebugUtilsMessageEXT`
                pub unsafe fn SubmitDebugUtilsMessageEXT(&self, instance: VkInstance, messageSeverity: VkDebugUtilsMessageSeverityFlagsEXT, messageTypes: VkDebugUtilsMessageTypeFlagsEXT, pCallbackData: *const VkDebugUtilsMessengerCallbackDataEXT) -> () {
                    unsafe { (self.vkSubmitDebugUtilsMessageEXT.expect("Unable to load vkSubmitDebugUtilsMessageEXT"))(instance, messageSeverity, messageTypes, pCallbackData) }
                }
            }

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkCmdBeginDebugUtilsLabelEXT: PFN_vkCmdBeginDebugUtilsLabelEXT,
                pub vkCmdEndDebugUtilsLabelEXT: PFN_vkCmdEndDebugUtilsLabelEXT,
                pub vkCmdInsertDebugUtilsLabelEXT: PFN_vkCmdInsertDebugUtilsLabelEXT,
                pub vkQueueBeginDebugUtilsLabelEXT: PFN_vkQueueBeginDebugUtilsLabelEXT,
                pub vkQueueEndDebugUtilsLabelEXT: PFN_vkQueueEndDebugUtilsLabelEXT,
                pub vkQueueInsertDebugUtilsLabelEXT: PFN_vkQueueInsertDebugUtilsLabelEXT,
                pub vkSetDebugUtilsObjectNameEXT: PFN_vkSetDebugUtilsObjectNameEXT,
                pub vkSetDebugUtilsObjectTagEXT: PFN_vkSetDebugUtilsObjectTagEXT,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkCmdBeginDebugUtilsLabelEXT: get(c!("vkCmdBeginDebugUtilsLabelEXT")).map(|a| a.cast()),
                        vkCmdEndDebugUtilsLabelEXT: get(c!("vkCmdEndDebugUtilsLabelEXT")).map(|a| a.cast()),
                        vkCmdInsertDebugUtilsLabelEXT: get(c!("vkCmdInsertDebugUtilsLabelEXT")).map(|a| a.cast()),
                        vkQueueBeginDebugUtilsLabelEXT: get(c!("vkQueueBeginDebugUtilsLabelEXT")).map(|a| a.cast()),
                        vkQueueEndDebugUtilsLabelEXT: get(c!("vkQueueEndDebugUtilsLabelEXT")).map(|a| a.cast()),
                        vkQueueInsertDebugUtilsLabelEXT: get(c!("vkQueueInsertDebugUtilsLabelEXT")).map(|a| a.cast()),
                        vkSetDebugUtilsObjectNameEXT: get(c!("vkSetDebugUtilsObjectNameEXT")).map(|a| a.cast()),
                        vkSetDebugUtilsObjectTagEXT: get(c!("vkSetDebugUtilsObjectTagEXT")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkCmdBeginDebugUtilsLabelEXT`
                pub unsafe fn CmdBeginDebugUtilsLabelEXT(&self, commandBuffer: VkCommandBuffer, pLabelInfo: *const VkDebugUtilsLabelEXT) -> () {
                    unsafe { (self.vkCmdBeginDebugUtilsLabelEXT.expect("Unable to load vkCmdBeginDebugUtilsLabelEXT"))(commandBuffer, pLabelInfo) }
                }
                /// `vkCmdEndDebugUtilsLabelEXT`
                pub unsafe fn CmdEndDebugUtilsLabelEXT(&self, commandBuffer: VkCommandBuffer) -> () {
                    unsafe { (self.vkCmdEndDebugUtilsLabelEXT.expect("Unable to load vkCmdEndDebugUtilsLabelEXT"))(commandBuffer) }
                }
                /// `vkCmdInsertDebugUtilsLabelEXT`
                pub unsafe fn CmdInsertDebugUtilsLabelEXT(&self, commandBuffer: VkCommandBuffer, pLabelInfo: *const VkDebugUtilsLabelEXT) -> () {
                    unsafe { (self.vkCmdInsertDebugUtilsLabelEXT.expect("Unable to load vkCmdInsertDebugUtilsLabelEXT"))(commandBuffer, pLabelInfo) }
                }
                /// `vkQueueBeginDebugUtilsLabelEXT`
                pub unsafe fn QueueBeginDebugUtilsLabelEXT(&self, queue: VkQueue, pLabelInfo: *const VkDebugUtilsLabelEXT) -> () {
                    unsafe { (self.vkQueueBeginDebugUtilsLabelEXT.expect("Unable to load vkQueueBeginDebugUtilsLabelEXT"))(queue, pLabelInfo) }
                }
                /// `vkQueueEndDebugUtilsLabelEXT`
                pub unsafe fn QueueEndDebugUtilsLabelEXT(&self, queue: VkQueue) -> () {
                    unsafe { (self.vkQueueEndDebugUtilsLabelEXT.expect("Unable to load vkQueueEndDebugUtilsLabelEXT"))(queue) }
                }
                /// `vkQueueInsertDebugUtilsLabelEXT`
                pub unsafe fn QueueInsertDebugUtilsLabelEXT(&self, queue: VkQueue, pLabelInfo: *const VkDebugUtilsLabelEXT) -> () {
                    unsafe { (self.vkQueueInsertDebugUtilsLabelEXT.expect("Unable to load vkQueueInsertDebugUtilsLabelEXT"))(queue, pLabelInfo) }
                }
                /// `vkSetDebugUtilsObjectNameEXT`
                pub unsafe fn SetDebugUtilsObjectNameEXT(&self, device: VkDevice, pNameInfo: *const VkDebugUtilsObjectNameInfoEXT) -> VkResult {
                    unsafe { (self.vkSetDebugUtilsObjectNameEXT.expect("Unable to load vkSetDebugUtilsObjectNameEXT"))(device, pNameInfo) }
                }
                /// `vkSetDebugUtilsObjectTagEXT`
                pub unsafe fn SetDebugUtilsObjectTagEXT(&self, device: VkDevice, pTagInfo: *const VkDebugUtilsObjectTagInfoEXT) -> VkResult {
                    unsafe { (self.vkSetDebugUtilsObjectTagEXT.expect("Unable to load vkSetDebugUtilsObjectTagEXT"))(device, pTagInfo) }
                }
            }
        }

        /// `VK_EXT_sampler_filter_minmax`
        pub mod sampler_filter_minmax {
            use super::*;

            /// `VK_EXT_sampler_filter_minmax`
            pub const NAME: &'static CStr = c!("VK_EXT_sampler_filter_minmax");
        }

        /// `VK_EXT_descriptor_heap`
        pub mod descriptor_heap {
            use super::*;

            /// `VK_EXT_descriptor_heap`
            pub const NAME: &'static CStr = c!("VK_EXT_descriptor_heap");

            /// InstanceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct InstanceCommands {
                pub vkGetPhysicalDeviceDescriptorSizeEXT: PFN_vkGetPhysicalDeviceDescriptorSizeEXT,
            }

            impl InstanceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkGetPhysicalDeviceDescriptorSizeEXT: get(c!("vkGetPhysicalDeviceDescriptorSizeEXT")).map(|a| a.cast()),
                    } }
                }
            }

            impl InstanceCommands {
                /// `vkGetPhysicalDeviceDescriptorSizeEXT`
                pub unsafe fn GetPhysicalDeviceDescriptorSizeEXT(&self, physicalDevice: VkPhysicalDevice, descriptorType: VkDescriptorType) -> VkDeviceSize {
                    unsafe { (self.vkGetPhysicalDeviceDescriptorSizeEXT.expect("Unable to load vkGetPhysicalDeviceDescriptorSizeEXT"))(physicalDevice, descriptorType) }
                }
            }

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkCmdBindResourceHeapEXT: PFN_vkCmdBindResourceHeapEXT,
                pub vkCmdBindSamplerHeapEXT: PFN_vkCmdBindSamplerHeapEXT,
                pub vkCmdPushDataEXT: PFN_vkCmdPushDataEXT,
                pub vkGetImageOpaqueCaptureDataEXT: PFN_vkGetImageOpaqueCaptureDataEXT,
                pub vkGetTensorOpaqueCaptureDataARM: PFN_vkGetTensorOpaqueCaptureDataARM,
                pub vkRegisterCustomBorderColorEXT: PFN_vkRegisterCustomBorderColorEXT,
                pub vkUnregisterCustomBorderColorEXT: PFN_vkUnregisterCustomBorderColorEXT,
                pub vkWriteResourceDescriptorsEXT: PFN_vkWriteResourceDescriptorsEXT,
                pub vkWriteSamplerDescriptorsEXT: PFN_vkWriteSamplerDescriptorsEXT,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkCmdBindResourceHeapEXT: get(c!("vkCmdBindResourceHeapEXT")).map(|a| a.cast()),
                        vkCmdBindSamplerHeapEXT: get(c!("vkCmdBindSamplerHeapEXT")).map(|a| a.cast()),
                        vkCmdPushDataEXT: get(c!("vkCmdPushDataEXT")).map(|a| a.cast()),
                        vkGetImageOpaqueCaptureDataEXT: get(c!("vkGetImageOpaqueCaptureDataEXT")).map(|a| a.cast()),
                        vkGetTensorOpaqueCaptureDataARM: get(c!("vkGetTensorOpaqueCaptureDataARM")).map(|a| a.cast()),
                        vkRegisterCustomBorderColorEXT: get(c!("vkRegisterCustomBorderColorEXT")).map(|a| a.cast()),
                        vkUnregisterCustomBorderColorEXT: get(c!("vkUnregisterCustomBorderColorEXT")).map(|a| a.cast()),
                        vkWriteResourceDescriptorsEXT: get(c!("vkWriteResourceDescriptorsEXT")).map(|a| a.cast()),
                        vkWriteSamplerDescriptorsEXT: get(c!("vkWriteSamplerDescriptorsEXT")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkCmdBindResourceHeapEXT`
                pub unsafe fn CmdBindResourceHeapEXT(&self, commandBuffer: VkCommandBuffer, pBindInfo: *const VkBindHeapInfoEXT) -> () {
                    unsafe { (self.vkCmdBindResourceHeapEXT.expect("Unable to load vkCmdBindResourceHeapEXT"))(commandBuffer, pBindInfo) }
                }
                /// `vkCmdBindSamplerHeapEXT`
                pub unsafe fn CmdBindSamplerHeapEXT(&self, commandBuffer: VkCommandBuffer, pBindInfo: *const VkBindHeapInfoEXT) -> () {
                    unsafe { (self.vkCmdBindSamplerHeapEXT.expect("Unable to load vkCmdBindSamplerHeapEXT"))(commandBuffer, pBindInfo) }
                }
                /// `vkCmdPushDataEXT`
                pub unsafe fn CmdPushDataEXT(&self, commandBuffer: VkCommandBuffer, pPushDataInfo: *const VkPushDataInfoEXT) -> () {
                    unsafe { (self.vkCmdPushDataEXT.expect("Unable to load vkCmdPushDataEXT"))(commandBuffer, pPushDataInfo) }
                }
                /// `vkGetImageOpaqueCaptureDataEXT`
                pub unsafe fn GetImageOpaqueCaptureDataEXT(&self, device: VkDevice, imageCount: uint32_t, pImages: *const VkImage, pDatas: *mut VkHostAddressRangeEXT) -> VkResult {
                    unsafe { (self.vkGetImageOpaqueCaptureDataEXT.expect("Unable to load vkGetImageOpaqueCaptureDataEXT"))(device, imageCount, pImages, pDatas) }
                }
                /// `vkGetTensorOpaqueCaptureDataARM`
                pub unsafe fn GetTensorOpaqueCaptureDataARM(&self, device: VkDevice, tensorCount: uint32_t, pTensors: *const VkTensorARM, pDatas: *mut VkHostAddressRangeEXT) -> VkResult {
                    unsafe { (self.vkGetTensorOpaqueCaptureDataARM.expect("Unable to load vkGetTensorOpaqueCaptureDataARM"))(device, tensorCount, pTensors, pDatas) }
                }
                /// `vkRegisterCustomBorderColorEXT`
                pub unsafe fn RegisterCustomBorderColorEXT(&self, device: VkDevice, pBorderColor: *const VkSamplerCustomBorderColorCreateInfoEXT, requestIndex: VkBool32, pIndex: *mut uint32_t) -> VkResult {
                    unsafe { (self.vkRegisterCustomBorderColorEXT.expect("Unable to load vkRegisterCustomBorderColorEXT"))(device, pBorderColor, requestIndex, pIndex) }
                }
                /// `vkUnregisterCustomBorderColorEXT`
                pub unsafe fn UnregisterCustomBorderColorEXT(&self, device: VkDevice, index: uint32_t) -> () {
                    unsafe { (self.vkUnregisterCustomBorderColorEXT.expect("Unable to load vkUnregisterCustomBorderColorEXT"))(device, index) }
                }
                /// `vkWriteResourceDescriptorsEXT`
                pub unsafe fn WriteResourceDescriptorsEXT(&self, device: VkDevice, resourceCount: uint32_t, pResources: *const VkResourceDescriptorInfoEXT, pDescriptors: *const VkHostAddressRangeEXT) -> VkResult {
                    unsafe { (self.vkWriteResourceDescriptorsEXT.expect("Unable to load vkWriteResourceDescriptorsEXT"))(device, resourceCount, pResources, pDescriptors) }
                }
                /// `vkWriteSamplerDescriptorsEXT`
                pub unsafe fn WriteSamplerDescriptorsEXT(&self, device: VkDevice, samplerCount: uint32_t, pSamplers: *const VkSamplerCreateInfo, pDescriptors: *const VkHostAddressRangeEXT) -> VkResult {
                    unsafe { (self.vkWriteSamplerDescriptorsEXT.expect("Unable to load vkWriteSamplerDescriptorsEXT"))(device, samplerCount, pSamplers, pDescriptors) }
                }
            }
        }

        /// `VK_EXT_inline_uniform_block`
        pub mod inline_uniform_block {
            use super::*;

            /// `VK_EXT_inline_uniform_block`
            pub const NAME: &'static CStr = c!("VK_EXT_inline_uniform_block");
        }

        /// `VK_EXT_shader_stencil_export`
        pub mod shader_stencil_export {
            use super::*;

            /// `VK_EXT_shader_stencil_export`
            pub const NAME: &'static CStr = c!("VK_EXT_shader_stencil_export");
        }

        /// `VK_EXT_sample_locations`
        pub mod sample_locations {
            use super::*;

            /// `VK_EXT_sample_locations`
            pub const NAME: &'static CStr = c!("VK_EXT_sample_locations");

            /// InstanceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct InstanceCommands {
                pub vkGetPhysicalDeviceMultisamplePropertiesEXT: PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT,
            }

            impl InstanceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkGetPhysicalDeviceMultisamplePropertiesEXT: get(c!("vkGetPhysicalDeviceMultisamplePropertiesEXT")).map(|a| a.cast()),
                    } }
                }
            }

            impl InstanceCommands {
                /// `vkGetPhysicalDeviceMultisamplePropertiesEXT`
                pub unsafe fn GetPhysicalDeviceMultisamplePropertiesEXT(&self, physicalDevice: VkPhysicalDevice, samples: VkSampleCountFlags, pMultisampleProperties: *mut VkMultisamplePropertiesEXT) -> () {
                    unsafe { (self.vkGetPhysicalDeviceMultisamplePropertiesEXT.expect("Unable to load vkGetPhysicalDeviceMultisamplePropertiesEXT"))(physicalDevice, samples, pMultisampleProperties) }
                }
            }

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkCmdSetSampleLocationsEXT: PFN_vkCmdSetSampleLocationsEXT,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkCmdSetSampleLocationsEXT: get(c!("vkCmdSetSampleLocationsEXT")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkCmdSetSampleLocationsEXT`
                pub unsafe fn CmdSetSampleLocationsEXT(&self, commandBuffer: VkCommandBuffer, pSampleLocationsInfo: *const VkSampleLocationsInfoEXT) -> () {
                    unsafe { (self.vkCmdSetSampleLocationsEXT.expect("Unable to load vkCmdSetSampleLocationsEXT"))(commandBuffer, pSampleLocationsInfo) }
                }
            }
        }

        /// `VK_EXT_blend_operation_advanced`
        pub mod blend_operation_advanced {
            use super::*;

            /// `VK_EXT_blend_operation_advanced`
            pub const NAME: &'static CStr = c!("VK_EXT_blend_operation_advanced");
        }

        /// `VK_EXT_post_depth_coverage`
        pub mod post_depth_coverage {
            use super::*;

            /// `VK_EXT_post_depth_coverage`
            pub const NAME: &'static CStr = c!("VK_EXT_post_depth_coverage");
        }

        /// `VK_EXT_image_drm_format_modifier`
        pub mod image_drm_format_modifier {
            use super::*;

            /// `VK_EXT_image_drm_format_modifier`
            pub const NAME: &'static CStr = c!("VK_EXT_image_drm_format_modifier");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkGetImageDrmFormatModifierPropertiesEXT: PFN_vkGetImageDrmFormatModifierPropertiesEXT,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkGetImageDrmFormatModifierPropertiesEXT: get(c!("vkGetImageDrmFormatModifierPropertiesEXT")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkGetImageDrmFormatModifierPropertiesEXT`
                pub unsafe fn GetImageDrmFormatModifierPropertiesEXT(&self, device: VkDevice, image: VkImage, pProperties: *mut VkImageDrmFormatModifierPropertiesEXT) -> VkResult {
                    unsafe { (self.vkGetImageDrmFormatModifierPropertiesEXT.expect("Unable to load vkGetImageDrmFormatModifierPropertiesEXT"))(device, image, pProperties) }
                }
            }
        }

        /// `VK_EXT_validation_cache`
        pub mod validation_cache {
            use super::*;

            /// `VK_EXT_validation_cache`
            pub const NAME: &'static CStr = c!("VK_EXT_validation_cache");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkCreateValidationCacheEXT: PFN_vkCreateValidationCacheEXT,
                pub vkDestroyValidationCacheEXT: PFN_vkDestroyValidationCacheEXT,
                pub vkGetValidationCacheDataEXT: PFN_vkGetValidationCacheDataEXT,
                pub vkMergeValidationCachesEXT: PFN_vkMergeValidationCachesEXT,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkCreateValidationCacheEXT: get(c!("vkCreateValidationCacheEXT")).map(|a| a.cast()),
                        vkDestroyValidationCacheEXT: get(c!("vkDestroyValidationCacheEXT")).map(|a| a.cast()),
                        vkGetValidationCacheDataEXT: get(c!("vkGetValidationCacheDataEXT")).map(|a| a.cast()),
                        vkMergeValidationCachesEXT: get(c!("vkMergeValidationCachesEXT")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkCreateValidationCacheEXT`
                pub unsafe fn CreateValidationCacheEXT(&self, device: VkDevice, pCreateInfo: *const VkValidationCacheCreateInfoEXT, pAllocator: *const VkAllocationCallbacks, pValidationCache: *mut VkValidationCacheEXT) -> VkResult {
                    unsafe { (self.vkCreateValidationCacheEXT.expect("Unable to load vkCreateValidationCacheEXT"))(device, pCreateInfo, pAllocator, pValidationCache) }
                }
                /// `vkDestroyValidationCacheEXT`
                pub unsafe fn DestroyValidationCacheEXT(&self, device: VkDevice, validationCache: VkValidationCacheEXT, pAllocator: *const VkAllocationCallbacks) -> () {
                    unsafe { (self.vkDestroyValidationCacheEXT.expect("Unable to load vkDestroyValidationCacheEXT"))(device, validationCache, pAllocator) }
                }
                /// `vkGetValidationCacheDataEXT`
                pub unsafe fn GetValidationCacheDataEXT(&self, device: VkDevice, validationCache: VkValidationCacheEXT, pDataSize: *mut size_t, pData: *mut void) -> VkResult {
                    unsafe { (self.vkGetValidationCacheDataEXT.expect("Unable to load vkGetValidationCacheDataEXT"))(device, validationCache, pDataSize, pData) }
                }
                /// `vkMergeValidationCachesEXT`
                pub unsafe fn MergeValidationCachesEXT(&self, device: VkDevice, dstCache: VkValidationCacheEXT, srcCacheCount: uint32_t, pSrcCaches: *const VkValidationCacheEXT) -> VkResult {
                    unsafe { (self.vkMergeValidationCachesEXT.expect("Unable to load vkMergeValidationCachesEXT"))(device, dstCache, srcCacheCount, pSrcCaches) }
                }
            }
        }

        /// `VK_EXT_descriptor_indexing`
        pub mod descriptor_indexing {
            use super::*;

            /// `VK_EXT_descriptor_indexing`
            pub const NAME: &'static CStr = c!("VK_EXT_descriptor_indexing");
        }

        /// `VK_EXT_shader_viewport_index_layer`
        pub mod shader_viewport_index_layer {
            use super::*;

            /// `VK_EXT_shader_viewport_index_layer`
            pub const NAME: &'static CStr = c!("VK_EXT_shader_viewport_index_layer");
        }

        /// `VK_EXT_filter_cubic`
        pub mod filter_cubic {
            use super::*;

            /// `VK_EXT_filter_cubic`
            pub const NAME: &'static CStr = c!("VK_EXT_filter_cubic");
        }

        /// `VK_EXT_global_priority`
        pub mod global_priority {
            use super::*;

            /// `VK_EXT_global_priority`
            pub const NAME: &'static CStr = c!("VK_EXT_global_priority");
        }

        /// `VK_EXT_external_memory_host`
        pub mod external_memory_host {
            use super::*;

            /// `VK_EXT_external_memory_host`
            pub const NAME: &'static CStr = c!("VK_EXT_external_memory_host");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkGetMemoryHostPointerPropertiesEXT: PFN_vkGetMemoryHostPointerPropertiesEXT,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkGetMemoryHostPointerPropertiesEXT: get(c!("vkGetMemoryHostPointerPropertiesEXT")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkGetMemoryHostPointerPropertiesEXT`
                pub unsafe fn GetMemoryHostPointerPropertiesEXT(&self, device: VkDevice, handleType: VkExternalMemoryHandleTypeFlags, pHostPointer: *const void, pMemoryHostPointerProperties: *mut VkMemoryHostPointerPropertiesEXT) -> VkResult {
                    unsafe { (self.vkGetMemoryHostPointerPropertiesEXT.expect("Unable to load vkGetMemoryHostPointerPropertiesEXT"))(device, handleType, pHostPointer, pMemoryHostPointerProperties) }
                }
            }
        }

        /// `VK_EXT_calibrated_timestamps`
        pub mod calibrated_timestamps {
            use super::*;

            /// `VK_EXT_calibrated_timestamps`
            pub const NAME: &'static CStr = c!("VK_EXT_calibrated_timestamps");

            /// InstanceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct InstanceCommands {
                pub vkGetPhysicalDeviceCalibrateableTimeDomainsEXT: PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT,
            }

            impl InstanceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkGetPhysicalDeviceCalibrateableTimeDomainsEXT: get(c!("vkGetPhysicalDeviceCalibrateableTimeDomainsEXT")).map(|a| a.cast()),
                    } }
                }
            }

            impl InstanceCommands {
                /// `vkGetPhysicalDeviceCalibrateableTimeDomainsEXT`
                pub unsafe fn GetPhysicalDeviceCalibrateableTimeDomainsEXT(&self, physicalDevice: VkPhysicalDevice, pTimeDomainCount: *mut uint32_t, pTimeDomains: *mut VkTimeDomainKHR) -> VkResult {
                    unsafe { (self.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT.expect("Unable to load vkGetPhysicalDeviceCalibrateableTimeDomainsEXT"))(physicalDevice, pTimeDomainCount, pTimeDomains) }
                }
            }

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkGetCalibratedTimestampsEXT: PFN_vkGetCalibratedTimestampsEXT,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkGetCalibratedTimestampsEXT: get(c!("vkGetCalibratedTimestampsEXT")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkGetCalibratedTimestampsEXT`
                pub unsafe fn GetCalibratedTimestampsEXT(&self, device: VkDevice, timestampCount: uint32_t, pTimestampInfos: *const VkCalibratedTimestampInfoKHR, pTimestamps: *mut uint64_t, pMaxDeviation: *mut uint64_t) -> VkResult {
                    unsafe { (self.vkGetCalibratedTimestampsEXT.expect("Unable to load vkGetCalibratedTimestampsEXT"))(device, timestampCount, pTimestampInfos, pTimestamps, pMaxDeviation) }
                }
            }
        }

        /// `VK_EXT_vertex_attribute_divisor`
        pub mod vertex_attribute_divisor {
            use super::*;

            /// `VK_EXT_vertex_attribute_divisor`
            pub const NAME: &'static CStr = c!("VK_EXT_vertex_attribute_divisor");
        }

        /// `VK_EXT_pipeline_creation_feedback`
        pub mod pipeline_creation_feedback {
            use super::*;

            /// `VK_EXT_pipeline_creation_feedback`
            pub const NAME: &'static CStr = c!("VK_EXT_pipeline_creation_feedback");
        }

        /// `VK_EXT_present_timing`
        pub mod present_timing {
            use super::*;

            /// `VK_EXT_present_timing`
            pub const NAME: &'static CStr = c!("VK_EXT_present_timing");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkGetPastPresentationTimingEXT: PFN_vkGetPastPresentationTimingEXT,
                pub vkGetSwapchainTimeDomainPropertiesEXT: PFN_vkGetSwapchainTimeDomainPropertiesEXT,
                pub vkGetSwapchainTimingPropertiesEXT: PFN_vkGetSwapchainTimingPropertiesEXT,
                pub vkSetSwapchainPresentTimingQueueSizeEXT: PFN_vkSetSwapchainPresentTimingQueueSizeEXT,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkGetPastPresentationTimingEXT: get(c!("vkGetPastPresentationTimingEXT")).map(|a| a.cast()),
                        vkGetSwapchainTimeDomainPropertiesEXT: get(c!("vkGetSwapchainTimeDomainPropertiesEXT")).map(|a| a.cast()),
                        vkGetSwapchainTimingPropertiesEXT: get(c!("vkGetSwapchainTimingPropertiesEXT")).map(|a| a.cast()),
                        vkSetSwapchainPresentTimingQueueSizeEXT: get(c!("vkSetSwapchainPresentTimingQueueSizeEXT")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkGetPastPresentationTimingEXT`
                pub unsafe fn GetPastPresentationTimingEXT(&self, device: VkDevice, pPastPresentationTimingInfo: *const VkPastPresentationTimingInfoEXT, pPastPresentationTimingProperties: *mut VkPastPresentationTimingPropertiesEXT) -> VkResult {
                    unsafe { (self.vkGetPastPresentationTimingEXT.expect("Unable to load vkGetPastPresentationTimingEXT"))(device, pPastPresentationTimingInfo, pPastPresentationTimingProperties) }
                }
                /// `vkGetSwapchainTimeDomainPropertiesEXT`
                pub unsafe fn GetSwapchainTimeDomainPropertiesEXT(&self, device: VkDevice, swapchain: VkSwapchainKHR, pSwapchainTimeDomainProperties: *mut VkSwapchainTimeDomainPropertiesEXT, pTimeDomainsCounter: *mut uint64_t) -> VkResult {
                    unsafe { (self.vkGetSwapchainTimeDomainPropertiesEXT.expect("Unable to load vkGetSwapchainTimeDomainPropertiesEXT"))(device, swapchain, pSwapchainTimeDomainProperties, pTimeDomainsCounter) }
                }
                /// `vkGetSwapchainTimingPropertiesEXT`
                pub unsafe fn GetSwapchainTimingPropertiesEXT(&self, device: VkDevice, swapchain: VkSwapchainKHR, pSwapchainTimingProperties: *mut VkSwapchainTimingPropertiesEXT, pSwapchainTimingPropertiesCounter: *mut uint64_t) -> VkResult {
                    unsafe { (self.vkGetSwapchainTimingPropertiesEXT.expect("Unable to load vkGetSwapchainTimingPropertiesEXT"))(device, swapchain, pSwapchainTimingProperties, pSwapchainTimingPropertiesCounter) }
                }
                /// `vkSetSwapchainPresentTimingQueueSizeEXT`
                pub unsafe fn SetSwapchainPresentTimingQueueSizeEXT(&self, device: VkDevice, swapchain: VkSwapchainKHR, size: uint32_t) -> VkResult {
                    unsafe { (self.vkSetSwapchainPresentTimingQueueSizeEXT.expect("Unable to load vkSetSwapchainPresentTimingQueueSizeEXT"))(device, swapchain, size) }
                }
            }
        }

        /// `VK_EXT_pci_bus_info`
        pub mod pci_bus_info {
            use super::*;

            /// `VK_EXT_pci_bus_info`
            pub const NAME: &'static CStr = c!("VK_EXT_pci_bus_info");
        }

        /// `VK_EXT_metal_surface`
        pub mod metal_surface {
            use super::*;

            /// `VK_EXT_metal_surface`
            pub const NAME: &'static CStr = c!("VK_EXT_metal_surface");

            /// InstanceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct InstanceCommands {
                pub vkCreateMetalSurfaceEXT: PFN_vkCreateMetalSurfaceEXT,
            }

            impl InstanceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkCreateMetalSurfaceEXT: get(c!("vkCreateMetalSurfaceEXT")).map(|a| a.cast()),
                    } }
                }
            }

            impl InstanceCommands {
                /// `vkCreateMetalSurfaceEXT`
                pub unsafe fn CreateMetalSurfaceEXT(&self, instance: VkInstance, pCreateInfo: *const VkMetalSurfaceCreateInfoEXT, pAllocator: *const VkAllocationCallbacks, pSurface: *mut VkSurfaceKHR) -> VkResult {
                    unsafe { (self.vkCreateMetalSurfaceEXT.expect("Unable to load vkCreateMetalSurfaceEXT"))(instance, pCreateInfo, pAllocator, pSurface) }
                }
            }
        }

        /// `VK_EXT_fragment_density_map`
        pub mod fragment_density_map {
            use super::*;

            /// `VK_EXT_fragment_density_map`
            pub const NAME: &'static CStr = c!("VK_EXT_fragment_density_map");
        }

        /// `VK_EXT_scalar_block_layout`
        pub mod scalar_block_layout {
            use super::*;

            /// `VK_EXT_scalar_block_layout`
            pub const NAME: &'static CStr = c!("VK_EXT_scalar_block_layout");
        }

        /// `VK_EXT_subgroup_size_control`
        pub mod subgroup_size_control {
            use super::*;

            /// `VK_EXT_subgroup_size_control`
            pub const NAME: &'static CStr = c!("VK_EXT_subgroup_size_control");
        }

        /// `VK_EXT_shader_image_atomic_int64`
        pub mod shader_image_atomic_int64 {
            use super::*;

            /// `VK_EXT_shader_image_atomic_int64`
            pub const NAME: &'static CStr = c!("VK_EXT_shader_image_atomic_int64");
        }

        /// `VK_EXT_memory_budget`
        pub mod memory_budget {
            use super::*;

            /// `VK_EXT_memory_budget`
            pub const NAME: &'static CStr = c!("VK_EXT_memory_budget");
        }

        /// `VK_EXT_memory_priority`
        pub mod memory_priority {
            use super::*;

            /// `VK_EXT_memory_priority`
            pub const NAME: &'static CStr = c!("VK_EXT_memory_priority");
        }

        /// `VK_EXT_buffer_device_address`
        pub mod buffer_device_address {
            use super::*;

            /// `VK_EXT_buffer_device_address`
            pub const NAME: &'static CStr = c!("VK_EXT_buffer_device_address");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkGetBufferDeviceAddressEXT: PFN_vkGetBufferDeviceAddressEXT,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkGetBufferDeviceAddressEXT: get(c!("vkGetBufferDeviceAddressEXT")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkGetBufferDeviceAddressEXT`
                pub unsafe fn GetBufferDeviceAddressEXT(&self, device: VkDevice, pInfo: *const VkBufferDeviceAddressInfo) -> VkDeviceAddress {
                    unsafe { (self.vkGetBufferDeviceAddressEXT.expect("Unable to load vkGetBufferDeviceAddressEXT"))(device, pInfo) }
                }
            }
        }

        /// `VK_EXT_tooling_info`
        pub mod tooling_info {
            use super::*;

            /// `VK_EXT_tooling_info`
            pub const NAME: &'static CStr = c!("VK_EXT_tooling_info");

            /// InstanceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct InstanceCommands {
                pub vkGetPhysicalDeviceToolPropertiesEXT: PFN_vkGetPhysicalDeviceToolPropertiesEXT,
            }

            impl InstanceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkGetPhysicalDeviceToolPropertiesEXT: get(c!("vkGetPhysicalDeviceToolPropertiesEXT")).map(|a| a.cast()),
                    } }
                }
            }

            impl InstanceCommands {
                /// `vkGetPhysicalDeviceToolPropertiesEXT`
                pub unsafe fn GetPhysicalDeviceToolPropertiesEXT(&self, physicalDevice: VkPhysicalDevice, pToolCount: *mut uint32_t, pToolProperties: *mut VkPhysicalDeviceToolProperties) -> VkResult {
                    unsafe { (self.vkGetPhysicalDeviceToolPropertiesEXT.expect("Unable to load vkGetPhysicalDeviceToolPropertiesEXT"))(physicalDevice, pToolCount, pToolProperties) }
                }
            }
        }

        /// `VK_EXT_separate_stencil_usage`
        pub mod separate_stencil_usage {
            use super::*;

            /// `VK_EXT_separate_stencil_usage`
            pub const NAME: &'static CStr = c!("VK_EXT_separate_stencil_usage");
        }

        /// `VK_EXT_validation_features`
        pub mod validation_features {
            use super::*;

            /// `VK_EXT_validation_features`
            pub const NAME: &'static CStr = c!("VK_EXT_validation_features");
        }

        /// `VK_EXT_fragment_shader_interlock`
        pub mod fragment_shader_interlock {
            use super::*;

            /// `VK_EXT_fragment_shader_interlock`
            pub const NAME: &'static CStr = c!("VK_EXT_fragment_shader_interlock");
        }

        /// `VK_EXT_ycbcr_image_arrays`
        pub mod ycbcr_image_arrays {
            use super::*;

            /// `VK_EXT_ycbcr_image_arrays`
            pub const NAME: &'static CStr = c!("VK_EXT_ycbcr_image_arrays");
        }

        /// `VK_EXT_provoking_vertex`
        pub mod provoking_vertex {
            use super::*;

            /// `VK_EXT_provoking_vertex`
            pub const NAME: &'static CStr = c!("VK_EXT_provoking_vertex");
        }

        /// `VK_EXT_full_screen_exclusive`
        pub mod full_screen_exclusive {
            use super::*;

            /// `VK_EXT_full_screen_exclusive`
            pub const NAME: &'static CStr = c!("VK_EXT_full_screen_exclusive");

            /// InstanceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct InstanceCommands {
                pub vkGetPhysicalDeviceSurfacePresentModes2EXT: PFN_vkGetPhysicalDeviceSurfacePresentModes2EXT,
            }

            impl InstanceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkGetPhysicalDeviceSurfacePresentModes2EXT: get(c!("vkGetPhysicalDeviceSurfacePresentModes2EXT")).map(|a| a.cast()),
                    } }
                }
            }

            impl InstanceCommands {
                /// `vkGetPhysicalDeviceSurfacePresentModes2EXT`
                pub unsafe fn GetPhysicalDeviceSurfacePresentModes2EXT(&self, physicalDevice: VkPhysicalDevice, pSurfaceInfo: *const VkPhysicalDeviceSurfaceInfo2KHR, pPresentModeCount: *mut uint32_t, pPresentModes: *mut VkPresentModeKHR) -> VkResult {
                    unsafe { (self.vkGetPhysicalDeviceSurfacePresentModes2EXT.expect("Unable to load vkGetPhysicalDeviceSurfacePresentModes2EXT"))(physicalDevice, pSurfaceInfo, pPresentModeCount, pPresentModes) }
                }
            }

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkAcquireFullScreenExclusiveModeEXT: PFN_vkAcquireFullScreenExclusiveModeEXT,
                pub vkGetDeviceGroupSurfacePresentModes2EXT: PFN_vkGetDeviceGroupSurfacePresentModes2EXT,
                pub vkReleaseFullScreenExclusiveModeEXT: PFN_vkReleaseFullScreenExclusiveModeEXT,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkAcquireFullScreenExclusiveModeEXT: get(c!("vkAcquireFullScreenExclusiveModeEXT")).map(|a| a.cast()),
                        vkGetDeviceGroupSurfacePresentModes2EXT: get(c!("vkGetDeviceGroupSurfacePresentModes2EXT")).map(|a| a.cast()),
                        vkReleaseFullScreenExclusiveModeEXT: get(c!("vkReleaseFullScreenExclusiveModeEXT")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkAcquireFullScreenExclusiveModeEXT`
                pub unsafe fn AcquireFullScreenExclusiveModeEXT(&self, device: VkDevice, swapchain: VkSwapchainKHR) -> VkResult {
                    unsafe { (self.vkAcquireFullScreenExclusiveModeEXT.expect("Unable to load vkAcquireFullScreenExclusiveModeEXT"))(device, swapchain) }
                }
                /// `vkGetDeviceGroupSurfacePresentModes2EXT`
                pub unsafe fn GetDeviceGroupSurfacePresentModes2EXT(&self, device: VkDevice, pSurfaceInfo: *const VkPhysicalDeviceSurfaceInfo2KHR, pModes: *mut VkDeviceGroupPresentModeFlagsKHR) -> VkResult {
                    unsafe { (self.vkGetDeviceGroupSurfacePresentModes2EXT.expect("Unable to load vkGetDeviceGroupSurfacePresentModes2EXT"))(device, pSurfaceInfo, pModes) }
                }
                /// `vkReleaseFullScreenExclusiveModeEXT`
                pub unsafe fn ReleaseFullScreenExclusiveModeEXT(&self, device: VkDevice, swapchain: VkSwapchainKHR) -> VkResult {
                    unsafe { (self.vkReleaseFullScreenExclusiveModeEXT.expect("Unable to load vkReleaseFullScreenExclusiveModeEXT"))(device, swapchain) }
                }
            }
        }

        /// `VK_EXT_headless_surface`
        pub mod headless_surface {
            use super::*;

            /// `VK_EXT_headless_surface`
            pub const NAME: &'static CStr = c!("VK_EXT_headless_surface");

            /// InstanceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct InstanceCommands {
                pub vkCreateHeadlessSurfaceEXT: PFN_vkCreateHeadlessSurfaceEXT,
            }

            impl InstanceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkCreateHeadlessSurfaceEXT: get(c!("vkCreateHeadlessSurfaceEXT")).map(|a| a.cast()),
                    } }
                }
            }

            impl InstanceCommands {
                /// `vkCreateHeadlessSurfaceEXT`
                pub unsafe fn CreateHeadlessSurfaceEXT(&self, instance: VkInstance, pCreateInfo: *const VkHeadlessSurfaceCreateInfoEXT, pAllocator: *const VkAllocationCallbacks, pSurface: *mut VkSurfaceKHR) -> VkResult {
                    unsafe { (self.vkCreateHeadlessSurfaceEXT.expect("Unable to load vkCreateHeadlessSurfaceEXT"))(instance, pCreateInfo, pAllocator, pSurface) }
                }
            }
        }

        /// `VK_EXT_line_rasterization`
        pub mod line_rasterization {
            use super::*;

            /// `VK_EXT_line_rasterization`
            pub const NAME: &'static CStr = c!("VK_EXT_line_rasterization");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkCmdSetLineStippleEXT: PFN_vkCmdSetLineStippleEXT,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkCmdSetLineStippleEXT: get(c!("vkCmdSetLineStippleEXT")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkCmdSetLineStippleEXT`
                pub unsafe fn CmdSetLineStippleEXT(&self, commandBuffer: VkCommandBuffer, lineStippleFactor: uint32_t, lineStipplePattern: uint16_t) -> () {
                    unsafe { (self.vkCmdSetLineStippleEXT.expect("Unable to load vkCmdSetLineStippleEXT"))(commandBuffer, lineStippleFactor, lineStipplePattern) }
                }
            }
        }

        /// `VK_EXT_shader_atomic_float`
        pub mod shader_atomic_float {
            use super::*;

            /// `VK_EXT_shader_atomic_float`
            pub const NAME: &'static CStr = c!("VK_EXT_shader_atomic_float");
        }

        /// `VK_EXT_host_query_reset`
        pub mod host_query_reset {
            use super::*;

            /// `VK_EXT_host_query_reset`
            pub const NAME: &'static CStr = c!("VK_EXT_host_query_reset");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkResetQueryPoolEXT: PFN_vkResetQueryPoolEXT,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkResetQueryPoolEXT: get(c!("vkResetQueryPoolEXT")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkResetQueryPoolEXT`
                pub unsafe fn ResetQueryPoolEXT(&self, device: VkDevice, queryPool: VkQueryPool, firstQuery: uint32_t, queryCount: uint32_t) -> () {
                    unsafe { (self.vkResetQueryPoolEXT.expect("Unable to load vkResetQueryPoolEXT"))(device, queryPool, firstQuery, queryCount) }
                }
            }
        }

        /// `VK_EXT_index_type_uint8`
        pub mod index_type_uint8 {
            use super::*;

            /// `VK_EXT_index_type_uint8`
            pub const NAME: &'static CStr = c!("VK_EXT_index_type_uint8");
        }

        /// `VK_EXT_extended_dynamic_state`
        pub mod extended_dynamic_state {
            use super::*;

            /// `VK_EXT_extended_dynamic_state`
            pub const NAME: &'static CStr = c!("VK_EXT_extended_dynamic_state");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkCmdBindVertexBuffers2EXT: PFN_vkCmdBindVertexBuffers2EXT,
                pub vkCmdSetCullModeEXT: PFN_vkCmdSetCullModeEXT,
                pub vkCmdSetDepthBoundsTestEnableEXT: PFN_vkCmdSetDepthBoundsTestEnableEXT,
                pub vkCmdSetDepthCompareOpEXT: PFN_vkCmdSetDepthCompareOpEXT,
                pub vkCmdSetDepthTestEnableEXT: PFN_vkCmdSetDepthTestEnableEXT,
                pub vkCmdSetDepthWriteEnableEXT: PFN_vkCmdSetDepthWriteEnableEXT,
                pub vkCmdSetFrontFaceEXT: PFN_vkCmdSetFrontFaceEXT,
                pub vkCmdSetPrimitiveTopologyEXT: PFN_vkCmdSetPrimitiveTopologyEXT,
                pub vkCmdSetScissorWithCountEXT: PFN_vkCmdSetScissorWithCountEXT,
                pub vkCmdSetStencilOpEXT: PFN_vkCmdSetStencilOpEXT,
                pub vkCmdSetStencilTestEnableEXT: PFN_vkCmdSetStencilTestEnableEXT,
                pub vkCmdSetViewportWithCountEXT: PFN_vkCmdSetViewportWithCountEXT,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkCmdBindVertexBuffers2EXT: get(c!("vkCmdBindVertexBuffers2EXT")).map(|a| a.cast()),
                        vkCmdSetCullModeEXT: get(c!("vkCmdSetCullModeEXT")).map(|a| a.cast()),
                        vkCmdSetDepthBoundsTestEnableEXT: get(c!("vkCmdSetDepthBoundsTestEnableEXT")).map(|a| a.cast()),
                        vkCmdSetDepthCompareOpEXT: get(c!("vkCmdSetDepthCompareOpEXT")).map(|a| a.cast()),
                        vkCmdSetDepthTestEnableEXT: get(c!("vkCmdSetDepthTestEnableEXT")).map(|a| a.cast()),
                        vkCmdSetDepthWriteEnableEXT: get(c!("vkCmdSetDepthWriteEnableEXT")).map(|a| a.cast()),
                        vkCmdSetFrontFaceEXT: get(c!("vkCmdSetFrontFaceEXT")).map(|a| a.cast()),
                        vkCmdSetPrimitiveTopologyEXT: get(c!("vkCmdSetPrimitiveTopologyEXT")).map(|a| a.cast()),
                        vkCmdSetScissorWithCountEXT: get(c!("vkCmdSetScissorWithCountEXT")).map(|a| a.cast()),
                        vkCmdSetStencilOpEXT: get(c!("vkCmdSetStencilOpEXT")).map(|a| a.cast()),
                        vkCmdSetStencilTestEnableEXT: get(c!("vkCmdSetStencilTestEnableEXT")).map(|a| a.cast()),
                        vkCmdSetViewportWithCountEXT: get(c!("vkCmdSetViewportWithCountEXT")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkCmdBindVertexBuffers2EXT`
                pub unsafe fn CmdBindVertexBuffers2EXT(&self, commandBuffer: VkCommandBuffer, firstBinding: uint32_t, bindingCount: uint32_t, pBuffers: *const VkBuffer, pOffsets: *const VkDeviceSize, pSizes: *const VkDeviceSize, pStrides: *const VkDeviceSize) -> () {
                    unsafe { (self.vkCmdBindVertexBuffers2EXT.expect("Unable to load vkCmdBindVertexBuffers2EXT"))(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides) }
                }
                /// `vkCmdSetCullModeEXT`
                pub unsafe fn CmdSetCullModeEXT(&self, commandBuffer: VkCommandBuffer, cullMode: VkCullModeFlags) -> () {
                    unsafe { (self.vkCmdSetCullModeEXT.expect("Unable to load vkCmdSetCullModeEXT"))(commandBuffer, cullMode) }
                }
                /// `vkCmdSetDepthBoundsTestEnableEXT`
                pub unsafe fn CmdSetDepthBoundsTestEnableEXT(&self, commandBuffer: VkCommandBuffer, depthBoundsTestEnable: VkBool32) -> () {
                    unsafe { (self.vkCmdSetDepthBoundsTestEnableEXT.expect("Unable to load vkCmdSetDepthBoundsTestEnableEXT"))(commandBuffer, depthBoundsTestEnable) }
                }
                /// `vkCmdSetDepthCompareOpEXT`
                pub unsafe fn CmdSetDepthCompareOpEXT(&self, commandBuffer: VkCommandBuffer, depthCompareOp: VkCompareOp) -> () {
                    unsafe { (self.vkCmdSetDepthCompareOpEXT.expect("Unable to load vkCmdSetDepthCompareOpEXT"))(commandBuffer, depthCompareOp) }
                }
                /// `vkCmdSetDepthTestEnableEXT`
                pub unsafe fn CmdSetDepthTestEnableEXT(&self, commandBuffer: VkCommandBuffer, depthTestEnable: VkBool32) -> () {
                    unsafe { (self.vkCmdSetDepthTestEnableEXT.expect("Unable to load vkCmdSetDepthTestEnableEXT"))(commandBuffer, depthTestEnable) }
                }
                /// `vkCmdSetDepthWriteEnableEXT`
                pub unsafe fn CmdSetDepthWriteEnableEXT(&self, commandBuffer: VkCommandBuffer, depthWriteEnable: VkBool32) -> () {
                    unsafe { (self.vkCmdSetDepthWriteEnableEXT.expect("Unable to load vkCmdSetDepthWriteEnableEXT"))(commandBuffer, depthWriteEnable) }
                }
                /// `vkCmdSetFrontFaceEXT`
                pub unsafe fn CmdSetFrontFaceEXT(&self, commandBuffer: VkCommandBuffer, frontFace: VkFrontFace) -> () {
                    unsafe { (self.vkCmdSetFrontFaceEXT.expect("Unable to load vkCmdSetFrontFaceEXT"))(commandBuffer, frontFace) }
                }
                /// `vkCmdSetPrimitiveTopologyEXT`
                pub unsafe fn CmdSetPrimitiveTopologyEXT(&self, commandBuffer: VkCommandBuffer, primitiveTopology: VkPrimitiveTopology) -> () {
                    unsafe { (self.vkCmdSetPrimitiveTopologyEXT.expect("Unable to load vkCmdSetPrimitiveTopologyEXT"))(commandBuffer, primitiveTopology) }
                }
                /// `vkCmdSetScissorWithCountEXT`
                pub unsafe fn CmdSetScissorWithCountEXT(&self, commandBuffer: VkCommandBuffer, scissorCount: uint32_t, pScissors: *const VkRect2D) -> () {
                    unsafe { (self.vkCmdSetScissorWithCountEXT.expect("Unable to load vkCmdSetScissorWithCountEXT"))(commandBuffer, scissorCount, pScissors) }
                }
                /// `vkCmdSetStencilOpEXT`
                pub unsafe fn CmdSetStencilOpEXT(&self, commandBuffer: VkCommandBuffer, faceMask: VkStencilFaceFlags, failOp: VkStencilOp, passOp: VkStencilOp, depthFailOp: VkStencilOp, compareOp: VkCompareOp) -> () {
                    unsafe { (self.vkCmdSetStencilOpEXT.expect("Unable to load vkCmdSetStencilOpEXT"))(commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp) }
                }
                /// `vkCmdSetStencilTestEnableEXT`
                pub unsafe fn CmdSetStencilTestEnableEXT(&self, commandBuffer: VkCommandBuffer, stencilTestEnable: VkBool32) -> () {
                    unsafe { (self.vkCmdSetStencilTestEnableEXT.expect("Unable to load vkCmdSetStencilTestEnableEXT"))(commandBuffer, stencilTestEnable) }
                }
                /// `vkCmdSetViewportWithCountEXT`
                pub unsafe fn CmdSetViewportWithCountEXT(&self, commandBuffer: VkCommandBuffer, viewportCount: uint32_t, pViewports: *const VkViewport) -> () {
                    unsafe { (self.vkCmdSetViewportWithCountEXT.expect("Unable to load vkCmdSetViewportWithCountEXT"))(commandBuffer, viewportCount, pViewports) }
                }
            }
        }

        /// `VK_EXT_host_image_copy`
        pub mod host_image_copy {
            use super::*;

            /// `VK_EXT_host_image_copy`
            pub const NAME: &'static CStr = c!("VK_EXT_host_image_copy");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkCopyImageToImageEXT: PFN_vkCopyImageToImageEXT,
                pub vkCopyImageToMemoryEXT: PFN_vkCopyImageToMemoryEXT,
                pub vkCopyMemoryToImageEXT: PFN_vkCopyMemoryToImageEXT,
                pub vkGetImageSubresourceLayout2EXT: PFN_vkGetImageSubresourceLayout2EXT,
                pub vkTransitionImageLayoutEXT: PFN_vkTransitionImageLayoutEXT,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkCopyImageToImageEXT: get(c!("vkCopyImageToImageEXT")).map(|a| a.cast()),
                        vkCopyImageToMemoryEXT: get(c!("vkCopyImageToMemoryEXT")).map(|a| a.cast()),
                        vkCopyMemoryToImageEXT: get(c!("vkCopyMemoryToImageEXT")).map(|a| a.cast()),
                        vkGetImageSubresourceLayout2EXT: get(c!("vkGetImageSubresourceLayout2EXT")).map(|a| a.cast()),
                        vkTransitionImageLayoutEXT: get(c!("vkTransitionImageLayoutEXT")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkCopyImageToImageEXT`
                pub unsafe fn CopyImageToImageEXT(&self, device: VkDevice, pCopyImageToImageInfo: *const VkCopyImageToImageInfo) -> VkResult {
                    unsafe { (self.vkCopyImageToImageEXT.expect("Unable to load vkCopyImageToImageEXT"))(device, pCopyImageToImageInfo) }
                }
                /// `vkCopyImageToMemoryEXT`
                pub unsafe fn CopyImageToMemoryEXT(&self, device: VkDevice, pCopyImageToMemoryInfo: *const VkCopyImageToMemoryInfo) -> VkResult {
                    unsafe { (self.vkCopyImageToMemoryEXT.expect("Unable to load vkCopyImageToMemoryEXT"))(device, pCopyImageToMemoryInfo) }
                }
                /// `vkCopyMemoryToImageEXT`
                pub unsafe fn CopyMemoryToImageEXT(&self, device: VkDevice, pCopyMemoryToImageInfo: *const VkCopyMemoryToImageInfo) -> VkResult {
                    unsafe { (self.vkCopyMemoryToImageEXT.expect("Unable to load vkCopyMemoryToImageEXT"))(device, pCopyMemoryToImageInfo) }
                }
                /// `vkGetImageSubresourceLayout2EXT`
                pub unsafe fn GetImageSubresourceLayout2EXT(&self, device: VkDevice, image: VkImage, pSubresource: *const VkImageSubresource2, pLayout: *mut VkSubresourceLayout2) -> () {
                    unsafe { (self.vkGetImageSubresourceLayout2EXT.expect("Unable to load vkGetImageSubresourceLayout2EXT"))(device, image, pSubresource, pLayout) }
                }
                /// `vkTransitionImageLayoutEXT`
                pub unsafe fn TransitionImageLayoutEXT(&self, device: VkDevice, transitionCount: uint32_t, pTransitions: *const VkHostImageLayoutTransitionInfo) -> VkResult {
                    unsafe { (self.vkTransitionImageLayoutEXT.expect("Unable to load vkTransitionImageLayoutEXT"))(device, transitionCount, pTransitions) }
                }
            }
        }

        /// `VK_EXT_map_memory_placed`
        pub mod map_memory_placed {
            use super::*;

            /// `VK_EXT_map_memory_placed`
            pub const NAME: &'static CStr = c!("VK_EXT_map_memory_placed");
        }

        /// `VK_EXT_shader_atomic_float2`
        pub mod shader_atomic_float2 {
            use super::*;

            /// `VK_EXT_shader_atomic_float2`
            pub const NAME: &'static CStr = c!("VK_EXT_shader_atomic_float2");
        }

        /// `VK_EXT_surface_maintenance1`
        pub mod surface_maintenance1 {
            use super::*;

            /// `VK_EXT_surface_maintenance1`
            pub const NAME: &'static CStr = c!("VK_EXT_surface_maintenance1");
        }

        /// `VK_EXT_swapchain_maintenance1`
        pub mod swapchain_maintenance1 {
            use super::*;

            /// `VK_EXT_swapchain_maintenance1`
            pub const NAME: &'static CStr = c!("VK_EXT_swapchain_maintenance1");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkReleaseSwapchainImagesEXT: PFN_vkReleaseSwapchainImagesEXT,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkReleaseSwapchainImagesEXT: get(c!("vkReleaseSwapchainImagesEXT")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkReleaseSwapchainImagesEXT`
                pub unsafe fn ReleaseSwapchainImagesEXT(&self, device: VkDevice, pReleaseInfo: *const VkReleaseSwapchainImagesInfoKHR) -> VkResult {
                    unsafe { (self.vkReleaseSwapchainImagesEXT.expect("Unable to load vkReleaseSwapchainImagesEXT"))(device, pReleaseInfo) }
                }
            }
        }

        /// `VK_EXT_shader_demote_to_helper_invocation`
        pub mod shader_demote_to_helper_invocation {
            use super::*;

            /// `VK_EXT_shader_demote_to_helper_invocation`
            pub const NAME: &'static CStr = c!("VK_EXT_shader_demote_to_helper_invocation");
        }

        /// `VK_EXT_texel_buffer_alignment`
        pub mod texel_buffer_alignment {
            use super::*;

            /// `VK_EXT_texel_buffer_alignment`
            pub const NAME: &'static CStr = c!("VK_EXT_texel_buffer_alignment");
        }

        /// `VK_EXT_depth_bias_control`
        pub mod depth_bias_control {
            use super::*;

            /// `VK_EXT_depth_bias_control`
            pub const NAME: &'static CStr = c!("VK_EXT_depth_bias_control");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkCmdSetDepthBias2EXT: PFN_vkCmdSetDepthBias2EXT,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkCmdSetDepthBias2EXT: get(c!("vkCmdSetDepthBias2EXT")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkCmdSetDepthBias2EXT`
                pub unsafe fn CmdSetDepthBias2EXT(&self, commandBuffer: VkCommandBuffer, pDepthBiasInfo: *const VkDepthBiasInfoEXT) -> () {
                    unsafe { (self.vkCmdSetDepthBias2EXT.expect("Unable to load vkCmdSetDepthBias2EXT"))(commandBuffer, pDepthBiasInfo) }
                }
            }
        }

        /// `VK_EXT_device_memory_report`
        pub mod device_memory_report {
            use super::*;

            /// `VK_EXT_device_memory_report`
            pub const NAME: &'static CStr = c!("VK_EXT_device_memory_report");
        }

        /// `VK_EXT_acquire_drm_display`
        pub mod acquire_drm_display {
            use super::*;

            /// `VK_EXT_acquire_drm_display`
            pub const NAME: &'static CStr = c!("VK_EXT_acquire_drm_display");

            /// InstanceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct InstanceCommands {
                pub vkAcquireDrmDisplayEXT: PFN_vkAcquireDrmDisplayEXT,
                pub vkGetDrmDisplayEXT: PFN_vkGetDrmDisplayEXT,
            }

            impl InstanceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkAcquireDrmDisplayEXT: get(c!("vkAcquireDrmDisplayEXT")).map(|a| a.cast()),
                        vkGetDrmDisplayEXT: get(c!("vkGetDrmDisplayEXT")).map(|a| a.cast()),
                    } }
                }
            }

            impl InstanceCommands {
                /// `vkAcquireDrmDisplayEXT`
                pub unsafe fn AcquireDrmDisplayEXT(&self, physicalDevice: VkPhysicalDevice, drmFd: int32_t, display: VkDisplayKHR) -> VkResult {
                    unsafe { (self.vkAcquireDrmDisplayEXT.expect("Unable to load vkAcquireDrmDisplayEXT"))(physicalDevice, drmFd, display) }
                }
                /// `vkGetDrmDisplayEXT`
                pub unsafe fn GetDrmDisplayEXT(&self, physicalDevice: VkPhysicalDevice, drmFd: int32_t, connectorId: uint32_t, display: *mut VkDisplayKHR) -> VkResult {
                    unsafe { (self.vkGetDrmDisplayEXT.expect("Unable to load vkGetDrmDisplayEXT"))(physicalDevice, drmFd, connectorId, display) }
                }
            }
        }

        /// `VK_EXT_robustness2`
        pub mod robustness2 {
            use super::*;

            /// `VK_EXT_robustness2`
            pub const NAME: &'static CStr = c!("VK_EXT_robustness2");
        }

        /// `VK_EXT_custom_border_color`
        pub mod custom_border_color {
            use super::*;

            /// `VK_EXT_custom_border_color`
            pub const NAME: &'static CStr = c!("VK_EXT_custom_border_color");
        }

        /// `VK_EXT_texture_compression_astc_3d`
        pub mod texture_compression_astc_3d {
            use super::*;

            /// `VK_EXT_texture_compression_astc_3d`
            pub const NAME: &'static CStr = c!("VK_EXT_texture_compression_astc_3d");
        }

        /// `VK_EXT_private_data`
        pub mod private_data {
            use super::*;

            /// `VK_EXT_private_data`
            pub const NAME: &'static CStr = c!("VK_EXT_private_data");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkCreatePrivateDataSlotEXT: PFN_vkCreatePrivateDataSlotEXT,
                pub vkDestroyPrivateDataSlotEXT: PFN_vkDestroyPrivateDataSlotEXT,
                pub vkGetPrivateDataEXT: PFN_vkGetPrivateDataEXT,
                pub vkSetPrivateDataEXT: PFN_vkSetPrivateDataEXT,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkCreatePrivateDataSlotEXT: get(c!("vkCreatePrivateDataSlotEXT")).map(|a| a.cast()),
                        vkDestroyPrivateDataSlotEXT: get(c!("vkDestroyPrivateDataSlotEXT")).map(|a| a.cast()),
                        vkGetPrivateDataEXT: get(c!("vkGetPrivateDataEXT")).map(|a| a.cast()),
                        vkSetPrivateDataEXT: get(c!("vkSetPrivateDataEXT")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkCreatePrivateDataSlotEXT`
                pub unsafe fn CreatePrivateDataSlotEXT(&self, device: VkDevice, pCreateInfo: *const VkPrivateDataSlotCreateInfo, pAllocator: *const VkAllocationCallbacks, pPrivateDataSlot: *mut VkPrivateDataSlot) -> VkResult {
                    unsafe { (self.vkCreatePrivateDataSlotEXT.expect("Unable to load vkCreatePrivateDataSlotEXT"))(device, pCreateInfo, pAllocator, pPrivateDataSlot) }
                }
                /// `vkDestroyPrivateDataSlotEXT`
                pub unsafe fn DestroyPrivateDataSlotEXT(&self, device: VkDevice, privateDataSlot: VkPrivateDataSlot, pAllocator: *const VkAllocationCallbacks) -> () {
                    unsafe { (self.vkDestroyPrivateDataSlotEXT.expect("Unable to load vkDestroyPrivateDataSlotEXT"))(device, privateDataSlot, pAllocator) }
                }
                /// `vkGetPrivateDataEXT`
                pub unsafe fn GetPrivateDataEXT(&self, device: VkDevice, objectType: VkObjectType, objectHandle: uint64_t, privateDataSlot: VkPrivateDataSlot, pData: *mut uint64_t) -> () {
                    unsafe { (self.vkGetPrivateDataEXT.expect("Unable to load vkGetPrivateDataEXT"))(device, objectType, objectHandle, privateDataSlot, pData) }
                }
                /// `vkSetPrivateDataEXT`
                pub unsafe fn SetPrivateDataEXT(&self, device: VkDevice, objectType: VkObjectType, objectHandle: uint64_t, privateDataSlot: VkPrivateDataSlot, data: uint64_t) -> VkResult {
                    unsafe { (self.vkSetPrivateDataEXT.expect("Unable to load vkSetPrivateDataEXT"))(device, objectType, objectHandle, privateDataSlot, data) }
                }
            }
        }

        /// `VK_EXT_pipeline_creation_cache_control`
        pub mod pipeline_creation_cache_control {
            use super::*;

            /// `VK_EXT_pipeline_creation_cache_control`
            pub const NAME: &'static CStr = c!("VK_EXT_pipeline_creation_cache_control");
        }

        /// `VK_EXT_metal_objects`
        pub mod metal_objects {
            use super::*;

            /// `VK_EXT_metal_objects`
            pub const NAME: &'static CStr = c!("VK_EXT_metal_objects");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkExportMetalObjectsEXT: PFN_vkExportMetalObjectsEXT,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkExportMetalObjectsEXT: get(c!("vkExportMetalObjectsEXT")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkExportMetalObjectsEXT`
                pub unsafe fn ExportMetalObjectsEXT(&self, device: VkDevice, pMetalObjectsInfo: *mut VkExportMetalObjectsInfoEXT) -> () {
                    unsafe { (self.vkExportMetalObjectsEXT.expect("Unable to load vkExportMetalObjectsEXT"))(device, pMetalObjectsInfo) }
                }
            }
        }

        /// `VK_EXT_descriptor_buffer`
        pub mod descriptor_buffer {
            use super::*;

            /// `VK_EXT_descriptor_buffer`
            pub const NAME: &'static CStr = c!("VK_EXT_descriptor_buffer");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkCmdBindDescriptorBufferEmbeddedSamplersEXT: PFN_vkCmdBindDescriptorBufferEmbeddedSamplersEXT,
                pub vkCmdBindDescriptorBuffersEXT: PFN_vkCmdBindDescriptorBuffersEXT,
                pub vkCmdSetDescriptorBufferOffsetsEXT: PFN_vkCmdSetDescriptorBufferOffsetsEXT,
                pub vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT: PFN_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT,
                pub vkGetBufferOpaqueCaptureDescriptorDataEXT: PFN_vkGetBufferOpaqueCaptureDescriptorDataEXT,
                pub vkGetDescriptorEXT: PFN_vkGetDescriptorEXT,
                pub vkGetDescriptorSetLayoutBindingOffsetEXT: PFN_vkGetDescriptorSetLayoutBindingOffsetEXT,
                pub vkGetDescriptorSetLayoutSizeEXT: PFN_vkGetDescriptorSetLayoutSizeEXT,
                pub vkGetImageOpaqueCaptureDescriptorDataEXT: PFN_vkGetImageOpaqueCaptureDescriptorDataEXT,
                pub vkGetImageViewOpaqueCaptureDescriptorDataEXT: PFN_vkGetImageViewOpaqueCaptureDescriptorDataEXT,
                pub vkGetSamplerOpaqueCaptureDescriptorDataEXT: PFN_vkGetSamplerOpaqueCaptureDescriptorDataEXT,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkCmdBindDescriptorBufferEmbeddedSamplersEXT: get(c!("vkCmdBindDescriptorBufferEmbeddedSamplersEXT")).map(|a| a.cast()),
                        vkCmdBindDescriptorBuffersEXT: get(c!("vkCmdBindDescriptorBuffersEXT")).map(|a| a.cast()),
                        vkCmdSetDescriptorBufferOffsetsEXT: get(c!("vkCmdSetDescriptorBufferOffsetsEXT")).map(|a| a.cast()),
                        vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT: get(c!("vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT")).map(|a| a.cast()),
                        vkGetBufferOpaqueCaptureDescriptorDataEXT: get(c!("vkGetBufferOpaqueCaptureDescriptorDataEXT")).map(|a| a.cast()),
                        vkGetDescriptorEXT: get(c!("vkGetDescriptorEXT")).map(|a| a.cast()),
                        vkGetDescriptorSetLayoutBindingOffsetEXT: get(c!("vkGetDescriptorSetLayoutBindingOffsetEXT")).map(|a| a.cast()),
                        vkGetDescriptorSetLayoutSizeEXT: get(c!("vkGetDescriptorSetLayoutSizeEXT")).map(|a| a.cast()),
                        vkGetImageOpaqueCaptureDescriptorDataEXT: get(c!("vkGetImageOpaqueCaptureDescriptorDataEXT")).map(|a| a.cast()),
                        vkGetImageViewOpaqueCaptureDescriptorDataEXT: get(c!("vkGetImageViewOpaqueCaptureDescriptorDataEXT")).map(|a| a.cast()),
                        vkGetSamplerOpaqueCaptureDescriptorDataEXT: get(c!("vkGetSamplerOpaqueCaptureDescriptorDataEXT")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkCmdBindDescriptorBufferEmbeddedSamplersEXT`
                pub unsafe fn CmdBindDescriptorBufferEmbeddedSamplersEXT(&self, commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, layout: VkPipelineLayout, set: uint32_t) -> () {
                    unsafe { (self.vkCmdBindDescriptorBufferEmbeddedSamplersEXT.expect("Unable to load vkCmdBindDescriptorBufferEmbeddedSamplersEXT"))(commandBuffer, pipelineBindPoint, layout, set) }
                }
                /// `vkCmdBindDescriptorBuffersEXT`
                pub unsafe fn CmdBindDescriptorBuffersEXT(&self, commandBuffer: VkCommandBuffer, bufferCount: uint32_t, pBindingInfos: *const VkDescriptorBufferBindingInfoEXT) -> () {
                    unsafe { (self.vkCmdBindDescriptorBuffersEXT.expect("Unable to load vkCmdBindDescriptorBuffersEXT"))(commandBuffer, bufferCount, pBindingInfos) }
                }
                /// `vkCmdSetDescriptorBufferOffsetsEXT`
                pub unsafe fn CmdSetDescriptorBufferOffsetsEXT(&self, commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, layout: VkPipelineLayout, firstSet: uint32_t, setCount: uint32_t, pBufferIndices: *const uint32_t, pOffsets: *const VkDeviceSize) -> () {
                    unsafe { (self.vkCmdSetDescriptorBufferOffsetsEXT.expect("Unable to load vkCmdSetDescriptorBufferOffsetsEXT"))(commandBuffer, pipelineBindPoint, layout, firstSet, setCount, pBufferIndices, pOffsets) }
                }
                /// `vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT`
                pub unsafe fn GetAccelerationStructureOpaqueCaptureDescriptorDataEXT(&self, device: VkDevice, pInfo: *const VkAccelerationStructureCaptureDescriptorDataInfoEXT, pData: *mut void) -> VkResult {
                    unsafe { (self.vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT.expect("Unable to load vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT"))(device, pInfo, pData) }
                }
                /// `vkGetBufferOpaqueCaptureDescriptorDataEXT`
                pub unsafe fn GetBufferOpaqueCaptureDescriptorDataEXT(&self, device: VkDevice, pInfo: *const VkBufferCaptureDescriptorDataInfoEXT, pData: *mut void) -> VkResult {
                    unsafe { (self.vkGetBufferOpaqueCaptureDescriptorDataEXT.expect("Unable to load vkGetBufferOpaqueCaptureDescriptorDataEXT"))(device, pInfo, pData) }
                }
                /// `vkGetDescriptorEXT`
                pub unsafe fn GetDescriptorEXT(&self, device: VkDevice, pDescriptorInfo: *const VkDescriptorGetInfoEXT, dataSize: size_t, pDescriptor: *mut void) -> () {
                    unsafe { (self.vkGetDescriptorEXT.expect("Unable to load vkGetDescriptorEXT"))(device, pDescriptorInfo, dataSize, pDescriptor) }
                }
                /// `vkGetDescriptorSetLayoutBindingOffsetEXT`
                pub unsafe fn GetDescriptorSetLayoutBindingOffsetEXT(&self, device: VkDevice, layout: VkDescriptorSetLayout, binding: uint32_t, pOffset: *mut VkDeviceSize) -> () {
                    unsafe { (self.vkGetDescriptorSetLayoutBindingOffsetEXT.expect("Unable to load vkGetDescriptorSetLayoutBindingOffsetEXT"))(device, layout, binding, pOffset) }
                }
                /// `vkGetDescriptorSetLayoutSizeEXT`
                pub unsafe fn GetDescriptorSetLayoutSizeEXT(&self, device: VkDevice, layout: VkDescriptorSetLayout, pLayoutSizeInBytes: *mut VkDeviceSize) -> () {
                    unsafe { (self.vkGetDescriptorSetLayoutSizeEXT.expect("Unable to load vkGetDescriptorSetLayoutSizeEXT"))(device, layout, pLayoutSizeInBytes) }
                }
                /// `vkGetImageOpaqueCaptureDescriptorDataEXT`
                pub unsafe fn GetImageOpaqueCaptureDescriptorDataEXT(&self, device: VkDevice, pInfo: *const VkImageCaptureDescriptorDataInfoEXT, pData: *mut void) -> VkResult {
                    unsafe { (self.vkGetImageOpaqueCaptureDescriptorDataEXT.expect("Unable to load vkGetImageOpaqueCaptureDescriptorDataEXT"))(device, pInfo, pData) }
                }
                /// `vkGetImageViewOpaqueCaptureDescriptorDataEXT`
                pub unsafe fn GetImageViewOpaqueCaptureDescriptorDataEXT(&self, device: VkDevice, pInfo: *const VkImageViewCaptureDescriptorDataInfoEXT, pData: *mut void) -> VkResult {
                    unsafe { (self.vkGetImageViewOpaqueCaptureDescriptorDataEXT.expect("Unable to load vkGetImageViewOpaqueCaptureDescriptorDataEXT"))(device, pInfo, pData) }
                }
                /// `vkGetSamplerOpaqueCaptureDescriptorDataEXT`
                pub unsafe fn GetSamplerOpaqueCaptureDescriptorDataEXT(&self, device: VkDevice, pInfo: *const VkSamplerCaptureDescriptorDataInfoEXT, pData: *mut void) -> VkResult {
                    unsafe { (self.vkGetSamplerOpaqueCaptureDescriptorDataEXT.expect("Unable to load vkGetSamplerOpaqueCaptureDescriptorDataEXT"))(device, pInfo, pData) }
                }
            }
        }

        /// `VK_EXT_graphics_pipeline_library`
        pub mod graphics_pipeline_library {
            use super::*;

            /// `VK_EXT_graphics_pipeline_library`
            pub const NAME: &'static CStr = c!("VK_EXT_graphics_pipeline_library");
        }

        /// `VK_EXT_mesh_shader`
        pub mod mesh_shader {
            use super::*;

            /// `VK_EXT_mesh_shader`
            pub const NAME: &'static CStr = c!("VK_EXT_mesh_shader");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkCmdDrawMeshTasksEXT: PFN_vkCmdDrawMeshTasksEXT,
                pub vkCmdDrawMeshTasksIndirectCountEXT: PFN_vkCmdDrawMeshTasksIndirectCountEXT,
                pub vkCmdDrawMeshTasksIndirectEXT: PFN_vkCmdDrawMeshTasksIndirectEXT,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkCmdDrawMeshTasksEXT: get(c!("vkCmdDrawMeshTasksEXT")).map(|a| a.cast()),
                        vkCmdDrawMeshTasksIndirectCountEXT: get(c!("vkCmdDrawMeshTasksIndirectCountEXT")).map(|a| a.cast()),
                        vkCmdDrawMeshTasksIndirectEXT: get(c!("vkCmdDrawMeshTasksIndirectEXT")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkCmdDrawMeshTasksEXT`
                pub unsafe fn CmdDrawMeshTasksEXT(&self, commandBuffer: VkCommandBuffer, groupCountX: uint32_t, groupCountY: uint32_t, groupCountZ: uint32_t) -> () {
                    unsafe { (self.vkCmdDrawMeshTasksEXT.expect("Unable to load vkCmdDrawMeshTasksEXT"))(commandBuffer, groupCountX, groupCountY, groupCountZ) }
                }
                /// `vkCmdDrawMeshTasksIndirectCountEXT`
                pub unsafe fn CmdDrawMeshTasksIndirectCountEXT(&self, commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, countBuffer: VkBuffer, countBufferOffset: VkDeviceSize, maxDrawCount: uint32_t, stride: uint32_t) -> () {
                    unsafe { (self.vkCmdDrawMeshTasksIndirectCountEXT.expect("Unable to load vkCmdDrawMeshTasksIndirectCountEXT"))(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride) }
                }
                /// `vkCmdDrawMeshTasksIndirectEXT`
                pub unsafe fn CmdDrawMeshTasksIndirectEXT(&self, commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, drawCount: uint32_t, stride: uint32_t) -> () {
                    unsafe { (self.vkCmdDrawMeshTasksIndirectEXT.expect("Unable to load vkCmdDrawMeshTasksIndirectEXT"))(commandBuffer, buffer, offset, drawCount, stride) }
                }
            }
        }

        /// `VK_EXT_ycbcr_2plane_444_formats`
        pub mod ycbcr_2plane_444_formats {
            use super::*;

            /// `VK_EXT_ycbcr_2plane_444_formats`
            pub const NAME: &'static CStr = c!("VK_EXT_ycbcr_2plane_444_formats");
        }

        /// `VK_EXT_fragment_density_map2`
        pub mod fragment_density_map2 {
            use super::*;

            /// `VK_EXT_fragment_density_map2`
            pub const NAME: &'static CStr = c!("VK_EXT_fragment_density_map2");
        }

        /// `VK_EXT_image_robustness`
        pub mod image_robustness {
            use super::*;

            /// `VK_EXT_image_robustness`
            pub const NAME: &'static CStr = c!("VK_EXT_image_robustness");
        }

        /// `VK_EXT_image_compression_control`
        pub mod image_compression_control {
            use super::*;

            /// `VK_EXT_image_compression_control`
            pub const NAME: &'static CStr = c!("VK_EXT_image_compression_control");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkGetImageSubresourceLayout2EXT: PFN_vkGetImageSubresourceLayout2EXT,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkGetImageSubresourceLayout2EXT: get(c!("vkGetImageSubresourceLayout2EXT")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkGetImageSubresourceLayout2EXT`
                pub unsafe fn GetImageSubresourceLayout2EXT(&self, device: VkDevice, image: VkImage, pSubresource: *const VkImageSubresource2, pLayout: *mut VkSubresourceLayout2) -> () {
                    unsafe { (self.vkGetImageSubresourceLayout2EXT.expect("Unable to load vkGetImageSubresourceLayout2EXT"))(device, image, pSubresource, pLayout) }
                }
            }
        }

        /// `VK_EXT_attachment_feedback_loop_layout`
        pub mod attachment_feedback_loop_layout {
            use super::*;

            /// `VK_EXT_attachment_feedback_loop_layout`
            pub const NAME: &'static CStr = c!("VK_EXT_attachment_feedback_loop_layout");
        }

        /// `VK_EXT_4444_formats`
        pub mod _4444_formats {
            use super::*;

            /// `VK_EXT_4444_formats`
            pub const NAME: &'static CStr = c!("VK_EXT_4444_formats");
        }

        /// `VK_EXT_device_fault`
        pub mod device_fault {
            use super::*;

            /// `VK_EXT_device_fault`
            pub const NAME: &'static CStr = c!("VK_EXT_device_fault");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkGetDeviceFaultInfoEXT: PFN_vkGetDeviceFaultInfoEXT,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkGetDeviceFaultInfoEXT: get(c!("vkGetDeviceFaultInfoEXT")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkGetDeviceFaultInfoEXT`
                pub unsafe fn GetDeviceFaultInfoEXT(&self, device: VkDevice, pFaultCounts: *mut VkDeviceFaultCountsEXT, pFaultInfo: *mut VkDeviceFaultInfoEXT) -> VkResult {
                    unsafe { (self.vkGetDeviceFaultInfoEXT.expect("Unable to load vkGetDeviceFaultInfoEXT"))(device, pFaultCounts, pFaultInfo) }
                }
            }
        }

        /// `VK_EXT_rgba10x6_formats`
        pub mod rgba10x6_formats {
            use super::*;

            /// `VK_EXT_rgba10x6_formats`
            pub const NAME: &'static CStr = c!("VK_EXT_rgba10x6_formats");
        }

        /// `VK_EXT_directfb_surface`
        pub mod directfb_surface {
            use super::*;

            /// `VK_EXT_directfb_surface`
            pub const NAME: &'static CStr = c!("VK_EXT_directfb_surface");

            /// InstanceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct InstanceCommands {
                pub vkCreateDirectFBSurfaceEXT: PFN_vkCreateDirectFBSurfaceEXT,
                pub vkGetPhysicalDeviceDirectFBPresentationSupportEXT: PFN_vkGetPhysicalDeviceDirectFBPresentationSupportEXT,
            }

            impl InstanceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkCreateDirectFBSurfaceEXT: get(c!("vkCreateDirectFBSurfaceEXT")).map(|a| a.cast()),
                        vkGetPhysicalDeviceDirectFBPresentationSupportEXT: get(c!("vkGetPhysicalDeviceDirectFBPresentationSupportEXT")).map(|a| a.cast()),
                    } }
                }
            }

            impl InstanceCommands {
                /// `vkCreateDirectFBSurfaceEXT`
                pub unsafe fn CreateDirectFBSurfaceEXT(&self, instance: VkInstance, pCreateInfo: *const VkDirectFBSurfaceCreateInfoEXT, pAllocator: *const VkAllocationCallbacks, pSurface: *mut VkSurfaceKHR) -> VkResult {
                    unsafe { (self.vkCreateDirectFBSurfaceEXT.expect("Unable to load vkCreateDirectFBSurfaceEXT"))(instance, pCreateInfo, pAllocator, pSurface) }
                }
                /// `vkGetPhysicalDeviceDirectFBPresentationSupportEXT`
                pub unsafe fn GetPhysicalDeviceDirectFBPresentationSupportEXT(&self, physicalDevice: VkPhysicalDevice, queueFamilyIndex: uint32_t, dfb: *mut IDirectFB) -> VkBool32 {
                    unsafe { (self.vkGetPhysicalDeviceDirectFBPresentationSupportEXT.expect("Unable to load vkGetPhysicalDeviceDirectFBPresentationSupportEXT"))(physicalDevice, queueFamilyIndex, dfb) }
                }
            }
        }

        /// `VK_EXT_vertex_input_dynamic_state`
        pub mod vertex_input_dynamic_state {
            use super::*;

            /// `VK_EXT_vertex_input_dynamic_state`
            pub const NAME: &'static CStr = c!("VK_EXT_vertex_input_dynamic_state");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkCmdSetVertexInputEXT: PFN_vkCmdSetVertexInputEXT,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkCmdSetVertexInputEXT: get(c!("vkCmdSetVertexInputEXT")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkCmdSetVertexInputEXT`
                pub unsafe fn CmdSetVertexInputEXT(&self, commandBuffer: VkCommandBuffer, vertexBindingDescriptionCount: uint32_t, pVertexBindingDescriptions: *const VkVertexInputBindingDescription2EXT, vertexAttributeDescriptionCount: uint32_t, pVertexAttributeDescriptions: *const VkVertexInputAttributeDescription2EXT) -> () {
                    unsafe { (self.vkCmdSetVertexInputEXT.expect("Unable to load vkCmdSetVertexInputEXT"))(commandBuffer, vertexBindingDescriptionCount, pVertexBindingDescriptions, vertexAttributeDescriptionCount, pVertexAttributeDescriptions) }
                }
            }
        }

        /// `VK_EXT_physical_device_drm`
        pub mod physical_device_drm {
            use super::*;

            /// `VK_EXT_physical_device_drm`
            pub const NAME: &'static CStr = c!("VK_EXT_physical_device_drm");
        }

        /// `VK_EXT_device_address_binding_report`
        pub mod device_address_binding_report {
            use super::*;

            /// `VK_EXT_device_address_binding_report`
            pub const NAME: &'static CStr = c!("VK_EXT_device_address_binding_report");
        }

        /// `VK_EXT_depth_clip_control`
        pub mod depth_clip_control {
            use super::*;

            /// `VK_EXT_depth_clip_control`
            pub const NAME: &'static CStr = c!("VK_EXT_depth_clip_control");
        }

        /// `VK_EXT_primitive_topology_list_restart`
        pub mod primitive_topology_list_restart {
            use super::*;

            /// `VK_EXT_primitive_topology_list_restart`
            pub const NAME: &'static CStr = c!("VK_EXT_primitive_topology_list_restart");
        }

        /// `VK_EXT_present_mode_fifo_latest_ready`
        pub mod present_mode_fifo_latest_ready {
            use super::*;

            /// `VK_EXT_present_mode_fifo_latest_ready`
            pub const NAME: &'static CStr = c!("VK_EXT_present_mode_fifo_latest_ready");
        }

        /// `VK_EXT_pipeline_properties`
        pub mod pipeline_properties {
            use super::*;

            /// `VK_EXT_pipeline_properties`
            pub const NAME: &'static CStr = c!("VK_EXT_pipeline_properties");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkGetPipelinePropertiesEXT: PFN_vkGetPipelinePropertiesEXT,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkGetPipelinePropertiesEXT: get(c!("vkGetPipelinePropertiesEXT")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkGetPipelinePropertiesEXT`
                pub unsafe fn GetPipelinePropertiesEXT(&self, device: VkDevice, pPipelineInfo: *const VkPipelineInfoEXT, pPipelineProperties: *mut VkBaseOutStructure) -> VkResult {
                    unsafe { (self.vkGetPipelinePropertiesEXT.expect("Unable to load vkGetPipelinePropertiesEXT"))(device, pPipelineInfo, pPipelineProperties) }
                }
            }
        }

        /// `VK_EXT_frame_boundary`
        pub mod frame_boundary {
            use super::*;

            /// `VK_EXT_frame_boundary`
            pub const NAME: &'static CStr = c!("VK_EXT_frame_boundary");
        }

        /// `VK_EXT_multisampled_render_to_single_sampled`
        pub mod multisampled_render_to_single_sampled {
            use super::*;

            /// `VK_EXT_multisampled_render_to_single_sampled`
            pub const NAME: &'static CStr = c!("VK_EXT_multisampled_render_to_single_sampled");
        }

        /// `VK_EXT_extended_dynamic_state2`
        pub mod extended_dynamic_state2 {
            use super::*;

            /// `VK_EXT_extended_dynamic_state2`
            pub const NAME: &'static CStr = c!("VK_EXT_extended_dynamic_state2");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkCmdSetDepthBiasEnableEXT: PFN_vkCmdSetDepthBiasEnableEXT,
                pub vkCmdSetLogicOpEXT: PFN_vkCmdSetLogicOpEXT,
                pub vkCmdSetPatchControlPointsEXT: PFN_vkCmdSetPatchControlPointsEXT,
                pub vkCmdSetPrimitiveRestartEnableEXT: PFN_vkCmdSetPrimitiveRestartEnableEXT,
                pub vkCmdSetRasterizerDiscardEnableEXT: PFN_vkCmdSetRasterizerDiscardEnableEXT,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkCmdSetDepthBiasEnableEXT: get(c!("vkCmdSetDepthBiasEnableEXT")).map(|a| a.cast()),
                        vkCmdSetLogicOpEXT: get(c!("vkCmdSetLogicOpEXT")).map(|a| a.cast()),
                        vkCmdSetPatchControlPointsEXT: get(c!("vkCmdSetPatchControlPointsEXT")).map(|a| a.cast()),
                        vkCmdSetPrimitiveRestartEnableEXT: get(c!("vkCmdSetPrimitiveRestartEnableEXT")).map(|a| a.cast()),
                        vkCmdSetRasterizerDiscardEnableEXT: get(c!("vkCmdSetRasterizerDiscardEnableEXT")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkCmdSetDepthBiasEnableEXT`
                pub unsafe fn CmdSetDepthBiasEnableEXT(&self, commandBuffer: VkCommandBuffer, depthBiasEnable: VkBool32) -> () {
                    unsafe { (self.vkCmdSetDepthBiasEnableEXT.expect("Unable to load vkCmdSetDepthBiasEnableEXT"))(commandBuffer, depthBiasEnable) }
                }
                /// `vkCmdSetLogicOpEXT`
                pub unsafe fn CmdSetLogicOpEXT(&self, commandBuffer: VkCommandBuffer, logicOp: VkLogicOp) -> () {
                    unsafe { (self.vkCmdSetLogicOpEXT.expect("Unable to load vkCmdSetLogicOpEXT"))(commandBuffer, logicOp) }
                }
                /// `vkCmdSetPatchControlPointsEXT`
                pub unsafe fn CmdSetPatchControlPointsEXT(&self, commandBuffer: VkCommandBuffer, patchControlPoints: uint32_t) -> () {
                    unsafe { (self.vkCmdSetPatchControlPointsEXT.expect("Unable to load vkCmdSetPatchControlPointsEXT"))(commandBuffer, patchControlPoints) }
                }
                /// `vkCmdSetPrimitiveRestartEnableEXT`
                pub unsafe fn CmdSetPrimitiveRestartEnableEXT(&self, commandBuffer: VkCommandBuffer, primitiveRestartEnable: VkBool32) -> () {
                    unsafe { (self.vkCmdSetPrimitiveRestartEnableEXT.expect("Unable to load vkCmdSetPrimitiveRestartEnableEXT"))(commandBuffer, primitiveRestartEnable) }
                }
                /// `vkCmdSetRasterizerDiscardEnableEXT`
                pub unsafe fn CmdSetRasterizerDiscardEnableEXT(&self, commandBuffer: VkCommandBuffer, rasterizerDiscardEnable: VkBool32) -> () {
                    unsafe { (self.vkCmdSetRasterizerDiscardEnableEXT.expect("Unable to load vkCmdSetRasterizerDiscardEnableEXT"))(commandBuffer, rasterizerDiscardEnable) }
                }
            }
        }

        /// `VK_EXT_color_write_enable`
        pub mod color_write_enable {
            use super::*;

            /// `VK_EXT_color_write_enable`
            pub const NAME: &'static CStr = c!("VK_EXT_color_write_enable");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkCmdSetColorWriteEnableEXT: PFN_vkCmdSetColorWriteEnableEXT,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkCmdSetColorWriteEnableEXT: get(c!("vkCmdSetColorWriteEnableEXT")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkCmdSetColorWriteEnableEXT`
                pub unsafe fn CmdSetColorWriteEnableEXT(&self, commandBuffer: VkCommandBuffer, attachmentCount: uint32_t, pColorWriteEnables: *const VkBool32) -> () {
                    unsafe { (self.vkCmdSetColorWriteEnableEXT.expect("Unable to load vkCmdSetColorWriteEnableEXT"))(commandBuffer, attachmentCount, pColorWriteEnables) }
                }
            }
        }

        /// `VK_EXT_primitives_generated_query`
        pub mod primitives_generated_query {
            use super::*;

            /// `VK_EXT_primitives_generated_query`
            pub const NAME: &'static CStr = c!("VK_EXT_primitives_generated_query");
        }

        /// `VK_EXT_global_priority_query`
        pub mod global_priority_query {
            use super::*;

            /// `VK_EXT_global_priority_query`
            pub const NAME: &'static CStr = c!("VK_EXT_global_priority_query");
        }

        /// `VK_EXT_image_view_min_lod`
        pub mod image_view_min_lod {
            use super::*;

            /// `VK_EXT_image_view_min_lod`
            pub const NAME: &'static CStr = c!("VK_EXT_image_view_min_lod");
        }

        /// `VK_EXT_multi_draw`
        pub mod multi_draw {
            use super::*;

            /// `VK_EXT_multi_draw`
            pub const NAME: &'static CStr = c!("VK_EXT_multi_draw");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkCmdDrawMultiEXT: PFN_vkCmdDrawMultiEXT,
                pub vkCmdDrawMultiIndexedEXT: PFN_vkCmdDrawMultiIndexedEXT,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkCmdDrawMultiEXT: get(c!("vkCmdDrawMultiEXT")).map(|a| a.cast()),
                        vkCmdDrawMultiIndexedEXT: get(c!("vkCmdDrawMultiIndexedEXT")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkCmdDrawMultiEXT`
                pub unsafe fn CmdDrawMultiEXT(&self, commandBuffer: VkCommandBuffer, drawCount: uint32_t, pVertexInfo: *const VkMultiDrawInfoEXT, instanceCount: uint32_t, firstInstance: uint32_t, stride: uint32_t) -> () {
                    unsafe { (self.vkCmdDrawMultiEXT.expect("Unable to load vkCmdDrawMultiEXT"))(commandBuffer, drawCount, pVertexInfo, instanceCount, firstInstance, stride) }
                }
                /// `vkCmdDrawMultiIndexedEXT`
                pub unsafe fn CmdDrawMultiIndexedEXT(&self, commandBuffer: VkCommandBuffer, drawCount: uint32_t, pIndexInfo: *const VkMultiDrawIndexedInfoEXT, instanceCount: uint32_t, firstInstance: uint32_t, stride: uint32_t, pVertexOffset: *const int32_t) -> () {
                    unsafe { (self.vkCmdDrawMultiIndexedEXT.expect("Unable to load vkCmdDrawMultiIndexedEXT"))(commandBuffer, drawCount, pIndexInfo, instanceCount, firstInstance, stride, pVertexOffset) }
                }
            }
        }

        /// `VK_EXT_image_2d_view_of_3d`
        pub mod image_2d_view_of_3d {
            use super::*;

            /// `VK_EXT_image_2d_view_of_3d`
            pub const NAME: &'static CStr = c!("VK_EXT_image_2d_view_of_3d");
        }

        /// `VK_EXT_shader_tile_image`
        pub mod shader_tile_image {
            use super::*;

            /// `VK_EXT_shader_tile_image`
            pub const NAME: &'static CStr = c!("VK_EXT_shader_tile_image");
        }

        /// `VK_EXT_opacity_micromap`
        pub mod opacity_micromap {
            use super::*;

            /// `VK_EXT_opacity_micromap`
            pub const NAME: &'static CStr = c!("VK_EXT_opacity_micromap");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkBuildMicromapsEXT: PFN_vkBuildMicromapsEXT,
                pub vkCmdBuildMicromapsEXT: PFN_vkCmdBuildMicromapsEXT,
                pub vkCmdCopyMemoryToMicromapEXT: PFN_vkCmdCopyMemoryToMicromapEXT,
                pub vkCmdCopyMicromapEXT: PFN_vkCmdCopyMicromapEXT,
                pub vkCmdCopyMicromapToMemoryEXT: PFN_vkCmdCopyMicromapToMemoryEXT,
                pub vkCmdWriteMicromapsPropertiesEXT: PFN_vkCmdWriteMicromapsPropertiesEXT,
                pub vkCopyMemoryToMicromapEXT: PFN_vkCopyMemoryToMicromapEXT,
                pub vkCopyMicromapEXT: PFN_vkCopyMicromapEXT,
                pub vkCopyMicromapToMemoryEXT: PFN_vkCopyMicromapToMemoryEXT,
                pub vkCreateMicromapEXT: PFN_vkCreateMicromapEXT,
                pub vkDestroyMicromapEXT: PFN_vkDestroyMicromapEXT,
                pub vkGetDeviceMicromapCompatibilityEXT: PFN_vkGetDeviceMicromapCompatibilityEXT,
                pub vkGetMicromapBuildSizesEXT: PFN_vkGetMicromapBuildSizesEXT,
                pub vkWriteMicromapsPropertiesEXT: PFN_vkWriteMicromapsPropertiesEXT,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkBuildMicromapsEXT: get(c!("vkBuildMicromapsEXT")).map(|a| a.cast()),
                        vkCmdBuildMicromapsEXT: get(c!("vkCmdBuildMicromapsEXT")).map(|a| a.cast()),
                        vkCmdCopyMemoryToMicromapEXT: get(c!("vkCmdCopyMemoryToMicromapEXT")).map(|a| a.cast()),
                        vkCmdCopyMicromapEXT: get(c!("vkCmdCopyMicromapEXT")).map(|a| a.cast()),
                        vkCmdCopyMicromapToMemoryEXT: get(c!("vkCmdCopyMicromapToMemoryEXT")).map(|a| a.cast()),
                        vkCmdWriteMicromapsPropertiesEXT: get(c!("vkCmdWriteMicromapsPropertiesEXT")).map(|a| a.cast()),
                        vkCopyMemoryToMicromapEXT: get(c!("vkCopyMemoryToMicromapEXT")).map(|a| a.cast()),
                        vkCopyMicromapEXT: get(c!("vkCopyMicromapEXT")).map(|a| a.cast()),
                        vkCopyMicromapToMemoryEXT: get(c!("vkCopyMicromapToMemoryEXT")).map(|a| a.cast()),
                        vkCreateMicromapEXT: get(c!("vkCreateMicromapEXT")).map(|a| a.cast()),
                        vkDestroyMicromapEXT: get(c!("vkDestroyMicromapEXT")).map(|a| a.cast()),
                        vkGetDeviceMicromapCompatibilityEXT: get(c!("vkGetDeviceMicromapCompatibilityEXT")).map(|a| a.cast()),
                        vkGetMicromapBuildSizesEXT: get(c!("vkGetMicromapBuildSizesEXT")).map(|a| a.cast()),
                        vkWriteMicromapsPropertiesEXT: get(c!("vkWriteMicromapsPropertiesEXT")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkBuildMicromapsEXT`
                pub unsafe fn BuildMicromapsEXT(&self, device: VkDevice, deferredOperation: VkDeferredOperationKHR, infoCount: uint32_t, pInfos: *const VkMicromapBuildInfoEXT) -> VkResult {
                    unsafe { (self.vkBuildMicromapsEXT.expect("Unable to load vkBuildMicromapsEXT"))(device, deferredOperation, infoCount, pInfos) }
                }
                /// `vkCmdBuildMicromapsEXT`
                pub unsafe fn CmdBuildMicromapsEXT(&self, commandBuffer: VkCommandBuffer, infoCount: uint32_t, pInfos: *const VkMicromapBuildInfoEXT) -> () {
                    unsafe { (self.vkCmdBuildMicromapsEXT.expect("Unable to load vkCmdBuildMicromapsEXT"))(commandBuffer, infoCount, pInfos) }
                }
                /// `vkCmdCopyMemoryToMicromapEXT`
                pub unsafe fn CmdCopyMemoryToMicromapEXT(&self, commandBuffer: VkCommandBuffer, pInfo: *const VkCopyMemoryToMicromapInfoEXT) -> () {
                    unsafe { (self.vkCmdCopyMemoryToMicromapEXT.expect("Unable to load vkCmdCopyMemoryToMicromapEXT"))(commandBuffer, pInfo) }
                }
                /// `vkCmdCopyMicromapEXT`
                pub unsafe fn CmdCopyMicromapEXT(&self, commandBuffer: VkCommandBuffer, pInfo: *const VkCopyMicromapInfoEXT) -> () {
                    unsafe { (self.vkCmdCopyMicromapEXT.expect("Unable to load vkCmdCopyMicromapEXT"))(commandBuffer, pInfo) }
                }
                /// `vkCmdCopyMicromapToMemoryEXT`
                pub unsafe fn CmdCopyMicromapToMemoryEXT(&self, commandBuffer: VkCommandBuffer, pInfo: *const VkCopyMicromapToMemoryInfoEXT) -> () {
                    unsafe { (self.vkCmdCopyMicromapToMemoryEXT.expect("Unable to load vkCmdCopyMicromapToMemoryEXT"))(commandBuffer, pInfo) }
                }
                /// `vkCmdWriteMicromapsPropertiesEXT`
                pub unsafe fn CmdWriteMicromapsPropertiesEXT(&self, commandBuffer: VkCommandBuffer, micromapCount: uint32_t, pMicromaps: *const VkMicromapEXT, queryType: VkQueryType, queryPool: VkQueryPool, firstQuery: uint32_t) -> () {
                    unsafe { (self.vkCmdWriteMicromapsPropertiesEXT.expect("Unable to load vkCmdWriteMicromapsPropertiesEXT"))(commandBuffer, micromapCount, pMicromaps, queryType, queryPool, firstQuery) }
                }
                /// `vkCopyMemoryToMicromapEXT`
                pub unsafe fn CopyMemoryToMicromapEXT(&self, device: VkDevice, deferredOperation: VkDeferredOperationKHR, pInfo: *const VkCopyMemoryToMicromapInfoEXT) -> VkResult {
                    unsafe { (self.vkCopyMemoryToMicromapEXT.expect("Unable to load vkCopyMemoryToMicromapEXT"))(device, deferredOperation, pInfo) }
                }
                /// `vkCopyMicromapEXT`
                pub unsafe fn CopyMicromapEXT(&self, device: VkDevice, deferredOperation: VkDeferredOperationKHR, pInfo: *const VkCopyMicromapInfoEXT) -> VkResult {
                    unsafe { (self.vkCopyMicromapEXT.expect("Unable to load vkCopyMicromapEXT"))(device, deferredOperation, pInfo) }
                }
                /// `vkCopyMicromapToMemoryEXT`
                pub unsafe fn CopyMicromapToMemoryEXT(&self, device: VkDevice, deferredOperation: VkDeferredOperationKHR, pInfo: *const VkCopyMicromapToMemoryInfoEXT) -> VkResult {
                    unsafe { (self.vkCopyMicromapToMemoryEXT.expect("Unable to load vkCopyMicromapToMemoryEXT"))(device, deferredOperation, pInfo) }
                }
                /// `vkCreateMicromapEXT`
                pub unsafe fn CreateMicromapEXT(&self, device: VkDevice, pCreateInfo: *const VkMicromapCreateInfoEXT, pAllocator: *const VkAllocationCallbacks, pMicromap: *mut VkMicromapEXT) -> VkResult {
                    unsafe { (self.vkCreateMicromapEXT.expect("Unable to load vkCreateMicromapEXT"))(device, pCreateInfo, pAllocator, pMicromap) }
                }
                /// `vkDestroyMicromapEXT`
                pub unsafe fn DestroyMicromapEXT(&self, device: VkDevice, micromap: VkMicromapEXT, pAllocator: *const VkAllocationCallbacks) -> () {
                    unsafe { (self.vkDestroyMicromapEXT.expect("Unable to load vkDestroyMicromapEXT"))(device, micromap, pAllocator) }
                }
                /// `vkGetDeviceMicromapCompatibilityEXT`
                pub unsafe fn GetDeviceMicromapCompatibilityEXT(&self, device: VkDevice, pVersionInfo: *const VkMicromapVersionInfoEXT, pCompatibility: *mut VkAccelerationStructureCompatibilityKHR) -> () {
                    unsafe { (self.vkGetDeviceMicromapCompatibilityEXT.expect("Unable to load vkGetDeviceMicromapCompatibilityEXT"))(device, pVersionInfo, pCompatibility) }
                }
                /// `vkGetMicromapBuildSizesEXT`
                pub unsafe fn GetMicromapBuildSizesEXT(&self, device: VkDevice, buildType: VkAccelerationStructureBuildTypeKHR, pBuildInfo: *const VkMicromapBuildInfoEXT, pSizeInfo: *mut VkMicromapBuildSizesInfoEXT) -> () {
                    unsafe { (self.vkGetMicromapBuildSizesEXT.expect("Unable to load vkGetMicromapBuildSizesEXT"))(device, buildType, pBuildInfo, pSizeInfo) }
                }
                /// `vkWriteMicromapsPropertiesEXT`
                pub unsafe fn WriteMicromapsPropertiesEXT(&self, device: VkDevice, micromapCount: uint32_t, pMicromaps: *const VkMicromapEXT, queryType: VkQueryType, dataSize: size_t, pData: *mut void, stride: size_t) -> VkResult {
                    unsafe { (self.vkWriteMicromapsPropertiesEXT.expect("Unable to load vkWriteMicromapsPropertiesEXT"))(device, micromapCount, pMicromaps, queryType, dataSize, pData, stride) }
                }
            }
        }

        /// `VK_EXT_load_store_op_none`
        pub mod load_store_op_none {
            use super::*;

            /// `VK_EXT_load_store_op_none`
            pub const NAME: &'static CStr = c!("VK_EXT_load_store_op_none");
        }

        /// `VK_EXT_border_color_swizzle`
        pub mod border_color_swizzle {
            use super::*;

            /// `VK_EXT_border_color_swizzle`
            pub const NAME: &'static CStr = c!("VK_EXT_border_color_swizzle");
        }

        /// `VK_EXT_pageable_device_local_memory`
        pub mod pageable_device_local_memory {
            use super::*;

            /// `VK_EXT_pageable_device_local_memory`
            pub const NAME: &'static CStr = c!("VK_EXT_pageable_device_local_memory");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkSetDeviceMemoryPriorityEXT: PFN_vkSetDeviceMemoryPriorityEXT,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkSetDeviceMemoryPriorityEXT: get(c!("vkSetDeviceMemoryPriorityEXT")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkSetDeviceMemoryPriorityEXT`
                pub unsafe fn SetDeviceMemoryPriorityEXT(&self, device: VkDevice, memory: VkDeviceMemory, priority: float) -> () {
                    unsafe { (self.vkSetDeviceMemoryPriorityEXT.expect("Unable to load vkSetDeviceMemoryPriorityEXT"))(device, memory, priority) }
                }
            }
        }

        /// `VK_EXT_image_sliced_view_of_3d`
        pub mod image_sliced_view_of_3d {
            use super::*;

            /// `VK_EXT_image_sliced_view_of_3d`
            pub const NAME: &'static CStr = c!("VK_EXT_image_sliced_view_of_3d");
        }

        /// `VK_EXT_depth_clamp_zero_one`
        pub mod depth_clamp_zero_one {
            use super::*;

            /// `VK_EXT_depth_clamp_zero_one`
            pub const NAME: &'static CStr = c!("VK_EXT_depth_clamp_zero_one");
        }

        /// `VK_EXT_non_seamless_cube_map`
        pub mod non_seamless_cube_map {
            use super::*;

            /// `VK_EXT_non_seamless_cube_map`
            pub const NAME: &'static CStr = c!("VK_EXT_non_seamless_cube_map");
        }

        /// `VK_EXT_application_parameters`
        pub mod application_parameters {
            use super::*;

            /// `VK_EXT_application_parameters`
            pub const NAME: &'static CStr = c!("VK_EXT_application_parameters");
        }

        /// `VK_EXT_image_compression_control_swapchain`
        pub mod image_compression_control_swapchain {
            use super::*;

            /// `VK_EXT_image_compression_control_swapchain`
            pub const NAME: &'static CStr = c!("VK_EXT_image_compression_control_swapchain");
        }

        /// `VK_EXT_nested_command_buffer`
        pub mod nested_command_buffer {
            use super::*;

            /// `VK_EXT_nested_command_buffer`
            pub const NAME: &'static CStr = c!("VK_EXT_nested_command_buffer");
        }

        /// `VK_EXT_external_memory_acquire_unmodified`
        pub mod external_memory_acquire_unmodified {
            use super::*;

            /// `VK_EXT_external_memory_acquire_unmodified`
            pub const NAME: &'static CStr = c!("VK_EXT_external_memory_acquire_unmodified");
        }

        /// `VK_EXT_extended_dynamic_state3`
        pub mod extended_dynamic_state3 {
            use super::*;

            /// `VK_EXT_extended_dynamic_state3`
            pub const NAME: &'static CStr = c!("VK_EXT_extended_dynamic_state3");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkCmdSetAlphaToCoverageEnableEXT: PFN_vkCmdSetAlphaToCoverageEnableEXT,
                pub vkCmdSetAlphaToOneEnableEXT: PFN_vkCmdSetAlphaToOneEnableEXT,
                pub vkCmdSetColorBlendAdvancedEXT: PFN_vkCmdSetColorBlendAdvancedEXT,
                pub vkCmdSetColorBlendEnableEXT: PFN_vkCmdSetColorBlendEnableEXT,
                pub vkCmdSetColorBlendEquationEXT: PFN_vkCmdSetColorBlendEquationEXT,
                pub vkCmdSetColorWriteMaskEXT: PFN_vkCmdSetColorWriteMaskEXT,
                pub vkCmdSetConservativeRasterizationModeEXT: PFN_vkCmdSetConservativeRasterizationModeEXT,
                pub vkCmdSetCoverageModulationModeNV: PFN_vkCmdSetCoverageModulationModeNV,
                pub vkCmdSetCoverageModulationTableEnableNV: PFN_vkCmdSetCoverageModulationTableEnableNV,
                pub vkCmdSetCoverageModulationTableNV: PFN_vkCmdSetCoverageModulationTableNV,
                pub vkCmdSetCoverageReductionModeNV: PFN_vkCmdSetCoverageReductionModeNV,
                pub vkCmdSetCoverageToColorEnableNV: PFN_vkCmdSetCoverageToColorEnableNV,
                pub vkCmdSetCoverageToColorLocationNV: PFN_vkCmdSetCoverageToColorLocationNV,
                pub vkCmdSetDepthClampEnableEXT: PFN_vkCmdSetDepthClampEnableEXT,
                pub vkCmdSetDepthClipEnableEXT: PFN_vkCmdSetDepthClipEnableEXT,
                pub vkCmdSetDepthClipNegativeOneToOneEXT: PFN_vkCmdSetDepthClipNegativeOneToOneEXT,
                pub vkCmdSetExtraPrimitiveOverestimationSizeEXT: PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT,
                pub vkCmdSetLineRasterizationModeEXT: PFN_vkCmdSetLineRasterizationModeEXT,
                pub vkCmdSetLineStippleEnableEXT: PFN_vkCmdSetLineStippleEnableEXT,
                pub vkCmdSetLogicOpEnableEXT: PFN_vkCmdSetLogicOpEnableEXT,
                pub vkCmdSetPolygonModeEXT: PFN_vkCmdSetPolygonModeEXT,
                pub vkCmdSetProvokingVertexModeEXT: PFN_vkCmdSetProvokingVertexModeEXT,
                pub vkCmdSetRasterizationSamplesEXT: PFN_vkCmdSetRasterizationSamplesEXT,
                pub vkCmdSetRasterizationStreamEXT: PFN_vkCmdSetRasterizationStreamEXT,
                pub vkCmdSetRepresentativeFragmentTestEnableNV: PFN_vkCmdSetRepresentativeFragmentTestEnableNV,
                pub vkCmdSetSampleLocationsEnableEXT: PFN_vkCmdSetSampleLocationsEnableEXT,
                pub vkCmdSetSampleMaskEXT: PFN_vkCmdSetSampleMaskEXT,
                pub vkCmdSetShadingRateImageEnableNV: PFN_vkCmdSetShadingRateImageEnableNV,
                pub vkCmdSetTessellationDomainOriginEXT: PFN_vkCmdSetTessellationDomainOriginEXT,
                pub vkCmdSetViewportSwizzleNV: PFN_vkCmdSetViewportSwizzleNV,
                pub vkCmdSetViewportWScalingEnableNV: PFN_vkCmdSetViewportWScalingEnableNV,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkCmdSetAlphaToCoverageEnableEXT: get(c!("vkCmdSetAlphaToCoverageEnableEXT")).map(|a| a.cast()),
                        vkCmdSetAlphaToOneEnableEXT: get(c!("vkCmdSetAlphaToOneEnableEXT")).map(|a| a.cast()),
                        vkCmdSetColorBlendAdvancedEXT: get(c!("vkCmdSetColorBlendAdvancedEXT")).map(|a| a.cast()),
                        vkCmdSetColorBlendEnableEXT: get(c!("vkCmdSetColorBlendEnableEXT")).map(|a| a.cast()),
                        vkCmdSetColorBlendEquationEXT: get(c!("vkCmdSetColorBlendEquationEXT")).map(|a| a.cast()),
                        vkCmdSetColorWriteMaskEXT: get(c!("vkCmdSetColorWriteMaskEXT")).map(|a| a.cast()),
                        vkCmdSetConservativeRasterizationModeEXT: get(c!("vkCmdSetConservativeRasterizationModeEXT")).map(|a| a.cast()),
                        vkCmdSetCoverageModulationModeNV: get(c!("vkCmdSetCoverageModulationModeNV")).map(|a| a.cast()),
                        vkCmdSetCoverageModulationTableEnableNV: get(c!("vkCmdSetCoverageModulationTableEnableNV")).map(|a| a.cast()),
                        vkCmdSetCoverageModulationTableNV: get(c!("vkCmdSetCoverageModulationTableNV")).map(|a| a.cast()),
                        vkCmdSetCoverageReductionModeNV: get(c!("vkCmdSetCoverageReductionModeNV")).map(|a| a.cast()),
                        vkCmdSetCoverageToColorEnableNV: get(c!("vkCmdSetCoverageToColorEnableNV")).map(|a| a.cast()),
                        vkCmdSetCoverageToColorLocationNV: get(c!("vkCmdSetCoverageToColorLocationNV")).map(|a| a.cast()),
                        vkCmdSetDepthClampEnableEXT: get(c!("vkCmdSetDepthClampEnableEXT")).map(|a| a.cast()),
                        vkCmdSetDepthClipEnableEXT: get(c!("vkCmdSetDepthClipEnableEXT")).map(|a| a.cast()),
                        vkCmdSetDepthClipNegativeOneToOneEXT: get(c!("vkCmdSetDepthClipNegativeOneToOneEXT")).map(|a| a.cast()),
                        vkCmdSetExtraPrimitiveOverestimationSizeEXT: get(c!("vkCmdSetExtraPrimitiveOverestimationSizeEXT")).map(|a| a.cast()),
                        vkCmdSetLineRasterizationModeEXT: get(c!("vkCmdSetLineRasterizationModeEXT")).map(|a| a.cast()),
                        vkCmdSetLineStippleEnableEXT: get(c!("vkCmdSetLineStippleEnableEXT")).map(|a| a.cast()),
                        vkCmdSetLogicOpEnableEXT: get(c!("vkCmdSetLogicOpEnableEXT")).map(|a| a.cast()),
                        vkCmdSetPolygonModeEXT: get(c!("vkCmdSetPolygonModeEXT")).map(|a| a.cast()),
                        vkCmdSetProvokingVertexModeEXT: get(c!("vkCmdSetProvokingVertexModeEXT")).map(|a| a.cast()),
                        vkCmdSetRasterizationSamplesEXT: get(c!("vkCmdSetRasterizationSamplesEXT")).map(|a| a.cast()),
                        vkCmdSetRasterizationStreamEXT: get(c!("vkCmdSetRasterizationStreamEXT")).map(|a| a.cast()),
                        vkCmdSetRepresentativeFragmentTestEnableNV: get(c!("vkCmdSetRepresentativeFragmentTestEnableNV")).map(|a| a.cast()),
                        vkCmdSetSampleLocationsEnableEXT: get(c!("vkCmdSetSampleLocationsEnableEXT")).map(|a| a.cast()),
                        vkCmdSetSampleMaskEXT: get(c!("vkCmdSetSampleMaskEXT")).map(|a| a.cast()),
                        vkCmdSetShadingRateImageEnableNV: get(c!("vkCmdSetShadingRateImageEnableNV")).map(|a| a.cast()),
                        vkCmdSetTessellationDomainOriginEXT: get(c!("vkCmdSetTessellationDomainOriginEXT")).map(|a| a.cast()),
                        vkCmdSetViewportSwizzleNV: get(c!("vkCmdSetViewportSwizzleNV")).map(|a| a.cast()),
                        vkCmdSetViewportWScalingEnableNV: get(c!("vkCmdSetViewportWScalingEnableNV")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkCmdSetAlphaToCoverageEnableEXT`
                pub unsafe fn CmdSetAlphaToCoverageEnableEXT(&self, commandBuffer: VkCommandBuffer, alphaToCoverageEnable: VkBool32) -> () {
                    unsafe { (self.vkCmdSetAlphaToCoverageEnableEXT.expect("Unable to load vkCmdSetAlphaToCoverageEnableEXT"))(commandBuffer, alphaToCoverageEnable) }
                }
                /// `vkCmdSetAlphaToOneEnableEXT`
                pub unsafe fn CmdSetAlphaToOneEnableEXT(&self, commandBuffer: VkCommandBuffer, alphaToOneEnable: VkBool32) -> () {
                    unsafe { (self.vkCmdSetAlphaToOneEnableEXT.expect("Unable to load vkCmdSetAlphaToOneEnableEXT"))(commandBuffer, alphaToOneEnable) }
                }
                /// `vkCmdSetColorBlendAdvancedEXT`
                pub unsafe fn CmdSetColorBlendAdvancedEXT(&self, commandBuffer: VkCommandBuffer, firstAttachment: uint32_t, attachmentCount: uint32_t, pColorBlendAdvanced: *const VkColorBlendAdvancedEXT) -> () {
                    unsafe { (self.vkCmdSetColorBlendAdvancedEXT.expect("Unable to load vkCmdSetColorBlendAdvancedEXT"))(commandBuffer, firstAttachment, attachmentCount, pColorBlendAdvanced) }
                }
                /// `vkCmdSetColorBlendEnableEXT`
                pub unsafe fn CmdSetColorBlendEnableEXT(&self, commandBuffer: VkCommandBuffer, firstAttachment: uint32_t, attachmentCount: uint32_t, pColorBlendEnables: *const VkBool32) -> () {
                    unsafe { (self.vkCmdSetColorBlendEnableEXT.expect("Unable to load vkCmdSetColorBlendEnableEXT"))(commandBuffer, firstAttachment, attachmentCount, pColorBlendEnables) }
                }
                /// `vkCmdSetColorBlendEquationEXT`
                pub unsafe fn CmdSetColorBlendEquationEXT(&self, commandBuffer: VkCommandBuffer, firstAttachment: uint32_t, attachmentCount: uint32_t, pColorBlendEquations: *const VkColorBlendEquationEXT) -> () {
                    unsafe { (self.vkCmdSetColorBlendEquationEXT.expect("Unable to load vkCmdSetColorBlendEquationEXT"))(commandBuffer, firstAttachment, attachmentCount, pColorBlendEquations) }
                }
                /// `vkCmdSetColorWriteMaskEXT`
                pub unsafe fn CmdSetColorWriteMaskEXT(&self, commandBuffer: VkCommandBuffer, firstAttachment: uint32_t, attachmentCount: uint32_t, pColorWriteMasks: *const VkColorComponentFlags) -> () {
                    unsafe { (self.vkCmdSetColorWriteMaskEXT.expect("Unable to load vkCmdSetColorWriteMaskEXT"))(commandBuffer, firstAttachment, attachmentCount, pColorWriteMasks) }
                }
                /// `vkCmdSetConservativeRasterizationModeEXT`
                pub unsafe fn CmdSetConservativeRasterizationModeEXT(&self, commandBuffer: VkCommandBuffer, conservativeRasterizationMode: VkConservativeRasterizationModeEXT) -> () {
                    unsafe { (self.vkCmdSetConservativeRasterizationModeEXT.expect("Unable to load vkCmdSetConservativeRasterizationModeEXT"))(commandBuffer, conservativeRasterizationMode) }
                }
                /// `vkCmdSetCoverageModulationModeNV`
                pub unsafe fn CmdSetCoverageModulationModeNV(&self, commandBuffer: VkCommandBuffer, coverageModulationMode: VkCoverageModulationModeNV) -> () {
                    unsafe { (self.vkCmdSetCoverageModulationModeNV.expect("Unable to load vkCmdSetCoverageModulationModeNV"))(commandBuffer, coverageModulationMode) }
                }
                /// `vkCmdSetCoverageModulationTableEnableNV`
                pub unsafe fn CmdSetCoverageModulationTableEnableNV(&self, commandBuffer: VkCommandBuffer, coverageModulationTableEnable: VkBool32) -> () {
                    unsafe { (self.vkCmdSetCoverageModulationTableEnableNV.expect("Unable to load vkCmdSetCoverageModulationTableEnableNV"))(commandBuffer, coverageModulationTableEnable) }
                }
                /// `vkCmdSetCoverageModulationTableNV`
                pub unsafe fn CmdSetCoverageModulationTableNV(&self, commandBuffer: VkCommandBuffer, coverageModulationTableCount: uint32_t, pCoverageModulationTable: *const float) -> () {
                    unsafe { (self.vkCmdSetCoverageModulationTableNV.expect("Unable to load vkCmdSetCoverageModulationTableNV"))(commandBuffer, coverageModulationTableCount, pCoverageModulationTable) }
                }
                /// `vkCmdSetCoverageReductionModeNV`
                pub unsafe fn CmdSetCoverageReductionModeNV(&self, commandBuffer: VkCommandBuffer, coverageReductionMode: VkCoverageReductionModeNV) -> () {
                    unsafe { (self.vkCmdSetCoverageReductionModeNV.expect("Unable to load vkCmdSetCoverageReductionModeNV"))(commandBuffer, coverageReductionMode) }
                }
                /// `vkCmdSetCoverageToColorEnableNV`
                pub unsafe fn CmdSetCoverageToColorEnableNV(&self, commandBuffer: VkCommandBuffer, coverageToColorEnable: VkBool32) -> () {
                    unsafe { (self.vkCmdSetCoverageToColorEnableNV.expect("Unable to load vkCmdSetCoverageToColorEnableNV"))(commandBuffer, coverageToColorEnable) }
                }
                /// `vkCmdSetCoverageToColorLocationNV`
                pub unsafe fn CmdSetCoverageToColorLocationNV(&self, commandBuffer: VkCommandBuffer, coverageToColorLocation: uint32_t) -> () {
                    unsafe { (self.vkCmdSetCoverageToColorLocationNV.expect("Unable to load vkCmdSetCoverageToColorLocationNV"))(commandBuffer, coverageToColorLocation) }
                }
                /// `vkCmdSetDepthClampEnableEXT`
                pub unsafe fn CmdSetDepthClampEnableEXT(&self, commandBuffer: VkCommandBuffer, depthClampEnable: VkBool32) -> () {
                    unsafe { (self.vkCmdSetDepthClampEnableEXT.expect("Unable to load vkCmdSetDepthClampEnableEXT"))(commandBuffer, depthClampEnable) }
                }
                /// `vkCmdSetDepthClipEnableEXT`
                pub unsafe fn CmdSetDepthClipEnableEXT(&self, commandBuffer: VkCommandBuffer, depthClipEnable: VkBool32) -> () {
                    unsafe { (self.vkCmdSetDepthClipEnableEXT.expect("Unable to load vkCmdSetDepthClipEnableEXT"))(commandBuffer, depthClipEnable) }
                }
                /// `vkCmdSetDepthClipNegativeOneToOneEXT`
                pub unsafe fn CmdSetDepthClipNegativeOneToOneEXT(&self, commandBuffer: VkCommandBuffer, negativeOneToOne: VkBool32) -> () {
                    unsafe { (self.vkCmdSetDepthClipNegativeOneToOneEXT.expect("Unable to load vkCmdSetDepthClipNegativeOneToOneEXT"))(commandBuffer, negativeOneToOne) }
                }
                /// `vkCmdSetExtraPrimitiveOverestimationSizeEXT`
                pub unsafe fn CmdSetExtraPrimitiveOverestimationSizeEXT(&self, commandBuffer: VkCommandBuffer, extraPrimitiveOverestimationSize: float) -> () {
                    unsafe { (self.vkCmdSetExtraPrimitiveOverestimationSizeEXT.expect("Unable to load vkCmdSetExtraPrimitiveOverestimationSizeEXT"))(commandBuffer, extraPrimitiveOverestimationSize) }
                }
                /// `vkCmdSetLineRasterizationModeEXT`
                pub unsafe fn CmdSetLineRasterizationModeEXT(&self, commandBuffer: VkCommandBuffer, lineRasterizationMode: VkLineRasterizationModeEXT) -> () {
                    unsafe { (self.vkCmdSetLineRasterizationModeEXT.expect("Unable to load vkCmdSetLineRasterizationModeEXT"))(commandBuffer, lineRasterizationMode) }
                }
                /// `vkCmdSetLineStippleEnableEXT`
                pub unsafe fn CmdSetLineStippleEnableEXT(&self, commandBuffer: VkCommandBuffer, stippledLineEnable: VkBool32) -> () {
                    unsafe { (self.vkCmdSetLineStippleEnableEXT.expect("Unable to load vkCmdSetLineStippleEnableEXT"))(commandBuffer, stippledLineEnable) }
                }
                /// `vkCmdSetLogicOpEnableEXT`
                pub unsafe fn CmdSetLogicOpEnableEXT(&self, commandBuffer: VkCommandBuffer, logicOpEnable: VkBool32) -> () {
                    unsafe { (self.vkCmdSetLogicOpEnableEXT.expect("Unable to load vkCmdSetLogicOpEnableEXT"))(commandBuffer, logicOpEnable) }
                }
                /// `vkCmdSetPolygonModeEXT`
                pub unsafe fn CmdSetPolygonModeEXT(&self, commandBuffer: VkCommandBuffer, polygonMode: VkPolygonMode) -> () {
                    unsafe { (self.vkCmdSetPolygonModeEXT.expect("Unable to load vkCmdSetPolygonModeEXT"))(commandBuffer, polygonMode) }
                }
                /// `vkCmdSetProvokingVertexModeEXT`
                pub unsafe fn CmdSetProvokingVertexModeEXT(&self, commandBuffer: VkCommandBuffer, provokingVertexMode: VkProvokingVertexModeEXT) -> () {
                    unsafe { (self.vkCmdSetProvokingVertexModeEXT.expect("Unable to load vkCmdSetProvokingVertexModeEXT"))(commandBuffer, provokingVertexMode) }
                }
                /// `vkCmdSetRasterizationSamplesEXT`
                pub unsafe fn CmdSetRasterizationSamplesEXT(&self, commandBuffer: VkCommandBuffer, rasterizationSamples: VkSampleCountFlags) -> () {
                    unsafe { (self.vkCmdSetRasterizationSamplesEXT.expect("Unable to load vkCmdSetRasterizationSamplesEXT"))(commandBuffer, rasterizationSamples) }
                }
                /// `vkCmdSetRasterizationStreamEXT`
                pub unsafe fn CmdSetRasterizationStreamEXT(&self, commandBuffer: VkCommandBuffer, rasterizationStream: uint32_t) -> () {
                    unsafe { (self.vkCmdSetRasterizationStreamEXT.expect("Unable to load vkCmdSetRasterizationStreamEXT"))(commandBuffer, rasterizationStream) }
                }
                /// `vkCmdSetRepresentativeFragmentTestEnableNV`
                pub unsafe fn CmdSetRepresentativeFragmentTestEnableNV(&self, commandBuffer: VkCommandBuffer, representativeFragmentTestEnable: VkBool32) -> () {
                    unsafe { (self.vkCmdSetRepresentativeFragmentTestEnableNV.expect("Unable to load vkCmdSetRepresentativeFragmentTestEnableNV"))(commandBuffer, representativeFragmentTestEnable) }
                }
                /// `vkCmdSetSampleLocationsEnableEXT`
                pub unsafe fn CmdSetSampleLocationsEnableEXT(&self, commandBuffer: VkCommandBuffer, sampleLocationsEnable: VkBool32) -> () {
                    unsafe { (self.vkCmdSetSampleLocationsEnableEXT.expect("Unable to load vkCmdSetSampleLocationsEnableEXT"))(commandBuffer, sampleLocationsEnable) }
                }
                /// `vkCmdSetSampleMaskEXT`
                pub unsafe fn CmdSetSampleMaskEXT(&self, commandBuffer: VkCommandBuffer, samples: VkSampleCountFlags, pSampleMask: *const VkSampleMask) -> () {
                    unsafe { (self.vkCmdSetSampleMaskEXT.expect("Unable to load vkCmdSetSampleMaskEXT"))(commandBuffer, samples, pSampleMask) }
                }
                /// `vkCmdSetShadingRateImageEnableNV`
                pub unsafe fn CmdSetShadingRateImageEnableNV(&self, commandBuffer: VkCommandBuffer, shadingRateImageEnable: VkBool32) -> () {
                    unsafe { (self.vkCmdSetShadingRateImageEnableNV.expect("Unable to load vkCmdSetShadingRateImageEnableNV"))(commandBuffer, shadingRateImageEnable) }
                }
                /// `vkCmdSetTessellationDomainOriginEXT`
                pub unsafe fn CmdSetTessellationDomainOriginEXT(&self, commandBuffer: VkCommandBuffer, domainOrigin: VkTessellationDomainOrigin) -> () {
                    unsafe { (self.vkCmdSetTessellationDomainOriginEXT.expect("Unable to load vkCmdSetTessellationDomainOriginEXT"))(commandBuffer, domainOrigin) }
                }
                /// `vkCmdSetViewportSwizzleNV`
                pub unsafe fn CmdSetViewportSwizzleNV(&self, commandBuffer: VkCommandBuffer, firstViewport: uint32_t, viewportCount: uint32_t, pViewportSwizzles: *const VkViewportSwizzleNV) -> () {
                    unsafe { (self.vkCmdSetViewportSwizzleNV.expect("Unable to load vkCmdSetViewportSwizzleNV"))(commandBuffer, firstViewport, viewportCount, pViewportSwizzles) }
                }
                /// `vkCmdSetViewportWScalingEnableNV`
                pub unsafe fn CmdSetViewportWScalingEnableNV(&self, commandBuffer: VkCommandBuffer, viewportWScalingEnable: VkBool32) -> () {
                    unsafe { (self.vkCmdSetViewportWScalingEnableNV.expect("Unable to load vkCmdSetViewportWScalingEnableNV"))(commandBuffer, viewportWScalingEnable) }
                }
            }
        }

        /// `VK_EXT_subpass_merge_feedback`
        pub mod subpass_merge_feedback {
            use super::*;

            /// `VK_EXT_subpass_merge_feedback`
            pub const NAME: &'static CStr = c!("VK_EXT_subpass_merge_feedback");
        }

        /// `VK_EXT_shader_module_identifier`
        pub mod shader_module_identifier {
            use super::*;

            /// `VK_EXT_shader_module_identifier`
            pub const NAME: &'static CStr = c!("VK_EXT_shader_module_identifier");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkGetShaderModuleCreateInfoIdentifierEXT: PFN_vkGetShaderModuleCreateInfoIdentifierEXT,
                pub vkGetShaderModuleIdentifierEXT: PFN_vkGetShaderModuleIdentifierEXT,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkGetShaderModuleCreateInfoIdentifierEXT: get(c!("vkGetShaderModuleCreateInfoIdentifierEXT")).map(|a| a.cast()),
                        vkGetShaderModuleIdentifierEXT: get(c!("vkGetShaderModuleIdentifierEXT")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkGetShaderModuleCreateInfoIdentifierEXT`
                pub unsafe fn GetShaderModuleCreateInfoIdentifierEXT(&self, device: VkDevice, pCreateInfo: *const VkShaderModuleCreateInfo, pIdentifier: *mut VkShaderModuleIdentifierEXT) -> () {
                    unsafe { (self.vkGetShaderModuleCreateInfoIdentifierEXT.expect("Unable to load vkGetShaderModuleCreateInfoIdentifierEXT"))(device, pCreateInfo, pIdentifier) }
                }
                /// `vkGetShaderModuleIdentifierEXT`
                pub unsafe fn GetShaderModuleIdentifierEXT(&self, device: VkDevice, shaderModule: VkShaderModule, pIdentifier: *mut VkShaderModuleIdentifierEXT) -> () {
                    unsafe { (self.vkGetShaderModuleIdentifierEXT.expect("Unable to load vkGetShaderModuleIdentifierEXT"))(device, shaderModule, pIdentifier) }
                }
            }
        }

        /// `VK_EXT_rasterization_order_attachment_access`
        pub mod rasterization_order_attachment_access {
            use super::*;

            /// `VK_EXT_rasterization_order_attachment_access`
            pub const NAME: &'static CStr = c!("VK_EXT_rasterization_order_attachment_access");
        }

        /// `VK_EXT_legacy_dithering`
        pub mod legacy_dithering {
            use super::*;

            /// `VK_EXT_legacy_dithering`
            pub const NAME: &'static CStr = c!("VK_EXT_legacy_dithering");
        }

        /// `VK_EXT_pipeline_protected_access`
        pub mod pipeline_protected_access {
            use super::*;

            /// `VK_EXT_pipeline_protected_access`
            pub const NAME: &'static CStr = c!("VK_EXT_pipeline_protected_access");
        }

        /// `VK_EXT_shader_object`
        pub mod shader_object {
            use super::*;

            /// `VK_EXT_shader_object`
            pub const NAME: &'static CStr = c!("VK_EXT_shader_object");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkCmdBindShadersEXT: PFN_vkCmdBindShadersEXT,
                pub vkCmdBindVertexBuffers2EXT: PFN_vkCmdBindVertexBuffers2EXT,
                pub vkCmdSetAlphaToCoverageEnableEXT: PFN_vkCmdSetAlphaToCoverageEnableEXT,
                pub vkCmdSetAlphaToOneEnableEXT: PFN_vkCmdSetAlphaToOneEnableEXT,
                pub vkCmdSetColorBlendAdvancedEXT: PFN_vkCmdSetColorBlendAdvancedEXT,
                pub vkCmdSetColorBlendEnableEXT: PFN_vkCmdSetColorBlendEnableEXT,
                pub vkCmdSetColorBlendEquationEXT: PFN_vkCmdSetColorBlendEquationEXT,
                pub vkCmdSetColorWriteMaskEXT: PFN_vkCmdSetColorWriteMaskEXT,
                pub vkCmdSetConservativeRasterizationModeEXT: PFN_vkCmdSetConservativeRasterizationModeEXT,
                pub vkCmdSetCoverageModulationModeNV: PFN_vkCmdSetCoverageModulationModeNV,
                pub vkCmdSetCoverageModulationTableEnableNV: PFN_vkCmdSetCoverageModulationTableEnableNV,
                pub vkCmdSetCoverageModulationTableNV: PFN_vkCmdSetCoverageModulationTableNV,
                pub vkCmdSetCoverageReductionModeNV: PFN_vkCmdSetCoverageReductionModeNV,
                pub vkCmdSetCoverageToColorEnableNV: PFN_vkCmdSetCoverageToColorEnableNV,
                pub vkCmdSetCoverageToColorLocationNV: PFN_vkCmdSetCoverageToColorLocationNV,
                pub vkCmdSetCullModeEXT: PFN_vkCmdSetCullModeEXT,
                pub vkCmdSetDepthBiasEnableEXT: PFN_vkCmdSetDepthBiasEnableEXT,
                pub vkCmdSetDepthBoundsTestEnableEXT: PFN_vkCmdSetDepthBoundsTestEnableEXT,
                pub vkCmdSetDepthClampEnableEXT: PFN_vkCmdSetDepthClampEnableEXT,
                pub vkCmdSetDepthClampRangeEXT: PFN_vkCmdSetDepthClampRangeEXT,
                pub vkCmdSetDepthClipEnableEXT: PFN_vkCmdSetDepthClipEnableEXT,
                pub vkCmdSetDepthClipNegativeOneToOneEXT: PFN_vkCmdSetDepthClipNegativeOneToOneEXT,
                pub vkCmdSetDepthCompareOpEXT: PFN_vkCmdSetDepthCompareOpEXT,
                pub vkCmdSetDepthTestEnableEXT: PFN_vkCmdSetDepthTestEnableEXT,
                pub vkCmdSetDepthWriteEnableEXT: PFN_vkCmdSetDepthWriteEnableEXT,
                pub vkCmdSetExtraPrimitiveOverestimationSizeEXT: PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT,
                pub vkCmdSetFrontFaceEXT: PFN_vkCmdSetFrontFaceEXT,
                pub vkCmdSetLineRasterizationModeEXT: PFN_vkCmdSetLineRasterizationModeEXT,
                pub vkCmdSetLineStippleEnableEXT: PFN_vkCmdSetLineStippleEnableEXT,
                pub vkCmdSetLogicOpEXT: PFN_vkCmdSetLogicOpEXT,
                pub vkCmdSetLogicOpEnableEXT: PFN_vkCmdSetLogicOpEnableEXT,
                pub vkCmdSetPatchControlPointsEXT: PFN_vkCmdSetPatchControlPointsEXT,
                pub vkCmdSetPolygonModeEXT: PFN_vkCmdSetPolygonModeEXT,
                pub vkCmdSetPrimitiveRestartEnableEXT: PFN_vkCmdSetPrimitiveRestartEnableEXT,
                pub vkCmdSetPrimitiveTopologyEXT: PFN_vkCmdSetPrimitiveTopologyEXT,
                pub vkCmdSetProvokingVertexModeEXT: PFN_vkCmdSetProvokingVertexModeEXT,
                pub vkCmdSetRasterizationSamplesEXT: PFN_vkCmdSetRasterizationSamplesEXT,
                pub vkCmdSetRasterizationStreamEXT: PFN_vkCmdSetRasterizationStreamEXT,
                pub vkCmdSetRasterizerDiscardEnableEXT: PFN_vkCmdSetRasterizerDiscardEnableEXT,
                pub vkCmdSetRepresentativeFragmentTestEnableNV: PFN_vkCmdSetRepresentativeFragmentTestEnableNV,
                pub vkCmdSetSampleLocationsEnableEXT: PFN_vkCmdSetSampleLocationsEnableEXT,
                pub vkCmdSetSampleMaskEXT: PFN_vkCmdSetSampleMaskEXT,
                pub vkCmdSetScissorWithCountEXT: PFN_vkCmdSetScissorWithCountEXT,
                pub vkCmdSetShadingRateImageEnableNV: PFN_vkCmdSetShadingRateImageEnableNV,
                pub vkCmdSetStencilOpEXT: PFN_vkCmdSetStencilOpEXT,
                pub vkCmdSetStencilTestEnableEXT: PFN_vkCmdSetStencilTestEnableEXT,
                pub vkCmdSetTessellationDomainOriginEXT: PFN_vkCmdSetTessellationDomainOriginEXT,
                pub vkCmdSetVertexInputEXT: PFN_vkCmdSetVertexInputEXT,
                pub vkCmdSetViewportSwizzleNV: PFN_vkCmdSetViewportSwizzleNV,
                pub vkCmdSetViewportWScalingEnableNV: PFN_vkCmdSetViewportWScalingEnableNV,
                pub vkCmdSetViewportWithCountEXT: PFN_vkCmdSetViewportWithCountEXT,
                pub vkCreateShadersEXT: PFN_vkCreateShadersEXT,
                pub vkDestroyShaderEXT: PFN_vkDestroyShaderEXT,
                pub vkGetShaderBinaryDataEXT: PFN_vkGetShaderBinaryDataEXT,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkCmdBindShadersEXT: get(c!("vkCmdBindShadersEXT")).map(|a| a.cast()),
                        vkCmdBindVertexBuffers2EXT: get(c!("vkCmdBindVertexBuffers2EXT")).map(|a| a.cast()),
                        vkCmdSetAlphaToCoverageEnableEXT: get(c!("vkCmdSetAlphaToCoverageEnableEXT")).map(|a| a.cast()),
                        vkCmdSetAlphaToOneEnableEXT: get(c!("vkCmdSetAlphaToOneEnableEXT")).map(|a| a.cast()),
                        vkCmdSetColorBlendAdvancedEXT: get(c!("vkCmdSetColorBlendAdvancedEXT")).map(|a| a.cast()),
                        vkCmdSetColorBlendEnableEXT: get(c!("vkCmdSetColorBlendEnableEXT")).map(|a| a.cast()),
                        vkCmdSetColorBlendEquationEXT: get(c!("vkCmdSetColorBlendEquationEXT")).map(|a| a.cast()),
                        vkCmdSetColorWriteMaskEXT: get(c!("vkCmdSetColorWriteMaskEXT")).map(|a| a.cast()),
                        vkCmdSetConservativeRasterizationModeEXT: get(c!("vkCmdSetConservativeRasterizationModeEXT")).map(|a| a.cast()),
                        vkCmdSetCoverageModulationModeNV: get(c!("vkCmdSetCoverageModulationModeNV")).map(|a| a.cast()),
                        vkCmdSetCoverageModulationTableEnableNV: get(c!("vkCmdSetCoverageModulationTableEnableNV")).map(|a| a.cast()),
                        vkCmdSetCoverageModulationTableNV: get(c!("vkCmdSetCoverageModulationTableNV")).map(|a| a.cast()),
                        vkCmdSetCoverageReductionModeNV: get(c!("vkCmdSetCoverageReductionModeNV")).map(|a| a.cast()),
                        vkCmdSetCoverageToColorEnableNV: get(c!("vkCmdSetCoverageToColorEnableNV")).map(|a| a.cast()),
                        vkCmdSetCoverageToColorLocationNV: get(c!("vkCmdSetCoverageToColorLocationNV")).map(|a| a.cast()),
                        vkCmdSetCullModeEXT: get(c!("vkCmdSetCullModeEXT")).map(|a| a.cast()),
                        vkCmdSetDepthBiasEnableEXT: get(c!("vkCmdSetDepthBiasEnableEXT")).map(|a| a.cast()),
                        vkCmdSetDepthBoundsTestEnableEXT: get(c!("vkCmdSetDepthBoundsTestEnableEXT")).map(|a| a.cast()),
                        vkCmdSetDepthClampEnableEXT: get(c!("vkCmdSetDepthClampEnableEXT")).map(|a| a.cast()),
                        vkCmdSetDepthClampRangeEXT: get(c!("vkCmdSetDepthClampRangeEXT")).map(|a| a.cast()),
                        vkCmdSetDepthClipEnableEXT: get(c!("vkCmdSetDepthClipEnableEXT")).map(|a| a.cast()),
                        vkCmdSetDepthClipNegativeOneToOneEXT: get(c!("vkCmdSetDepthClipNegativeOneToOneEXT")).map(|a| a.cast()),
                        vkCmdSetDepthCompareOpEXT: get(c!("vkCmdSetDepthCompareOpEXT")).map(|a| a.cast()),
                        vkCmdSetDepthTestEnableEXT: get(c!("vkCmdSetDepthTestEnableEXT")).map(|a| a.cast()),
                        vkCmdSetDepthWriteEnableEXT: get(c!("vkCmdSetDepthWriteEnableEXT")).map(|a| a.cast()),
                        vkCmdSetExtraPrimitiveOverestimationSizeEXT: get(c!("vkCmdSetExtraPrimitiveOverestimationSizeEXT")).map(|a| a.cast()),
                        vkCmdSetFrontFaceEXT: get(c!("vkCmdSetFrontFaceEXT")).map(|a| a.cast()),
                        vkCmdSetLineRasterizationModeEXT: get(c!("vkCmdSetLineRasterizationModeEXT")).map(|a| a.cast()),
                        vkCmdSetLineStippleEnableEXT: get(c!("vkCmdSetLineStippleEnableEXT")).map(|a| a.cast()),
                        vkCmdSetLogicOpEXT: get(c!("vkCmdSetLogicOpEXT")).map(|a| a.cast()),
                        vkCmdSetLogicOpEnableEXT: get(c!("vkCmdSetLogicOpEnableEXT")).map(|a| a.cast()),
                        vkCmdSetPatchControlPointsEXT: get(c!("vkCmdSetPatchControlPointsEXT")).map(|a| a.cast()),
                        vkCmdSetPolygonModeEXT: get(c!("vkCmdSetPolygonModeEXT")).map(|a| a.cast()),
                        vkCmdSetPrimitiveRestartEnableEXT: get(c!("vkCmdSetPrimitiveRestartEnableEXT")).map(|a| a.cast()),
                        vkCmdSetPrimitiveTopologyEXT: get(c!("vkCmdSetPrimitiveTopologyEXT")).map(|a| a.cast()),
                        vkCmdSetProvokingVertexModeEXT: get(c!("vkCmdSetProvokingVertexModeEXT")).map(|a| a.cast()),
                        vkCmdSetRasterizationSamplesEXT: get(c!("vkCmdSetRasterizationSamplesEXT")).map(|a| a.cast()),
                        vkCmdSetRasterizationStreamEXT: get(c!("vkCmdSetRasterizationStreamEXT")).map(|a| a.cast()),
                        vkCmdSetRasterizerDiscardEnableEXT: get(c!("vkCmdSetRasterizerDiscardEnableEXT")).map(|a| a.cast()),
                        vkCmdSetRepresentativeFragmentTestEnableNV: get(c!("vkCmdSetRepresentativeFragmentTestEnableNV")).map(|a| a.cast()),
                        vkCmdSetSampleLocationsEnableEXT: get(c!("vkCmdSetSampleLocationsEnableEXT")).map(|a| a.cast()),
                        vkCmdSetSampleMaskEXT: get(c!("vkCmdSetSampleMaskEXT")).map(|a| a.cast()),
                        vkCmdSetScissorWithCountEXT: get(c!("vkCmdSetScissorWithCountEXT")).map(|a| a.cast()),
                        vkCmdSetShadingRateImageEnableNV: get(c!("vkCmdSetShadingRateImageEnableNV")).map(|a| a.cast()),
                        vkCmdSetStencilOpEXT: get(c!("vkCmdSetStencilOpEXT")).map(|a| a.cast()),
                        vkCmdSetStencilTestEnableEXT: get(c!("vkCmdSetStencilTestEnableEXT")).map(|a| a.cast()),
                        vkCmdSetTessellationDomainOriginEXT: get(c!("vkCmdSetTessellationDomainOriginEXT")).map(|a| a.cast()),
                        vkCmdSetVertexInputEXT: get(c!("vkCmdSetVertexInputEXT")).map(|a| a.cast()),
                        vkCmdSetViewportSwizzleNV: get(c!("vkCmdSetViewportSwizzleNV")).map(|a| a.cast()),
                        vkCmdSetViewportWScalingEnableNV: get(c!("vkCmdSetViewportWScalingEnableNV")).map(|a| a.cast()),
                        vkCmdSetViewportWithCountEXT: get(c!("vkCmdSetViewportWithCountEXT")).map(|a| a.cast()),
                        vkCreateShadersEXT: get(c!("vkCreateShadersEXT")).map(|a| a.cast()),
                        vkDestroyShaderEXT: get(c!("vkDestroyShaderEXT")).map(|a| a.cast()),
                        vkGetShaderBinaryDataEXT: get(c!("vkGetShaderBinaryDataEXT")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkCmdBindShadersEXT`
                pub unsafe fn CmdBindShadersEXT(&self, commandBuffer: VkCommandBuffer, stageCount: uint32_t, pStages: *const VkShaderStageFlags, pShaders: *const VkShaderEXT) -> () {
                    unsafe { (self.vkCmdBindShadersEXT.expect("Unable to load vkCmdBindShadersEXT"))(commandBuffer, stageCount, pStages, pShaders) }
                }
                /// `vkCmdBindVertexBuffers2EXT`
                pub unsafe fn CmdBindVertexBuffers2EXT(&self, commandBuffer: VkCommandBuffer, firstBinding: uint32_t, bindingCount: uint32_t, pBuffers: *const VkBuffer, pOffsets: *const VkDeviceSize, pSizes: *const VkDeviceSize, pStrides: *const VkDeviceSize) -> () {
                    unsafe { (self.vkCmdBindVertexBuffers2EXT.expect("Unable to load vkCmdBindVertexBuffers2EXT"))(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides) }
                }
                /// `vkCmdSetAlphaToCoverageEnableEXT`
                pub unsafe fn CmdSetAlphaToCoverageEnableEXT(&self, commandBuffer: VkCommandBuffer, alphaToCoverageEnable: VkBool32) -> () {
                    unsafe { (self.vkCmdSetAlphaToCoverageEnableEXT.expect("Unable to load vkCmdSetAlphaToCoverageEnableEXT"))(commandBuffer, alphaToCoverageEnable) }
                }
                /// `vkCmdSetAlphaToOneEnableEXT`
                pub unsafe fn CmdSetAlphaToOneEnableEXT(&self, commandBuffer: VkCommandBuffer, alphaToOneEnable: VkBool32) -> () {
                    unsafe { (self.vkCmdSetAlphaToOneEnableEXT.expect("Unable to load vkCmdSetAlphaToOneEnableEXT"))(commandBuffer, alphaToOneEnable) }
                }
                /// `vkCmdSetColorBlendAdvancedEXT`
                pub unsafe fn CmdSetColorBlendAdvancedEXT(&self, commandBuffer: VkCommandBuffer, firstAttachment: uint32_t, attachmentCount: uint32_t, pColorBlendAdvanced: *const VkColorBlendAdvancedEXT) -> () {
                    unsafe { (self.vkCmdSetColorBlendAdvancedEXT.expect("Unable to load vkCmdSetColorBlendAdvancedEXT"))(commandBuffer, firstAttachment, attachmentCount, pColorBlendAdvanced) }
                }
                /// `vkCmdSetColorBlendEnableEXT`
                pub unsafe fn CmdSetColorBlendEnableEXT(&self, commandBuffer: VkCommandBuffer, firstAttachment: uint32_t, attachmentCount: uint32_t, pColorBlendEnables: *const VkBool32) -> () {
                    unsafe { (self.vkCmdSetColorBlendEnableEXT.expect("Unable to load vkCmdSetColorBlendEnableEXT"))(commandBuffer, firstAttachment, attachmentCount, pColorBlendEnables) }
                }
                /// `vkCmdSetColorBlendEquationEXT`
                pub unsafe fn CmdSetColorBlendEquationEXT(&self, commandBuffer: VkCommandBuffer, firstAttachment: uint32_t, attachmentCount: uint32_t, pColorBlendEquations: *const VkColorBlendEquationEXT) -> () {
                    unsafe { (self.vkCmdSetColorBlendEquationEXT.expect("Unable to load vkCmdSetColorBlendEquationEXT"))(commandBuffer, firstAttachment, attachmentCount, pColorBlendEquations) }
                }
                /// `vkCmdSetColorWriteMaskEXT`
                pub unsafe fn CmdSetColorWriteMaskEXT(&self, commandBuffer: VkCommandBuffer, firstAttachment: uint32_t, attachmentCount: uint32_t, pColorWriteMasks: *const VkColorComponentFlags) -> () {
                    unsafe { (self.vkCmdSetColorWriteMaskEXT.expect("Unable to load vkCmdSetColorWriteMaskEXT"))(commandBuffer, firstAttachment, attachmentCount, pColorWriteMasks) }
                }
                /// `vkCmdSetConservativeRasterizationModeEXT`
                pub unsafe fn CmdSetConservativeRasterizationModeEXT(&self, commandBuffer: VkCommandBuffer, conservativeRasterizationMode: VkConservativeRasterizationModeEXT) -> () {
                    unsafe { (self.vkCmdSetConservativeRasterizationModeEXT.expect("Unable to load vkCmdSetConservativeRasterizationModeEXT"))(commandBuffer, conservativeRasterizationMode) }
                }
                /// `vkCmdSetCoverageModulationModeNV`
                pub unsafe fn CmdSetCoverageModulationModeNV(&self, commandBuffer: VkCommandBuffer, coverageModulationMode: VkCoverageModulationModeNV) -> () {
                    unsafe { (self.vkCmdSetCoverageModulationModeNV.expect("Unable to load vkCmdSetCoverageModulationModeNV"))(commandBuffer, coverageModulationMode) }
                }
                /// `vkCmdSetCoverageModulationTableEnableNV`
                pub unsafe fn CmdSetCoverageModulationTableEnableNV(&self, commandBuffer: VkCommandBuffer, coverageModulationTableEnable: VkBool32) -> () {
                    unsafe { (self.vkCmdSetCoverageModulationTableEnableNV.expect("Unable to load vkCmdSetCoverageModulationTableEnableNV"))(commandBuffer, coverageModulationTableEnable) }
                }
                /// `vkCmdSetCoverageModulationTableNV`
                pub unsafe fn CmdSetCoverageModulationTableNV(&self, commandBuffer: VkCommandBuffer, coverageModulationTableCount: uint32_t, pCoverageModulationTable: *const float) -> () {
                    unsafe { (self.vkCmdSetCoverageModulationTableNV.expect("Unable to load vkCmdSetCoverageModulationTableNV"))(commandBuffer, coverageModulationTableCount, pCoverageModulationTable) }
                }
                /// `vkCmdSetCoverageReductionModeNV`
                pub unsafe fn CmdSetCoverageReductionModeNV(&self, commandBuffer: VkCommandBuffer, coverageReductionMode: VkCoverageReductionModeNV) -> () {
                    unsafe { (self.vkCmdSetCoverageReductionModeNV.expect("Unable to load vkCmdSetCoverageReductionModeNV"))(commandBuffer, coverageReductionMode) }
                }
                /// `vkCmdSetCoverageToColorEnableNV`
                pub unsafe fn CmdSetCoverageToColorEnableNV(&self, commandBuffer: VkCommandBuffer, coverageToColorEnable: VkBool32) -> () {
                    unsafe { (self.vkCmdSetCoverageToColorEnableNV.expect("Unable to load vkCmdSetCoverageToColorEnableNV"))(commandBuffer, coverageToColorEnable) }
                }
                /// `vkCmdSetCoverageToColorLocationNV`
                pub unsafe fn CmdSetCoverageToColorLocationNV(&self, commandBuffer: VkCommandBuffer, coverageToColorLocation: uint32_t) -> () {
                    unsafe { (self.vkCmdSetCoverageToColorLocationNV.expect("Unable to load vkCmdSetCoverageToColorLocationNV"))(commandBuffer, coverageToColorLocation) }
                }
                /// `vkCmdSetCullModeEXT`
                pub unsafe fn CmdSetCullModeEXT(&self, commandBuffer: VkCommandBuffer, cullMode: VkCullModeFlags) -> () {
                    unsafe { (self.vkCmdSetCullModeEXT.expect("Unable to load vkCmdSetCullModeEXT"))(commandBuffer, cullMode) }
                }
                /// `vkCmdSetDepthBiasEnableEXT`
                pub unsafe fn CmdSetDepthBiasEnableEXT(&self, commandBuffer: VkCommandBuffer, depthBiasEnable: VkBool32) -> () {
                    unsafe { (self.vkCmdSetDepthBiasEnableEXT.expect("Unable to load vkCmdSetDepthBiasEnableEXT"))(commandBuffer, depthBiasEnable) }
                }
                /// `vkCmdSetDepthBoundsTestEnableEXT`
                pub unsafe fn CmdSetDepthBoundsTestEnableEXT(&self, commandBuffer: VkCommandBuffer, depthBoundsTestEnable: VkBool32) -> () {
                    unsafe { (self.vkCmdSetDepthBoundsTestEnableEXT.expect("Unable to load vkCmdSetDepthBoundsTestEnableEXT"))(commandBuffer, depthBoundsTestEnable) }
                }
                /// `vkCmdSetDepthClampEnableEXT`
                pub unsafe fn CmdSetDepthClampEnableEXT(&self, commandBuffer: VkCommandBuffer, depthClampEnable: VkBool32) -> () {
                    unsafe { (self.vkCmdSetDepthClampEnableEXT.expect("Unable to load vkCmdSetDepthClampEnableEXT"))(commandBuffer, depthClampEnable) }
                }
                /// `vkCmdSetDepthClampRangeEXT`
                pub unsafe fn CmdSetDepthClampRangeEXT(&self, commandBuffer: VkCommandBuffer, depthClampMode: VkDepthClampModeEXT, pDepthClampRange: *const VkDepthClampRangeEXT) -> () {
                    unsafe { (self.vkCmdSetDepthClampRangeEXT.expect("Unable to load vkCmdSetDepthClampRangeEXT"))(commandBuffer, depthClampMode, pDepthClampRange) }
                }
                /// `vkCmdSetDepthClipEnableEXT`
                pub unsafe fn CmdSetDepthClipEnableEXT(&self, commandBuffer: VkCommandBuffer, depthClipEnable: VkBool32) -> () {
                    unsafe { (self.vkCmdSetDepthClipEnableEXT.expect("Unable to load vkCmdSetDepthClipEnableEXT"))(commandBuffer, depthClipEnable) }
                }
                /// `vkCmdSetDepthClipNegativeOneToOneEXT`
                pub unsafe fn CmdSetDepthClipNegativeOneToOneEXT(&self, commandBuffer: VkCommandBuffer, negativeOneToOne: VkBool32) -> () {
                    unsafe { (self.vkCmdSetDepthClipNegativeOneToOneEXT.expect("Unable to load vkCmdSetDepthClipNegativeOneToOneEXT"))(commandBuffer, negativeOneToOne) }
                }
                /// `vkCmdSetDepthCompareOpEXT`
                pub unsafe fn CmdSetDepthCompareOpEXT(&self, commandBuffer: VkCommandBuffer, depthCompareOp: VkCompareOp) -> () {
                    unsafe { (self.vkCmdSetDepthCompareOpEXT.expect("Unable to load vkCmdSetDepthCompareOpEXT"))(commandBuffer, depthCompareOp) }
                }
                /// `vkCmdSetDepthTestEnableEXT`
                pub unsafe fn CmdSetDepthTestEnableEXT(&self, commandBuffer: VkCommandBuffer, depthTestEnable: VkBool32) -> () {
                    unsafe { (self.vkCmdSetDepthTestEnableEXT.expect("Unable to load vkCmdSetDepthTestEnableEXT"))(commandBuffer, depthTestEnable) }
                }
                /// `vkCmdSetDepthWriteEnableEXT`
                pub unsafe fn CmdSetDepthWriteEnableEXT(&self, commandBuffer: VkCommandBuffer, depthWriteEnable: VkBool32) -> () {
                    unsafe { (self.vkCmdSetDepthWriteEnableEXT.expect("Unable to load vkCmdSetDepthWriteEnableEXT"))(commandBuffer, depthWriteEnable) }
                }
                /// `vkCmdSetExtraPrimitiveOverestimationSizeEXT`
                pub unsafe fn CmdSetExtraPrimitiveOverestimationSizeEXT(&self, commandBuffer: VkCommandBuffer, extraPrimitiveOverestimationSize: float) -> () {
                    unsafe { (self.vkCmdSetExtraPrimitiveOverestimationSizeEXT.expect("Unable to load vkCmdSetExtraPrimitiveOverestimationSizeEXT"))(commandBuffer, extraPrimitiveOverestimationSize) }
                }
                /// `vkCmdSetFrontFaceEXT`
                pub unsafe fn CmdSetFrontFaceEXT(&self, commandBuffer: VkCommandBuffer, frontFace: VkFrontFace) -> () {
                    unsafe { (self.vkCmdSetFrontFaceEXT.expect("Unable to load vkCmdSetFrontFaceEXT"))(commandBuffer, frontFace) }
                }
                /// `vkCmdSetLineRasterizationModeEXT`
                pub unsafe fn CmdSetLineRasterizationModeEXT(&self, commandBuffer: VkCommandBuffer, lineRasterizationMode: VkLineRasterizationModeEXT) -> () {
                    unsafe { (self.vkCmdSetLineRasterizationModeEXT.expect("Unable to load vkCmdSetLineRasterizationModeEXT"))(commandBuffer, lineRasterizationMode) }
                }
                /// `vkCmdSetLineStippleEnableEXT`
                pub unsafe fn CmdSetLineStippleEnableEXT(&self, commandBuffer: VkCommandBuffer, stippledLineEnable: VkBool32) -> () {
                    unsafe { (self.vkCmdSetLineStippleEnableEXT.expect("Unable to load vkCmdSetLineStippleEnableEXT"))(commandBuffer, stippledLineEnable) }
                }
                /// `vkCmdSetLogicOpEXT`
                pub unsafe fn CmdSetLogicOpEXT(&self, commandBuffer: VkCommandBuffer, logicOp: VkLogicOp) -> () {
                    unsafe { (self.vkCmdSetLogicOpEXT.expect("Unable to load vkCmdSetLogicOpEXT"))(commandBuffer, logicOp) }
                }
                /// `vkCmdSetLogicOpEnableEXT`
                pub unsafe fn CmdSetLogicOpEnableEXT(&self, commandBuffer: VkCommandBuffer, logicOpEnable: VkBool32) -> () {
                    unsafe { (self.vkCmdSetLogicOpEnableEXT.expect("Unable to load vkCmdSetLogicOpEnableEXT"))(commandBuffer, logicOpEnable) }
                }
                /// `vkCmdSetPatchControlPointsEXT`
                pub unsafe fn CmdSetPatchControlPointsEXT(&self, commandBuffer: VkCommandBuffer, patchControlPoints: uint32_t) -> () {
                    unsafe { (self.vkCmdSetPatchControlPointsEXT.expect("Unable to load vkCmdSetPatchControlPointsEXT"))(commandBuffer, patchControlPoints) }
                }
                /// `vkCmdSetPolygonModeEXT`
                pub unsafe fn CmdSetPolygonModeEXT(&self, commandBuffer: VkCommandBuffer, polygonMode: VkPolygonMode) -> () {
                    unsafe { (self.vkCmdSetPolygonModeEXT.expect("Unable to load vkCmdSetPolygonModeEXT"))(commandBuffer, polygonMode) }
                }
                /// `vkCmdSetPrimitiveRestartEnableEXT`
                pub unsafe fn CmdSetPrimitiveRestartEnableEXT(&self, commandBuffer: VkCommandBuffer, primitiveRestartEnable: VkBool32) -> () {
                    unsafe { (self.vkCmdSetPrimitiveRestartEnableEXT.expect("Unable to load vkCmdSetPrimitiveRestartEnableEXT"))(commandBuffer, primitiveRestartEnable) }
                }
                /// `vkCmdSetPrimitiveTopologyEXT`
                pub unsafe fn CmdSetPrimitiveTopologyEXT(&self, commandBuffer: VkCommandBuffer, primitiveTopology: VkPrimitiveTopology) -> () {
                    unsafe { (self.vkCmdSetPrimitiveTopologyEXT.expect("Unable to load vkCmdSetPrimitiveTopologyEXT"))(commandBuffer, primitiveTopology) }
                }
                /// `vkCmdSetProvokingVertexModeEXT`
                pub unsafe fn CmdSetProvokingVertexModeEXT(&self, commandBuffer: VkCommandBuffer, provokingVertexMode: VkProvokingVertexModeEXT) -> () {
                    unsafe { (self.vkCmdSetProvokingVertexModeEXT.expect("Unable to load vkCmdSetProvokingVertexModeEXT"))(commandBuffer, provokingVertexMode) }
                }
                /// `vkCmdSetRasterizationSamplesEXT`
                pub unsafe fn CmdSetRasterizationSamplesEXT(&self, commandBuffer: VkCommandBuffer, rasterizationSamples: VkSampleCountFlags) -> () {
                    unsafe { (self.vkCmdSetRasterizationSamplesEXT.expect("Unable to load vkCmdSetRasterizationSamplesEXT"))(commandBuffer, rasterizationSamples) }
                }
                /// `vkCmdSetRasterizationStreamEXT`
                pub unsafe fn CmdSetRasterizationStreamEXT(&self, commandBuffer: VkCommandBuffer, rasterizationStream: uint32_t) -> () {
                    unsafe { (self.vkCmdSetRasterizationStreamEXT.expect("Unable to load vkCmdSetRasterizationStreamEXT"))(commandBuffer, rasterizationStream) }
                }
                /// `vkCmdSetRasterizerDiscardEnableEXT`
                pub unsafe fn CmdSetRasterizerDiscardEnableEXT(&self, commandBuffer: VkCommandBuffer, rasterizerDiscardEnable: VkBool32) -> () {
                    unsafe { (self.vkCmdSetRasterizerDiscardEnableEXT.expect("Unable to load vkCmdSetRasterizerDiscardEnableEXT"))(commandBuffer, rasterizerDiscardEnable) }
                }
                /// `vkCmdSetRepresentativeFragmentTestEnableNV`
                pub unsafe fn CmdSetRepresentativeFragmentTestEnableNV(&self, commandBuffer: VkCommandBuffer, representativeFragmentTestEnable: VkBool32) -> () {
                    unsafe { (self.vkCmdSetRepresentativeFragmentTestEnableNV.expect("Unable to load vkCmdSetRepresentativeFragmentTestEnableNV"))(commandBuffer, representativeFragmentTestEnable) }
                }
                /// `vkCmdSetSampleLocationsEnableEXT`
                pub unsafe fn CmdSetSampleLocationsEnableEXT(&self, commandBuffer: VkCommandBuffer, sampleLocationsEnable: VkBool32) -> () {
                    unsafe { (self.vkCmdSetSampleLocationsEnableEXT.expect("Unable to load vkCmdSetSampleLocationsEnableEXT"))(commandBuffer, sampleLocationsEnable) }
                }
                /// `vkCmdSetSampleMaskEXT`
                pub unsafe fn CmdSetSampleMaskEXT(&self, commandBuffer: VkCommandBuffer, samples: VkSampleCountFlags, pSampleMask: *const VkSampleMask) -> () {
                    unsafe { (self.vkCmdSetSampleMaskEXT.expect("Unable to load vkCmdSetSampleMaskEXT"))(commandBuffer, samples, pSampleMask) }
                }
                /// `vkCmdSetScissorWithCountEXT`
                pub unsafe fn CmdSetScissorWithCountEXT(&self, commandBuffer: VkCommandBuffer, scissorCount: uint32_t, pScissors: *const VkRect2D) -> () {
                    unsafe { (self.vkCmdSetScissorWithCountEXT.expect("Unable to load vkCmdSetScissorWithCountEXT"))(commandBuffer, scissorCount, pScissors) }
                }
                /// `vkCmdSetShadingRateImageEnableNV`
                pub unsafe fn CmdSetShadingRateImageEnableNV(&self, commandBuffer: VkCommandBuffer, shadingRateImageEnable: VkBool32) -> () {
                    unsafe { (self.vkCmdSetShadingRateImageEnableNV.expect("Unable to load vkCmdSetShadingRateImageEnableNV"))(commandBuffer, shadingRateImageEnable) }
                }
                /// `vkCmdSetStencilOpEXT`
                pub unsafe fn CmdSetStencilOpEXT(&self, commandBuffer: VkCommandBuffer, faceMask: VkStencilFaceFlags, failOp: VkStencilOp, passOp: VkStencilOp, depthFailOp: VkStencilOp, compareOp: VkCompareOp) -> () {
                    unsafe { (self.vkCmdSetStencilOpEXT.expect("Unable to load vkCmdSetStencilOpEXT"))(commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp) }
                }
                /// `vkCmdSetStencilTestEnableEXT`
                pub unsafe fn CmdSetStencilTestEnableEXT(&self, commandBuffer: VkCommandBuffer, stencilTestEnable: VkBool32) -> () {
                    unsafe { (self.vkCmdSetStencilTestEnableEXT.expect("Unable to load vkCmdSetStencilTestEnableEXT"))(commandBuffer, stencilTestEnable) }
                }
                /// `vkCmdSetTessellationDomainOriginEXT`
                pub unsafe fn CmdSetTessellationDomainOriginEXT(&self, commandBuffer: VkCommandBuffer, domainOrigin: VkTessellationDomainOrigin) -> () {
                    unsafe { (self.vkCmdSetTessellationDomainOriginEXT.expect("Unable to load vkCmdSetTessellationDomainOriginEXT"))(commandBuffer, domainOrigin) }
                }
                /// `vkCmdSetVertexInputEXT`
                pub unsafe fn CmdSetVertexInputEXT(&self, commandBuffer: VkCommandBuffer, vertexBindingDescriptionCount: uint32_t, pVertexBindingDescriptions: *const VkVertexInputBindingDescription2EXT, vertexAttributeDescriptionCount: uint32_t, pVertexAttributeDescriptions: *const VkVertexInputAttributeDescription2EXT) -> () {
                    unsafe { (self.vkCmdSetVertexInputEXT.expect("Unable to load vkCmdSetVertexInputEXT"))(commandBuffer, vertexBindingDescriptionCount, pVertexBindingDescriptions, vertexAttributeDescriptionCount, pVertexAttributeDescriptions) }
                }
                /// `vkCmdSetViewportSwizzleNV`
                pub unsafe fn CmdSetViewportSwizzleNV(&self, commandBuffer: VkCommandBuffer, firstViewport: uint32_t, viewportCount: uint32_t, pViewportSwizzles: *const VkViewportSwizzleNV) -> () {
                    unsafe { (self.vkCmdSetViewportSwizzleNV.expect("Unable to load vkCmdSetViewportSwizzleNV"))(commandBuffer, firstViewport, viewportCount, pViewportSwizzles) }
                }
                /// `vkCmdSetViewportWScalingEnableNV`
                pub unsafe fn CmdSetViewportWScalingEnableNV(&self, commandBuffer: VkCommandBuffer, viewportWScalingEnable: VkBool32) -> () {
                    unsafe { (self.vkCmdSetViewportWScalingEnableNV.expect("Unable to load vkCmdSetViewportWScalingEnableNV"))(commandBuffer, viewportWScalingEnable) }
                }
                /// `vkCmdSetViewportWithCountEXT`
                pub unsafe fn CmdSetViewportWithCountEXT(&self, commandBuffer: VkCommandBuffer, viewportCount: uint32_t, pViewports: *const VkViewport) -> () {
                    unsafe { (self.vkCmdSetViewportWithCountEXT.expect("Unable to load vkCmdSetViewportWithCountEXT"))(commandBuffer, viewportCount, pViewports) }
                }
                /// `vkCreateShadersEXT`
                pub unsafe fn CreateShadersEXT(&self, device: VkDevice, createInfoCount: uint32_t, pCreateInfos: *const VkShaderCreateInfoEXT, pAllocator: *const VkAllocationCallbacks, pShaders: *mut VkShaderEXT) -> VkResult {
                    unsafe { (self.vkCreateShadersEXT.expect("Unable to load vkCreateShadersEXT"))(device, createInfoCount, pCreateInfos, pAllocator, pShaders) }
                }
                /// `vkDestroyShaderEXT`
                pub unsafe fn DestroyShaderEXT(&self, device: VkDevice, shader: VkShaderEXT, pAllocator: *const VkAllocationCallbacks) -> () {
                    unsafe { (self.vkDestroyShaderEXT.expect("Unable to load vkDestroyShaderEXT"))(device, shader, pAllocator) }
                }
                /// `vkGetShaderBinaryDataEXT`
                pub unsafe fn GetShaderBinaryDataEXT(&self, device: VkDevice, shader: VkShaderEXT, pDataSize: *mut size_t, pData: *mut void) -> VkResult {
                    unsafe { (self.vkGetShaderBinaryDataEXT.expect("Unable to load vkGetShaderBinaryDataEXT"))(device, shader, pDataSize, pData) }
                }
            }
        }

        /// `VK_EXT_mutable_descriptor_type`
        pub mod mutable_descriptor_type {
            use super::*;

            /// `VK_EXT_mutable_descriptor_type`
            pub const NAME: &'static CStr = c!("VK_EXT_mutable_descriptor_type");
        }

        /// `VK_EXT_legacy_vertex_attributes`
        pub mod legacy_vertex_attributes {
            use super::*;

            /// `VK_EXT_legacy_vertex_attributes`
            pub const NAME: &'static CStr = c!("VK_EXT_legacy_vertex_attributes");
        }

        /// `VK_EXT_layer_settings`
        pub mod layer_settings {
            use super::*;

            /// `VK_EXT_layer_settings`
            pub const NAME: &'static CStr = c!("VK_EXT_layer_settings");
        }

        /// `VK_EXT_pipeline_library_group_handles`
        pub mod pipeline_library_group_handles {
            use super::*;

            /// `VK_EXT_pipeline_library_group_handles`
            pub const NAME: &'static CStr = c!("VK_EXT_pipeline_library_group_handles");
        }

        /// `VK_EXT_dynamic_rendering_unused_attachments`
        pub mod dynamic_rendering_unused_attachments {
            use super::*;

            /// `VK_EXT_dynamic_rendering_unused_attachments`
            pub const NAME: &'static CStr = c!("VK_EXT_dynamic_rendering_unused_attachments");
        }

        /// `VK_EXT_attachment_feedback_loop_dynamic_state`
        pub mod attachment_feedback_loop_dynamic_state {
            use super::*;

            /// `VK_EXT_attachment_feedback_loop_dynamic_state`
            pub const NAME: &'static CStr = c!("VK_EXT_attachment_feedback_loop_dynamic_state");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkCmdSetAttachmentFeedbackLoopEnableEXT: PFN_vkCmdSetAttachmentFeedbackLoopEnableEXT,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkCmdSetAttachmentFeedbackLoopEnableEXT: get(c!("vkCmdSetAttachmentFeedbackLoopEnableEXT")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkCmdSetAttachmentFeedbackLoopEnableEXT`
                pub unsafe fn CmdSetAttachmentFeedbackLoopEnableEXT(&self, commandBuffer: VkCommandBuffer, aspectMask: VkImageAspectFlags) -> () {
                    unsafe { (self.vkCmdSetAttachmentFeedbackLoopEnableEXT.expect("Unable to load vkCmdSetAttachmentFeedbackLoopEnableEXT"))(commandBuffer, aspectMask) }
                }
            }
        }

        /// `VK_EXT_memory_decompression`
        pub mod memory_decompression {
            use super::*;

            /// `VK_EXT_memory_decompression`
            pub const NAME: &'static CStr = c!("VK_EXT_memory_decompression");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkCmdDecompressMemoryEXT: PFN_vkCmdDecompressMemoryEXT,
                pub vkCmdDecompressMemoryIndirectCountEXT: PFN_vkCmdDecompressMemoryIndirectCountEXT,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkCmdDecompressMemoryEXT: get(c!("vkCmdDecompressMemoryEXT")).map(|a| a.cast()),
                        vkCmdDecompressMemoryIndirectCountEXT: get(c!("vkCmdDecompressMemoryIndirectCountEXT")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkCmdDecompressMemoryEXT`
                pub unsafe fn CmdDecompressMemoryEXT(&self, commandBuffer: VkCommandBuffer, pDecompressMemoryInfoEXT: *const VkDecompressMemoryInfoEXT) -> () {
                    unsafe { (self.vkCmdDecompressMemoryEXT.expect("Unable to load vkCmdDecompressMemoryEXT"))(commandBuffer, pDecompressMemoryInfoEXT) }
                }
                /// `vkCmdDecompressMemoryIndirectCountEXT`
                pub unsafe fn CmdDecompressMemoryIndirectCountEXT(&self, commandBuffer: VkCommandBuffer, decompressionMethod: VkMemoryDecompressionMethodFlagsEXT, indirectCommandsAddress: VkDeviceAddress, indirectCommandsCountAddress: VkDeviceAddress, maxDecompressionCount: uint32_t, stride: uint32_t) -> () {
                    unsafe { (self.vkCmdDecompressMemoryIndirectCountEXT.expect("Unable to load vkCmdDecompressMemoryIndirectCountEXT"))(commandBuffer, decompressionMethod, indirectCommandsAddress, indirectCommandsCountAddress, maxDecompressionCount, stride) }
                }
            }
        }

        /// `VK_EXT_shader_replicated_composites`
        pub mod shader_replicated_composites {
            use super::*;

            /// `VK_EXT_shader_replicated_composites`
            pub const NAME: &'static CStr = c!("VK_EXT_shader_replicated_composites");
        }

        /// `VK_EXT_shader_float8`
        pub mod shader_float8 {
            use super::*;

            /// `VK_EXT_shader_float8`
            pub const NAME: &'static CStr = c!("VK_EXT_shader_float8");
        }

        /// `VK_EXT_device_generated_commands`
        pub mod device_generated_commands {
            use super::*;

            /// `VK_EXT_device_generated_commands`
            pub const NAME: &'static CStr = c!("VK_EXT_device_generated_commands");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkCmdExecuteGeneratedCommandsEXT: PFN_vkCmdExecuteGeneratedCommandsEXT,
                pub vkCmdPreprocessGeneratedCommandsEXT: PFN_vkCmdPreprocessGeneratedCommandsEXT,
                pub vkCreateIndirectCommandsLayoutEXT: PFN_vkCreateIndirectCommandsLayoutEXT,
                pub vkCreateIndirectExecutionSetEXT: PFN_vkCreateIndirectExecutionSetEXT,
                pub vkDestroyIndirectCommandsLayoutEXT: PFN_vkDestroyIndirectCommandsLayoutEXT,
                pub vkDestroyIndirectExecutionSetEXT: PFN_vkDestroyIndirectExecutionSetEXT,
                pub vkGetGeneratedCommandsMemoryRequirementsEXT: PFN_vkGetGeneratedCommandsMemoryRequirementsEXT,
                pub vkUpdateIndirectExecutionSetPipelineEXT: PFN_vkUpdateIndirectExecutionSetPipelineEXT,
                pub vkUpdateIndirectExecutionSetShaderEXT: PFN_vkUpdateIndirectExecutionSetShaderEXT,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkCmdExecuteGeneratedCommandsEXT: get(c!("vkCmdExecuteGeneratedCommandsEXT")).map(|a| a.cast()),
                        vkCmdPreprocessGeneratedCommandsEXT: get(c!("vkCmdPreprocessGeneratedCommandsEXT")).map(|a| a.cast()),
                        vkCreateIndirectCommandsLayoutEXT: get(c!("vkCreateIndirectCommandsLayoutEXT")).map(|a| a.cast()),
                        vkCreateIndirectExecutionSetEXT: get(c!("vkCreateIndirectExecutionSetEXT")).map(|a| a.cast()),
                        vkDestroyIndirectCommandsLayoutEXT: get(c!("vkDestroyIndirectCommandsLayoutEXT")).map(|a| a.cast()),
                        vkDestroyIndirectExecutionSetEXT: get(c!("vkDestroyIndirectExecutionSetEXT")).map(|a| a.cast()),
                        vkGetGeneratedCommandsMemoryRequirementsEXT: get(c!("vkGetGeneratedCommandsMemoryRequirementsEXT")).map(|a| a.cast()),
                        vkUpdateIndirectExecutionSetPipelineEXT: get(c!("vkUpdateIndirectExecutionSetPipelineEXT")).map(|a| a.cast()),
                        vkUpdateIndirectExecutionSetShaderEXT: get(c!("vkUpdateIndirectExecutionSetShaderEXT")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkCmdExecuteGeneratedCommandsEXT`
                pub unsafe fn CmdExecuteGeneratedCommandsEXT(&self, commandBuffer: VkCommandBuffer, isPreprocessed: VkBool32, pGeneratedCommandsInfo: *const VkGeneratedCommandsInfoEXT) -> () {
                    unsafe { (self.vkCmdExecuteGeneratedCommandsEXT.expect("Unable to load vkCmdExecuteGeneratedCommandsEXT"))(commandBuffer, isPreprocessed, pGeneratedCommandsInfo) }
                }
                /// `vkCmdPreprocessGeneratedCommandsEXT`
                pub unsafe fn CmdPreprocessGeneratedCommandsEXT(&self, commandBuffer: VkCommandBuffer, pGeneratedCommandsInfo: *const VkGeneratedCommandsInfoEXT, stateCommandBuffer: VkCommandBuffer) -> () {
                    unsafe { (self.vkCmdPreprocessGeneratedCommandsEXT.expect("Unable to load vkCmdPreprocessGeneratedCommandsEXT"))(commandBuffer, pGeneratedCommandsInfo, stateCommandBuffer) }
                }
                /// `vkCreateIndirectCommandsLayoutEXT`
                pub unsafe fn CreateIndirectCommandsLayoutEXT(&self, device: VkDevice, pCreateInfo: *const VkIndirectCommandsLayoutCreateInfoEXT, pAllocator: *const VkAllocationCallbacks, pIndirectCommandsLayout: *mut VkIndirectCommandsLayoutEXT) -> VkResult {
                    unsafe { (self.vkCreateIndirectCommandsLayoutEXT.expect("Unable to load vkCreateIndirectCommandsLayoutEXT"))(device, pCreateInfo, pAllocator, pIndirectCommandsLayout) }
                }
                /// `vkCreateIndirectExecutionSetEXT`
                pub unsafe fn CreateIndirectExecutionSetEXT(&self, device: VkDevice, pCreateInfo: *const VkIndirectExecutionSetCreateInfoEXT, pAllocator: *const VkAllocationCallbacks, pIndirectExecutionSet: *mut VkIndirectExecutionSetEXT) -> VkResult {
                    unsafe { (self.vkCreateIndirectExecutionSetEXT.expect("Unable to load vkCreateIndirectExecutionSetEXT"))(device, pCreateInfo, pAllocator, pIndirectExecutionSet) }
                }
                /// `vkDestroyIndirectCommandsLayoutEXT`
                pub unsafe fn DestroyIndirectCommandsLayoutEXT(&self, device: VkDevice, indirectCommandsLayout: VkIndirectCommandsLayoutEXT, pAllocator: *const VkAllocationCallbacks) -> () {
                    unsafe { (self.vkDestroyIndirectCommandsLayoutEXT.expect("Unable to load vkDestroyIndirectCommandsLayoutEXT"))(device, indirectCommandsLayout, pAllocator) }
                }
                /// `vkDestroyIndirectExecutionSetEXT`
                pub unsafe fn DestroyIndirectExecutionSetEXT(&self, device: VkDevice, indirectExecutionSet: VkIndirectExecutionSetEXT, pAllocator: *const VkAllocationCallbacks) -> () {
                    unsafe { (self.vkDestroyIndirectExecutionSetEXT.expect("Unable to load vkDestroyIndirectExecutionSetEXT"))(device, indirectExecutionSet, pAllocator) }
                }
                /// `vkGetGeneratedCommandsMemoryRequirementsEXT`
                pub unsafe fn GetGeneratedCommandsMemoryRequirementsEXT(&self, device: VkDevice, pInfo: *const VkGeneratedCommandsMemoryRequirementsInfoEXT, pMemoryRequirements: *mut VkMemoryRequirements2) -> () {
                    unsafe { (self.vkGetGeneratedCommandsMemoryRequirementsEXT.expect("Unable to load vkGetGeneratedCommandsMemoryRequirementsEXT"))(device, pInfo, pMemoryRequirements) }
                }
                /// `vkUpdateIndirectExecutionSetPipelineEXT`
                pub unsafe fn UpdateIndirectExecutionSetPipelineEXT(&self, device: VkDevice, indirectExecutionSet: VkIndirectExecutionSetEXT, executionSetWriteCount: uint32_t, pExecutionSetWrites: *const VkWriteIndirectExecutionSetPipelineEXT) -> () {
                    unsafe { (self.vkUpdateIndirectExecutionSetPipelineEXT.expect("Unable to load vkUpdateIndirectExecutionSetPipelineEXT"))(device, indirectExecutionSet, executionSetWriteCount, pExecutionSetWrites) }
                }
                /// `vkUpdateIndirectExecutionSetShaderEXT`
                pub unsafe fn UpdateIndirectExecutionSetShaderEXT(&self, device: VkDevice, indirectExecutionSet: VkIndirectExecutionSetEXT, executionSetWriteCount: uint32_t, pExecutionSetWrites: *const VkWriteIndirectExecutionSetShaderEXT) -> () {
                    unsafe { (self.vkUpdateIndirectExecutionSetShaderEXT.expect("Unable to load vkUpdateIndirectExecutionSetShaderEXT"))(device, indirectExecutionSet, executionSetWriteCount, pExecutionSetWrites) }
                }
            }
        }

        /// `VK_EXT_ray_tracing_invocation_reorder`
        pub mod ray_tracing_invocation_reorder {
            use super::*;

            /// `VK_EXT_ray_tracing_invocation_reorder`
            pub const NAME: &'static CStr = c!("VK_EXT_ray_tracing_invocation_reorder");
        }

        /// `VK_EXT_depth_clamp_control`
        pub mod depth_clamp_control {
            use super::*;

            /// `VK_EXT_depth_clamp_control`
            pub const NAME: &'static CStr = c!("VK_EXT_depth_clamp_control");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkCmdSetDepthClampRangeEXT: PFN_vkCmdSetDepthClampRangeEXT,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkCmdSetDepthClampRangeEXT: get(c!("vkCmdSetDepthClampRangeEXT")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkCmdSetDepthClampRangeEXT`
                pub unsafe fn CmdSetDepthClampRangeEXT(&self, commandBuffer: VkCommandBuffer, depthClampMode: VkDepthClampModeEXT, pDepthClampRange: *const VkDepthClampRangeEXT) -> () {
                    unsafe { (self.vkCmdSetDepthClampRangeEXT.expect("Unable to load vkCmdSetDepthClampRangeEXT"))(commandBuffer, depthClampMode, pDepthClampRange) }
                }
            }
        }

        /// `VK_EXT_external_memory_metal`
        pub mod external_memory_metal {
            use super::*;

            /// `VK_EXT_external_memory_metal`
            pub const NAME: &'static CStr = c!("VK_EXT_external_memory_metal");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkGetMemoryMetalHandleEXT: PFN_vkGetMemoryMetalHandleEXT,
                pub vkGetMemoryMetalHandlePropertiesEXT: PFN_vkGetMemoryMetalHandlePropertiesEXT,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkGetMemoryMetalHandleEXT: get(c!("vkGetMemoryMetalHandleEXT")).map(|a| a.cast()),
                        vkGetMemoryMetalHandlePropertiesEXT: get(c!("vkGetMemoryMetalHandlePropertiesEXT")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkGetMemoryMetalHandleEXT`
                pub unsafe fn GetMemoryMetalHandleEXT(&self, device: VkDevice, pGetMetalHandleInfo: *const VkMemoryGetMetalHandleInfoEXT, pHandle: *mut *mut void) -> VkResult {
                    unsafe { (self.vkGetMemoryMetalHandleEXT.expect("Unable to load vkGetMemoryMetalHandleEXT"))(device, pGetMetalHandleInfo, pHandle) }
                }
                /// `vkGetMemoryMetalHandlePropertiesEXT`
                pub unsafe fn GetMemoryMetalHandlePropertiesEXT(&self, device: VkDevice, handleType: VkExternalMemoryHandleTypeFlags, pHandle: *const void, pMemoryMetalHandleProperties: *mut VkMemoryMetalHandlePropertiesEXT) -> VkResult {
                    unsafe { (self.vkGetMemoryMetalHandlePropertiesEXT.expect("Unable to load vkGetMemoryMetalHandlePropertiesEXT"))(device, handleType, pHandle, pMemoryMetalHandleProperties) }
                }
            }
        }

        /// `VK_EXT_vertex_attribute_robustness`
        pub mod vertex_attribute_robustness {
            use super::*;

            /// `VK_EXT_vertex_attribute_robustness`
            pub const NAME: &'static CStr = c!("VK_EXT_vertex_attribute_robustness");
        }

        /// `VK_EXT_fragment_density_map_offset`
        pub mod fragment_density_map_offset {
            use super::*;

            /// `VK_EXT_fragment_density_map_offset`
            pub const NAME: &'static CStr = c!("VK_EXT_fragment_density_map_offset");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkCmdEndRendering2EXT: PFN_vkCmdEndRendering2EXT,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkCmdEndRendering2EXT: get(c!("vkCmdEndRendering2EXT")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkCmdEndRendering2EXT`
                pub unsafe fn CmdEndRendering2EXT(&self, commandBuffer: VkCommandBuffer, pRenderingEndInfo: *const VkRenderingEndInfoKHR) -> () {
                    unsafe { (self.vkCmdEndRendering2EXT.expect("Unable to load vkCmdEndRendering2EXT"))(commandBuffer, pRenderingEndInfo) }
                }
            }
        }

        /// `VK_EXT_zero_initialize_device_memory`
        pub mod zero_initialize_device_memory {
            use super::*;

            /// `VK_EXT_zero_initialize_device_memory`
            pub const NAME: &'static CStr = c!("VK_EXT_zero_initialize_device_memory");
        }

        /// `VK_EXT_shader_64bit_indexing`
        pub mod shader_64bit_indexing {
            use super::*;

            /// `VK_EXT_shader_64bit_indexing`
            pub const NAME: &'static CStr = c!("VK_EXT_shader_64bit_indexing");
        }

        /// `VK_EXT_custom_resolve`
        pub mod custom_resolve {
            use super::*;

            /// `VK_EXT_custom_resolve`
            pub const NAME: &'static CStr = c!("VK_EXT_custom_resolve");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkCmdBeginCustomResolveEXT: PFN_vkCmdBeginCustomResolveEXT,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkCmdBeginCustomResolveEXT: get(c!("vkCmdBeginCustomResolveEXT")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkCmdBeginCustomResolveEXT`
                pub unsafe fn CmdBeginCustomResolveEXT(&self, commandBuffer: VkCommandBuffer, pBeginCustomResolveInfo: *const VkBeginCustomResolveInfoEXT) -> () {
                    unsafe { (self.vkCmdBeginCustomResolveEXT.expect("Unable to load vkCmdBeginCustomResolveEXT"))(commandBuffer, pBeginCustomResolveInfo) }
                }
            }
        }

        /// `VK_EXT_shader_long_vector`
        pub mod shader_long_vector {
            use super::*;

            /// `VK_EXT_shader_long_vector`
            pub const NAME: &'static CStr = c!("VK_EXT_shader_long_vector");
        }

        /// `VK_EXT_shader_uniform_buffer_unsized_array`
        pub mod shader_uniform_buffer_unsized_array {
            use super::*;

            /// `VK_EXT_shader_uniform_buffer_unsized_array`
            pub const NAME: &'static CStr = c!("VK_EXT_shader_uniform_buffer_unsized_array");
        }

        /// `VK_EXT_shader_subgroup_partitioned`
        pub mod shader_subgroup_partitioned {
            use super::*;

            /// `VK_EXT_shader_subgroup_partitioned`
            pub const NAME: &'static CStr = c!("VK_EXT_shader_subgroup_partitioned");
        }
    }
    /// `FUCHSIA` prefix extensions
    pub mod fuchsia {
        use core::ffi::CStr;
        use crate::loader::*;
        use crate::ffi::*;
        use crate::*;

        /// `VK_FUCHSIA_imagepipe_surface`
        pub mod imagepipe_surface {
            use super::*;

            /// `VK_FUCHSIA_imagepipe_surface`
            pub const NAME: &'static CStr = c!("VK_FUCHSIA_imagepipe_surface");

            /// InstanceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct InstanceCommands {
                pub vkCreateImagePipeSurfaceFUCHSIA: PFN_vkCreateImagePipeSurfaceFUCHSIA,
            }

            impl InstanceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkCreateImagePipeSurfaceFUCHSIA: get(c!("vkCreateImagePipeSurfaceFUCHSIA")).map(|a| a.cast()),
                    } }
                }
            }

            impl InstanceCommands {
                /// `vkCreateImagePipeSurfaceFUCHSIA`
                pub unsafe fn CreateImagePipeSurfaceFUCHSIA(&self, instance: VkInstance, pCreateInfo: *const VkImagePipeSurfaceCreateInfoFUCHSIA, pAllocator: *const VkAllocationCallbacks, pSurface: *mut VkSurfaceKHR) -> VkResult {
                    unsafe { (self.vkCreateImagePipeSurfaceFUCHSIA.expect("Unable to load vkCreateImagePipeSurfaceFUCHSIA"))(instance, pCreateInfo, pAllocator, pSurface) }
                }
            }
        }

        /// `VK_FUCHSIA_external_memory`
        pub mod external_memory {
            use super::*;

            /// `VK_FUCHSIA_external_memory`
            pub const NAME: &'static CStr = c!("VK_FUCHSIA_external_memory");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkGetMemoryZirconHandleFUCHSIA: PFN_vkGetMemoryZirconHandleFUCHSIA,
                pub vkGetMemoryZirconHandlePropertiesFUCHSIA: PFN_vkGetMemoryZirconHandlePropertiesFUCHSIA,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkGetMemoryZirconHandleFUCHSIA: get(c!("vkGetMemoryZirconHandleFUCHSIA")).map(|a| a.cast()),
                        vkGetMemoryZirconHandlePropertiesFUCHSIA: get(c!("vkGetMemoryZirconHandlePropertiesFUCHSIA")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkGetMemoryZirconHandleFUCHSIA`
                pub unsafe fn GetMemoryZirconHandleFUCHSIA(&self, device: VkDevice, pGetZirconHandleInfo: *const VkMemoryGetZirconHandleInfoFUCHSIA, pZirconHandle: *mut zx_handle_t) -> VkResult {
                    unsafe { (self.vkGetMemoryZirconHandleFUCHSIA.expect("Unable to load vkGetMemoryZirconHandleFUCHSIA"))(device, pGetZirconHandleInfo, pZirconHandle) }
                }
                /// `vkGetMemoryZirconHandlePropertiesFUCHSIA`
                pub unsafe fn GetMemoryZirconHandlePropertiesFUCHSIA(&self, device: VkDevice, handleType: VkExternalMemoryHandleTypeFlags, zirconHandle: zx_handle_t, pMemoryZirconHandleProperties: *mut VkMemoryZirconHandlePropertiesFUCHSIA) -> VkResult {
                    unsafe { (self.vkGetMemoryZirconHandlePropertiesFUCHSIA.expect("Unable to load vkGetMemoryZirconHandlePropertiesFUCHSIA"))(device, handleType, zirconHandle, pMemoryZirconHandleProperties) }
                }
            }
        }

        /// `VK_FUCHSIA_external_semaphore`
        pub mod external_semaphore {
            use super::*;

            /// `VK_FUCHSIA_external_semaphore`
            pub const NAME: &'static CStr = c!("VK_FUCHSIA_external_semaphore");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkGetSemaphoreZirconHandleFUCHSIA: PFN_vkGetSemaphoreZirconHandleFUCHSIA,
                pub vkImportSemaphoreZirconHandleFUCHSIA: PFN_vkImportSemaphoreZirconHandleFUCHSIA,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkGetSemaphoreZirconHandleFUCHSIA: get(c!("vkGetSemaphoreZirconHandleFUCHSIA")).map(|a| a.cast()),
                        vkImportSemaphoreZirconHandleFUCHSIA: get(c!("vkImportSemaphoreZirconHandleFUCHSIA")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkGetSemaphoreZirconHandleFUCHSIA`
                pub unsafe fn GetSemaphoreZirconHandleFUCHSIA(&self, device: VkDevice, pGetZirconHandleInfo: *const VkSemaphoreGetZirconHandleInfoFUCHSIA, pZirconHandle: *mut zx_handle_t) -> VkResult {
                    unsafe { (self.vkGetSemaphoreZirconHandleFUCHSIA.expect("Unable to load vkGetSemaphoreZirconHandleFUCHSIA"))(device, pGetZirconHandleInfo, pZirconHandle) }
                }
                /// `vkImportSemaphoreZirconHandleFUCHSIA`
                pub unsafe fn ImportSemaphoreZirconHandleFUCHSIA(&self, device: VkDevice, pImportSemaphoreZirconHandleInfo: *const VkImportSemaphoreZirconHandleInfoFUCHSIA) -> VkResult {
                    unsafe { (self.vkImportSemaphoreZirconHandleFUCHSIA.expect("Unable to load vkImportSemaphoreZirconHandleFUCHSIA"))(device, pImportSemaphoreZirconHandleInfo) }
                }
            }
        }

        /// `VK_FUCHSIA_buffer_collection`
        pub mod buffer_collection {
            use super::*;

            /// `VK_FUCHSIA_buffer_collection`
            pub const NAME: &'static CStr = c!("VK_FUCHSIA_buffer_collection");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkCreateBufferCollectionFUCHSIA: PFN_vkCreateBufferCollectionFUCHSIA,
                pub vkDestroyBufferCollectionFUCHSIA: PFN_vkDestroyBufferCollectionFUCHSIA,
                pub vkGetBufferCollectionPropertiesFUCHSIA: PFN_vkGetBufferCollectionPropertiesFUCHSIA,
                pub vkSetBufferCollectionBufferConstraintsFUCHSIA: PFN_vkSetBufferCollectionBufferConstraintsFUCHSIA,
                pub vkSetBufferCollectionImageConstraintsFUCHSIA: PFN_vkSetBufferCollectionImageConstraintsFUCHSIA,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkCreateBufferCollectionFUCHSIA: get(c!("vkCreateBufferCollectionFUCHSIA")).map(|a| a.cast()),
                        vkDestroyBufferCollectionFUCHSIA: get(c!("vkDestroyBufferCollectionFUCHSIA")).map(|a| a.cast()),
                        vkGetBufferCollectionPropertiesFUCHSIA: get(c!("vkGetBufferCollectionPropertiesFUCHSIA")).map(|a| a.cast()),
                        vkSetBufferCollectionBufferConstraintsFUCHSIA: get(c!("vkSetBufferCollectionBufferConstraintsFUCHSIA")).map(|a| a.cast()),
                        vkSetBufferCollectionImageConstraintsFUCHSIA: get(c!("vkSetBufferCollectionImageConstraintsFUCHSIA")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkCreateBufferCollectionFUCHSIA`
                pub unsafe fn CreateBufferCollectionFUCHSIA(&self, device: VkDevice, pCreateInfo: *const VkBufferCollectionCreateInfoFUCHSIA, pAllocator: *const VkAllocationCallbacks, pCollection: *mut VkBufferCollectionFUCHSIA) -> VkResult {
                    unsafe { (self.vkCreateBufferCollectionFUCHSIA.expect("Unable to load vkCreateBufferCollectionFUCHSIA"))(device, pCreateInfo, pAllocator, pCollection) }
                }
                /// `vkDestroyBufferCollectionFUCHSIA`
                pub unsafe fn DestroyBufferCollectionFUCHSIA(&self, device: VkDevice, collection: VkBufferCollectionFUCHSIA, pAllocator: *const VkAllocationCallbacks) -> () {
                    unsafe { (self.vkDestroyBufferCollectionFUCHSIA.expect("Unable to load vkDestroyBufferCollectionFUCHSIA"))(device, collection, pAllocator) }
                }
                /// `vkGetBufferCollectionPropertiesFUCHSIA`
                pub unsafe fn GetBufferCollectionPropertiesFUCHSIA(&self, device: VkDevice, collection: VkBufferCollectionFUCHSIA, pProperties: *mut VkBufferCollectionPropertiesFUCHSIA) -> VkResult {
                    unsafe { (self.vkGetBufferCollectionPropertiesFUCHSIA.expect("Unable to load vkGetBufferCollectionPropertiesFUCHSIA"))(device, collection, pProperties) }
                }
                /// `vkSetBufferCollectionBufferConstraintsFUCHSIA`
                pub unsafe fn SetBufferCollectionBufferConstraintsFUCHSIA(&self, device: VkDevice, collection: VkBufferCollectionFUCHSIA, pBufferConstraintsInfo: *const VkBufferConstraintsInfoFUCHSIA) -> VkResult {
                    unsafe { (self.vkSetBufferCollectionBufferConstraintsFUCHSIA.expect("Unable to load vkSetBufferCollectionBufferConstraintsFUCHSIA"))(device, collection, pBufferConstraintsInfo) }
                }
                /// `vkSetBufferCollectionImageConstraintsFUCHSIA`
                pub unsafe fn SetBufferCollectionImageConstraintsFUCHSIA(&self, device: VkDevice, collection: VkBufferCollectionFUCHSIA, pImageConstraintsInfo: *const VkImageConstraintsInfoFUCHSIA) -> VkResult {
                    unsafe { (self.vkSetBufferCollectionImageConstraintsFUCHSIA.expect("Unable to load vkSetBufferCollectionImageConstraintsFUCHSIA"))(device, collection, pImageConstraintsInfo) }
                }
            }
        }
    }
    /// `GGP` prefix extensions
    pub mod ggp {
        use core::ffi::CStr;
        use crate::loader::*;
        use crate::ffi::*;
        use crate::*;

        /// `VK_GGP_stream_descriptor_surface`
        pub mod stream_descriptor_surface {
            use super::*;

            /// `VK_GGP_stream_descriptor_surface`
            pub const NAME: &'static CStr = c!("VK_GGP_stream_descriptor_surface");

            /// InstanceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct InstanceCommands {
                pub vkCreateStreamDescriptorSurfaceGGP: PFN_vkCreateStreamDescriptorSurfaceGGP,
            }

            impl InstanceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkCreateStreamDescriptorSurfaceGGP: get(c!("vkCreateStreamDescriptorSurfaceGGP")).map(|a| a.cast()),
                    } }
                }
            }

            impl InstanceCommands {
                /// `vkCreateStreamDescriptorSurfaceGGP`
                pub unsafe fn CreateStreamDescriptorSurfaceGGP(&self, instance: VkInstance, pCreateInfo: *const VkStreamDescriptorSurfaceCreateInfoGGP, pAllocator: *const VkAllocationCallbacks, pSurface: *mut VkSurfaceKHR) -> VkResult {
                    unsafe { (self.vkCreateStreamDescriptorSurfaceGGP.expect("Unable to load vkCreateStreamDescriptorSurfaceGGP"))(instance, pCreateInfo, pAllocator, pSurface) }
                }
            }
        }

        /// `VK_GGP_frame_token`
        pub mod frame_token {
            use super::*;

            /// `VK_GGP_frame_token`
            pub const NAME: &'static CStr = c!("VK_GGP_frame_token");
        }
    }
    /// `GOOGLE` prefix extensions
    pub mod google {
        use core::ffi::CStr;
        use crate::loader::*;
        use crate::ffi::*;
        use crate::*;

        /// `VK_GOOGLE_display_timing`
        pub mod display_timing {
            use super::*;

            /// `VK_GOOGLE_display_timing`
            pub const NAME: &'static CStr = c!("VK_GOOGLE_display_timing");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkGetPastPresentationTimingGOOGLE: PFN_vkGetPastPresentationTimingGOOGLE,
                pub vkGetRefreshCycleDurationGOOGLE: PFN_vkGetRefreshCycleDurationGOOGLE,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkGetPastPresentationTimingGOOGLE: get(c!("vkGetPastPresentationTimingGOOGLE")).map(|a| a.cast()),
                        vkGetRefreshCycleDurationGOOGLE: get(c!("vkGetRefreshCycleDurationGOOGLE")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkGetPastPresentationTimingGOOGLE`
                pub unsafe fn GetPastPresentationTimingGOOGLE(&self, device: VkDevice, swapchain: VkSwapchainKHR, pPresentationTimingCount: *mut uint32_t, pPresentationTimings: *mut VkPastPresentationTimingGOOGLE) -> VkResult {
                    unsafe { (self.vkGetPastPresentationTimingGOOGLE.expect("Unable to load vkGetPastPresentationTimingGOOGLE"))(device, swapchain, pPresentationTimingCount, pPresentationTimings) }
                }
                /// `vkGetRefreshCycleDurationGOOGLE`
                pub unsafe fn GetRefreshCycleDurationGOOGLE(&self, device: VkDevice, swapchain: VkSwapchainKHR, pDisplayTimingProperties: *mut VkRefreshCycleDurationGOOGLE) -> VkResult {
                    unsafe { (self.vkGetRefreshCycleDurationGOOGLE.expect("Unable to load vkGetRefreshCycleDurationGOOGLE"))(device, swapchain, pDisplayTimingProperties) }
                }
            }
        }

        /// `VK_GOOGLE_hlsl_functionality1`
        pub mod hlsl_functionality1 {
            use super::*;

            /// `VK_GOOGLE_hlsl_functionality1`
            pub const NAME: &'static CStr = c!("VK_GOOGLE_hlsl_functionality1");
        }

        /// `VK_GOOGLE_decorate_string`
        pub mod decorate_string {
            use super::*;

            /// `VK_GOOGLE_decorate_string`
            pub const NAME: &'static CStr = c!("VK_GOOGLE_decorate_string");
        }

        /// `VK_GOOGLE_user_type`
        pub mod user_type {
            use super::*;

            /// `VK_GOOGLE_user_type`
            pub const NAME: &'static CStr = c!("VK_GOOGLE_user_type");
        }

        /// `VK_GOOGLE_surfaceless_query`
        pub mod surfaceless_query {
            use super::*;

            /// `VK_GOOGLE_surfaceless_query`
            pub const NAME: &'static CStr = c!("VK_GOOGLE_surfaceless_query");
        }
    }
    /// `HUAWEI` prefix extensions
    pub mod huawei {
        use core::ffi::CStr;
        use crate::loader::*;
        use crate::ffi::*;
        use crate::*;

        /// `VK_HUAWEI_subpass_shading`
        pub mod subpass_shading {
            use super::*;

            /// `VK_HUAWEI_subpass_shading`
            pub const NAME: &'static CStr = c!("VK_HUAWEI_subpass_shading");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkCmdSubpassShadingHUAWEI: PFN_vkCmdSubpassShadingHUAWEI,
                pub vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI: PFN_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkCmdSubpassShadingHUAWEI: get(c!("vkCmdSubpassShadingHUAWEI")).map(|a| a.cast()),
                        vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI: get(c!("vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkCmdSubpassShadingHUAWEI`
                pub unsafe fn CmdSubpassShadingHUAWEI(&self, commandBuffer: VkCommandBuffer) -> () {
                    unsafe { (self.vkCmdSubpassShadingHUAWEI.expect("Unable to load vkCmdSubpassShadingHUAWEI"))(commandBuffer) }
                }
                /// `vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI`
                pub unsafe fn GetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(&self, device: VkDevice, renderpass: VkRenderPass, pMaxWorkgroupSize: *mut VkExtent2D) -> VkResult {
                    unsafe { (self.vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI.expect("Unable to load vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI"))(device, renderpass, pMaxWorkgroupSize) }
                }
            }
        }

        /// `VK_HUAWEI_invocation_mask`
        pub mod invocation_mask {
            use super::*;

            /// `VK_HUAWEI_invocation_mask`
            pub const NAME: &'static CStr = c!("VK_HUAWEI_invocation_mask");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkCmdBindInvocationMaskHUAWEI: PFN_vkCmdBindInvocationMaskHUAWEI,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkCmdBindInvocationMaskHUAWEI: get(c!("vkCmdBindInvocationMaskHUAWEI")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkCmdBindInvocationMaskHUAWEI`
                pub unsafe fn CmdBindInvocationMaskHUAWEI(&self, commandBuffer: VkCommandBuffer, imageView: VkImageView, imageLayout: VkImageLayout) -> () {
                    unsafe { (self.vkCmdBindInvocationMaskHUAWEI.expect("Unable to load vkCmdBindInvocationMaskHUAWEI"))(commandBuffer, imageView, imageLayout) }
                }
            }
        }

        /// `VK_HUAWEI_cluster_culling_shader`
        pub mod cluster_culling_shader {
            use super::*;

            /// `VK_HUAWEI_cluster_culling_shader`
            pub const NAME: &'static CStr = c!("VK_HUAWEI_cluster_culling_shader");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkCmdDrawClusterHUAWEI: PFN_vkCmdDrawClusterHUAWEI,
                pub vkCmdDrawClusterIndirectHUAWEI: PFN_vkCmdDrawClusterIndirectHUAWEI,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkCmdDrawClusterHUAWEI: get(c!("vkCmdDrawClusterHUAWEI")).map(|a| a.cast()),
                        vkCmdDrawClusterIndirectHUAWEI: get(c!("vkCmdDrawClusterIndirectHUAWEI")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkCmdDrawClusterHUAWEI`
                pub unsafe fn CmdDrawClusterHUAWEI(&self, commandBuffer: VkCommandBuffer, groupCountX: uint32_t, groupCountY: uint32_t, groupCountZ: uint32_t) -> () {
                    unsafe { (self.vkCmdDrawClusterHUAWEI.expect("Unable to load vkCmdDrawClusterHUAWEI"))(commandBuffer, groupCountX, groupCountY, groupCountZ) }
                }
                /// `vkCmdDrawClusterIndirectHUAWEI`
                pub unsafe fn CmdDrawClusterIndirectHUAWEI(&self, commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize) -> () {
                    unsafe { (self.vkCmdDrawClusterIndirectHUAWEI.expect("Unable to load vkCmdDrawClusterIndirectHUAWEI"))(commandBuffer, buffer, offset) }
                }
            }
        }

        /// `VK_HUAWEI_hdr_vivid`
        pub mod hdr_vivid {
            use super::*;

            /// `VK_HUAWEI_hdr_vivid`
            pub const NAME: &'static CStr = c!("VK_HUAWEI_hdr_vivid");
        }
    }
    /// `IMG` prefix extensions
    pub mod img {
        use core::ffi::CStr;
        use crate::loader::*;
        use crate::ffi::*;
        use crate::*;

        /// `VK_IMG_filter_cubic`
        pub mod filter_cubic {
            use super::*;

            /// `VK_IMG_filter_cubic`
            pub const NAME: &'static CStr = c!("VK_IMG_filter_cubic");
        }

        /// `VK_IMG_format_pvrtc`
        pub mod format_pvrtc {
            use super::*;

            /// `VK_IMG_format_pvrtc`
            pub const NAME: &'static CStr = c!("VK_IMG_format_pvrtc");
        }

        /// `VK_IMG_relaxed_line_rasterization`
        pub mod relaxed_line_rasterization {
            use super::*;

            /// `VK_IMG_relaxed_line_rasterization`
            pub const NAME: &'static CStr = c!("VK_IMG_relaxed_line_rasterization");
        }
    }
    /// `INTEL` prefix extensions
    pub mod intel {
        use core::ffi::CStr;
        use crate::loader::*;
        use crate::ffi::*;
        use crate::*;

        /// `VK_INTEL_shader_integer_functions2`
        pub mod shader_integer_functions2 {
            use super::*;

            /// `VK_INTEL_shader_integer_functions2`
            pub const NAME: &'static CStr = c!("VK_INTEL_shader_integer_functions2");
        }

        /// `VK_INTEL_performance_query`
        pub mod performance_query {
            use super::*;

            /// `VK_INTEL_performance_query`
            pub const NAME: &'static CStr = c!("VK_INTEL_performance_query");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkAcquirePerformanceConfigurationINTEL: PFN_vkAcquirePerformanceConfigurationINTEL,
                pub vkCmdSetPerformanceMarkerINTEL: PFN_vkCmdSetPerformanceMarkerINTEL,
                pub vkCmdSetPerformanceOverrideINTEL: PFN_vkCmdSetPerformanceOverrideINTEL,
                pub vkCmdSetPerformanceStreamMarkerINTEL: PFN_vkCmdSetPerformanceStreamMarkerINTEL,
                pub vkGetPerformanceParameterINTEL: PFN_vkGetPerformanceParameterINTEL,
                pub vkInitializePerformanceApiINTEL: PFN_vkInitializePerformanceApiINTEL,
                pub vkQueueSetPerformanceConfigurationINTEL: PFN_vkQueueSetPerformanceConfigurationINTEL,
                pub vkReleasePerformanceConfigurationINTEL: PFN_vkReleasePerformanceConfigurationINTEL,
                pub vkUninitializePerformanceApiINTEL: PFN_vkUninitializePerformanceApiINTEL,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkAcquirePerformanceConfigurationINTEL: get(c!("vkAcquirePerformanceConfigurationINTEL")).map(|a| a.cast()),
                        vkCmdSetPerformanceMarkerINTEL: get(c!("vkCmdSetPerformanceMarkerINTEL")).map(|a| a.cast()),
                        vkCmdSetPerformanceOverrideINTEL: get(c!("vkCmdSetPerformanceOverrideINTEL")).map(|a| a.cast()),
                        vkCmdSetPerformanceStreamMarkerINTEL: get(c!("vkCmdSetPerformanceStreamMarkerINTEL")).map(|a| a.cast()),
                        vkGetPerformanceParameterINTEL: get(c!("vkGetPerformanceParameterINTEL")).map(|a| a.cast()),
                        vkInitializePerformanceApiINTEL: get(c!("vkInitializePerformanceApiINTEL")).map(|a| a.cast()),
                        vkQueueSetPerformanceConfigurationINTEL: get(c!("vkQueueSetPerformanceConfigurationINTEL")).map(|a| a.cast()),
                        vkReleasePerformanceConfigurationINTEL: get(c!("vkReleasePerformanceConfigurationINTEL")).map(|a| a.cast()),
                        vkUninitializePerformanceApiINTEL: get(c!("vkUninitializePerformanceApiINTEL")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkAcquirePerformanceConfigurationINTEL`
                pub unsafe fn AcquirePerformanceConfigurationINTEL(&self, device: VkDevice, pAcquireInfo: *const VkPerformanceConfigurationAcquireInfoINTEL, pConfiguration: *mut VkPerformanceConfigurationINTEL) -> VkResult {
                    unsafe { (self.vkAcquirePerformanceConfigurationINTEL.expect("Unable to load vkAcquirePerformanceConfigurationINTEL"))(device, pAcquireInfo, pConfiguration) }
                }
                /// `vkCmdSetPerformanceMarkerINTEL`
                pub unsafe fn CmdSetPerformanceMarkerINTEL(&self, commandBuffer: VkCommandBuffer, pMarkerInfo: *const VkPerformanceMarkerInfoINTEL) -> VkResult {
                    unsafe { (self.vkCmdSetPerformanceMarkerINTEL.expect("Unable to load vkCmdSetPerformanceMarkerINTEL"))(commandBuffer, pMarkerInfo) }
                }
                /// `vkCmdSetPerformanceOverrideINTEL`
                pub unsafe fn CmdSetPerformanceOverrideINTEL(&self, commandBuffer: VkCommandBuffer, pOverrideInfo: *const VkPerformanceOverrideInfoINTEL) -> VkResult {
                    unsafe { (self.vkCmdSetPerformanceOverrideINTEL.expect("Unable to load vkCmdSetPerformanceOverrideINTEL"))(commandBuffer, pOverrideInfo) }
                }
                /// `vkCmdSetPerformanceStreamMarkerINTEL`
                pub unsafe fn CmdSetPerformanceStreamMarkerINTEL(&self, commandBuffer: VkCommandBuffer, pMarkerInfo: *const VkPerformanceStreamMarkerInfoINTEL) -> VkResult {
                    unsafe { (self.vkCmdSetPerformanceStreamMarkerINTEL.expect("Unable to load vkCmdSetPerformanceStreamMarkerINTEL"))(commandBuffer, pMarkerInfo) }
                }
                /// `vkGetPerformanceParameterINTEL`
                pub unsafe fn GetPerformanceParameterINTEL(&self, device: VkDevice, parameter: VkPerformanceParameterTypeINTEL, pValue: *mut VkPerformanceValueINTEL) -> VkResult {
                    unsafe { (self.vkGetPerformanceParameterINTEL.expect("Unable to load vkGetPerformanceParameterINTEL"))(device, parameter, pValue) }
                }
                /// `vkInitializePerformanceApiINTEL`
                pub unsafe fn InitializePerformanceApiINTEL(&self, device: VkDevice, pInitializeInfo: *const VkInitializePerformanceApiInfoINTEL) -> VkResult {
                    unsafe { (self.vkInitializePerformanceApiINTEL.expect("Unable to load vkInitializePerformanceApiINTEL"))(device, pInitializeInfo) }
                }
                /// `vkQueueSetPerformanceConfigurationINTEL`
                pub unsafe fn QueueSetPerformanceConfigurationINTEL(&self, queue: VkQueue, configuration: VkPerformanceConfigurationINTEL) -> VkResult {
                    unsafe { (self.vkQueueSetPerformanceConfigurationINTEL.expect("Unable to load vkQueueSetPerformanceConfigurationINTEL"))(queue, configuration) }
                }
                /// `vkReleasePerformanceConfigurationINTEL`
                pub unsafe fn ReleasePerformanceConfigurationINTEL(&self, device: VkDevice, configuration: VkPerformanceConfigurationINTEL) -> VkResult {
                    unsafe { (self.vkReleasePerformanceConfigurationINTEL.expect("Unable to load vkReleasePerformanceConfigurationINTEL"))(device, configuration) }
                }
                /// `vkUninitializePerformanceApiINTEL`
                pub unsafe fn UninitializePerformanceApiINTEL(&self, device: VkDevice) -> () {
                    unsafe { (self.vkUninitializePerformanceApiINTEL.expect("Unable to load vkUninitializePerformanceApiINTEL"))(device) }
                }
            }
        }
    }
    /// `KHR` prefix extensions
    pub mod khr {
        use core::ffi::CStr;
        use crate::loader::*;
        use crate::ffi::*;
        use crate::*;

        /// `VK_KHR_surface`
        pub mod surface {
            use super::*;

            /// `VK_KHR_surface`
            pub const NAME: &'static CStr = c!("VK_KHR_surface");

            /// InstanceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct InstanceCommands {
                pub vkDestroySurfaceKHR: PFN_vkDestroySurfaceKHR,
                pub vkGetPhysicalDeviceSurfaceCapabilitiesKHR: PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR,
                pub vkGetPhysicalDeviceSurfaceFormatsKHR: PFN_vkGetPhysicalDeviceSurfaceFormatsKHR,
                pub vkGetPhysicalDeviceSurfacePresentModesKHR: PFN_vkGetPhysicalDeviceSurfacePresentModesKHR,
                pub vkGetPhysicalDeviceSurfaceSupportKHR: PFN_vkGetPhysicalDeviceSurfaceSupportKHR,
            }

            impl InstanceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkDestroySurfaceKHR: get(c!("vkDestroySurfaceKHR")).map(|a| a.cast()),
                        vkGetPhysicalDeviceSurfaceCapabilitiesKHR: get(c!("vkGetPhysicalDeviceSurfaceCapabilitiesKHR")).map(|a| a.cast()),
                        vkGetPhysicalDeviceSurfaceFormatsKHR: get(c!("vkGetPhysicalDeviceSurfaceFormatsKHR")).map(|a| a.cast()),
                        vkGetPhysicalDeviceSurfacePresentModesKHR: get(c!("vkGetPhysicalDeviceSurfacePresentModesKHR")).map(|a| a.cast()),
                        vkGetPhysicalDeviceSurfaceSupportKHR: get(c!("vkGetPhysicalDeviceSurfaceSupportKHR")).map(|a| a.cast()),
                    } }
                }
            }

            impl InstanceCommands {
                /// `vkDestroySurfaceKHR`
                pub unsafe fn DestroySurfaceKHR(&self, instance: VkInstance, surface: VkSurfaceKHR, pAllocator: *const VkAllocationCallbacks) -> () {
                    unsafe { (self.vkDestroySurfaceKHR.expect("Unable to load vkDestroySurfaceKHR"))(instance, surface, pAllocator) }
                }
                /// `vkGetPhysicalDeviceSurfaceCapabilitiesKHR`
                pub unsafe fn GetPhysicalDeviceSurfaceCapabilitiesKHR(&self, physicalDevice: VkPhysicalDevice, surface: VkSurfaceKHR, pSurfaceCapabilities: *mut VkSurfaceCapabilitiesKHR) -> VkResult {
                    unsafe { (self.vkGetPhysicalDeviceSurfaceCapabilitiesKHR.expect("Unable to load vkGetPhysicalDeviceSurfaceCapabilitiesKHR"))(physicalDevice, surface, pSurfaceCapabilities) }
                }
                /// `vkGetPhysicalDeviceSurfaceFormatsKHR`
                pub unsafe fn GetPhysicalDeviceSurfaceFormatsKHR(&self, physicalDevice: VkPhysicalDevice, surface: VkSurfaceKHR, pSurfaceFormatCount: *mut uint32_t, pSurfaceFormats: *mut VkSurfaceFormatKHR) -> VkResult {
                    unsafe { (self.vkGetPhysicalDeviceSurfaceFormatsKHR.expect("Unable to load vkGetPhysicalDeviceSurfaceFormatsKHR"))(physicalDevice, surface, pSurfaceFormatCount, pSurfaceFormats) }
                }
                /// `vkGetPhysicalDeviceSurfacePresentModesKHR`
                pub unsafe fn GetPhysicalDeviceSurfacePresentModesKHR(&self, physicalDevice: VkPhysicalDevice, surface: VkSurfaceKHR, pPresentModeCount: *mut uint32_t, pPresentModes: *mut VkPresentModeKHR) -> VkResult {
                    unsafe { (self.vkGetPhysicalDeviceSurfacePresentModesKHR.expect("Unable to load vkGetPhysicalDeviceSurfacePresentModesKHR"))(physicalDevice, surface, pPresentModeCount, pPresentModes) }
                }
                /// `vkGetPhysicalDeviceSurfaceSupportKHR`
                pub unsafe fn GetPhysicalDeviceSurfaceSupportKHR(&self, physicalDevice: VkPhysicalDevice, queueFamilyIndex: uint32_t, surface: VkSurfaceKHR, pSupported: *mut VkBool32) -> VkResult {
                    unsafe { (self.vkGetPhysicalDeviceSurfaceSupportKHR.expect("Unable to load vkGetPhysicalDeviceSurfaceSupportKHR"))(physicalDevice, queueFamilyIndex, surface, pSupported) }
                }
            }
        }

        /// `VK_KHR_swapchain`
        pub mod swapchain {
            use super::*;

            /// `VK_KHR_swapchain`
            pub const NAME: &'static CStr = c!("VK_KHR_swapchain");

            /// InstanceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct InstanceCommands {
                pub vkGetPhysicalDevicePresentRectanglesKHR: PFN_vkGetPhysicalDevicePresentRectanglesKHR,
            }

            impl InstanceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkGetPhysicalDevicePresentRectanglesKHR: get(c!("vkGetPhysicalDevicePresentRectanglesKHR")).map(|a| a.cast()),
                    } }
                }
            }

            impl InstanceCommands {
                /// `vkGetPhysicalDevicePresentRectanglesKHR`
                pub unsafe fn GetPhysicalDevicePresentRectanglesKHR(&self, physicalDevice: VkPhysicalDevice, surface: VkSurfaceKHR, pRectCount: *mut uint32_t, pRects: *mut VkRect2D) -> VkResult {
                    unsafe { (self.vkGetPhysicalDevicePresentRectanglesKHR.expect("Unable to load vkGetPhysicalDevicePresentRectanglesKHR"))(physicalDevice, surface, pRectCount, pRects) }
                }
            }

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkAcquireNextImage2KHR: PFN_vkAcquireNextImage2KHR,
                pub vkAcquireNextImageKHR: PFN_vkAcquireNextImageKHR,
                pub vkCreateSwapchainKHR: PFN_vkCreateSwapchainKHR,
                pub vkDestroySwapchainKHR: PFN_vkDestroySwapchainKHR,
                pub vkGetDeviceGroupPresentCapabilitiesKHR: PFN_vkGetDeviceGroupPresentCapabilitiesKHR,
                pub vkGetDeviceGroupSurfacePresentModesKHR: PFN_vkGetDeviceGroupSurfacePresentModesKHR,
                pub vkGetSwapchainImagesKHR: PFN_vkGetSwapchainImagesKHR,
                pub vkQueuePresentKHR: PFN_vkQueuePresentKHR,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkAcquireNextImage2KHR: get(c!("vkAcquireNextImage2KHR")).map(|a| a.cast()),
                        vkAcquireNextImageKHR: get(c!("vkAcquireNextImageKHR")).map(|a| a.cast()),
                        vkCreateSwapchainKHR: get(c!("vkCreateSwapchainKHR")).map(|a| a.cast()),
                        vkDestroySwapchainKHR: get(c!("vkDestroySwapchainKHR")).map(|a| a.cast()),
                        vkGetDeviceGroupPresentCapabilitiesKHR: get(c!("vkGetDeviceGroupPresentCapabilitiesKHR")).map(|a| a.cast()),
                        vkGetDeviceGroupSurfacePresentModesKHR: get(c!("vkGetDeviceGroupSurfacePresentModesKHR")).map(|a| a.cast()),
                        vkGetSwapchainImagesKHR: get(c!("vkGetSwapchainImagesKHR")).map(|a| a.cast()),
                        vkQueuePresentKHR: get(c!("vkQueuePresentKHR")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkAcquireNextImage2KHR`
                pub unsafe fn AcquireNextImage2KHR(&self, device: VkDevice, pAcquireInfo: *const VkAcquireNextImageInfoKHR, pImageIndex: *mut uint32_t) -> VkResult {
                    unsafe { (self.vkAcquireNextImage2KHR.expect("Unable to load vkAcquireNextImage2KHR"))(device, pAcquireInfo, pImageIndex) }
                }
                /// `vkAcquireNextImageKHR`
                pub unsafe fn AcquireNextImageKHR(&self, device: VkDevice, swapchain: VkSwapchainKHR, timeout: uint64_t, semaphore: VkSemaphore, fence: VkFence, pImageIndex: *mut uint32_t) -> VkResult {
                    unsafe { (self.vkAcquireNextImageKHR.expect("Unable to load vkAcquireNextImageKHR"))(device, swapchain, timeout, semaphore, fence, pImageIndex) }
                }
                /// `vkCreateSwapchainKHR`
                pub unsafe fn CreateSwapchainKHR(&self, device: VkDevice, pCreateInfo: *const VkSwapchainCreateInfoKHR, pAllocator: *const VkAllocationCallbacks, pSwapchain: *mut VkSwapchainKHR) -> VkResult {
                    unsafe { (self.vkCreateSwapchainKHR.expect("Unable to load vkCreateSwapchainKHR"))(device, pCreateInfo, pAllocator, pSwapchain) }
                }
                /// `vkDestroySwapchainKHR`
                pub unsafe fn DestroySwapchainKHR(&self, device: VkDevice, swapchain: VkSwapchainKHR, pAllocator: *const VkAllocationCallbacks) -> () {
                    unsafe { (self.vkDestroySwapchainKHR.expect("Unable to load vkDestroySwapchainKHR"))(device, swapchain, pAllocator) }
                }
                /// `vkGetDeviceGroupPresentCapabilitiesKHR`
                pub unsafe fn GetDeviceGroupPresentCapabilitiesKHR(&self, device: VkDevice, pDeviceGroupPresentCapabilities: *mut VkDeviceGroupPresentCapabilitiesKHR) -> VkResult {
                    unsafe { (self.vkGetDeviceGroupPresentCapabilitiesKHR.expect("Unable to load vkGetDeviceGroupPresentCapabilitiesKHR"))(device, pDeviceGroupPresentCapabilities) }
                }
                /// `vkGetDeviceGroupSurfacePresentModesKHR`
                pub unsafe fn GetDeviceGroupSurfacePresentModesKHR(&self, device: VkDevice, surface: VkSurfaceKHR, pModes: *mut VkDeviceGroupPresentModeFlagsKHR) -> VkResult {
                    unsafe { (self.vkGetDeviceGroupSurfacePresentModesKHR.expect("Unable to load vkGetDeviceGroupSurfacePresentModesKHR"))(device, surface, pModes) }
                }
                /// `vkGetSwapchainImagesKHR`
                pub unsafe fn GetSwapchainImagesKHR(&self, device: VkDevice, swapchain: VkSwapchainKHR, pSwapchainImageCount: *mut uint32_t, pSwapchainImages: *mut VkImage) -> VkResult {
                    unsafe { (self.vkGetSwapchainImagesKHR.expect("Unable to load vkGetSwapchainImagesKHR"))(device, swapchain, pSwapchainImageCount, pSwapchainImages) }
                }
                /// `vkQueuePresentKHR`
                pub unsafe fn QueuePresentKHR(&self, queue: VkQueue, pPresentInfo: *const VkPresentInfoKHR) -> VkResult {
                    unsafe { (self.vkQueuePresentKHR.expect("Unable to load vkQueuePresentKHR"))(queue, pPresentInfo) }
                }
            }
        }

        /// `VK_KHR_display`
        pub mod display {
            use super::*;

            /// `VK_KHR_display`
            pub const NAME: &'static CStr = c!("VK_KHR_display");

            /// InstanceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct InstanceCommands {
                pub vkCreateDisplayModeKHR: PFN_vkCreateDisplayModeKHR,
                pub vkCreateDisplayPlaneSurfaceKHR: PFN_vkCreateDisplayPlaneSurfaceKHR,
                pub vkGetDisplayModePropertiesKHR: PFN_vkGetDisplayModePropertiesKHR,
                pub vkGetDisplayPlaneCapabilitiesKHR: PFN_vkGetDisplayPlaneCapabilitiesKHR,
                pub vkGetDisplayPlaneSupportedDisplaysKHR: PFN_vkGetDisplayPlaneSupportedDisplaysKHR,
                pub vkGetPhysicalDeviceDisplayPlanePropertiesKHR: PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR,
                pub vkGetPhysicalDeviceDisplayPropertiesKHR: PFN_vkGetPhysicalDeviceDisplayPropertiesKHR,
            }

            impl InstanceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkCreateDisplayModeKHR: get(c!("vkCreateDisplayModeKHR")).map(|a| a.cast()),
                        vkCreateDisplayPlaneSurfaceKHR: get(c!("vkCreateDisplayPlaneSurfaceKHR")).map(|a| a.cast()),
                        vkGetDisplayModePropertiesKHR: get(c!("vkGetDisplayModePropertiesKHR")).map(|a| a.cast()),
                        vkGetDisplayPlaneCapabilitiesKHR: get(c!("vkGetDisplayPlaneCapabilitiesKHR")).map(|a| a.cast()),
                        vkGetDisplayPlaneSupportedDisplaysKHR: get(c!("vkGetDisplayPlaneSupportedDisplaysKHR")).map(|a| a.cast()),
                        vkGetPhysicalDeviceDisplayPlanePropertiesKHR: get(c!("vkGetPhysicalDeviceDisplayPlanePropertiesKHR")).map(|a| a.cast()),
                        vkGetPhysicalDeviceDisplayPropertiesKHR: get(c!("vkGetPhysicalDeviceDisplayPropertiesKHR")).map(|a| a.cast()),
                    } }
                }
            }

            impl InstanceCommands {
                /// `vkCreateDisplayModeKHR`
                pub unsafe fn CreateDisplayModeKHR(&self, physicalDevice: VkPhysicalDevice, display: VkDisplayKHR, pCreateInfo: *const VkDisplayModeCreateInfoKHR, pAllocator: *const VkAllocationCallbacks, pMode: *mut VkDisplayModeKHR) -> VkResult {
                    unsafe { (self.vkCreateDisplayModeKHR.expect("Unable to load vkCreateDisplayModeKHR"))(physicalDevice, display, pCreateInfo, pAllocator, pMode) }
                }
                /// `vkCreateDisplayPlaneSurfaceKHR`
                pub unsafe fn CreateDisplayPlaneSurfaceKHR(&self, instance: VkInstance, pCreateInfo: *const VkDisplaySurfaceCreateInfoKHR, pAllocator: *const VkAllocationCallbacks, pSurface: *mut VkSurfaceKHR) -> VkResult {
                    unsafe { (self.vkCreateDisplayPlaneSurfaceKHR.expect("Unable to load vkCreateDisplayPlaneSurfaceKHR"))(instance, pCreateInfo, pAllocator, pSurface) }
                }
                /// `vkGetDisplayModePropertiesKHR`
                pub unsafe fn GetDisplayModePropertiesKHR(&self, physicalDevice: VkPhysicalDevice, display: VkDisplayKHR, pPropertyCount: *mut uint32_t, pProperties: *mut VkDisplayModePropertiesKHR) -> VkResult {
                    unsafe { (self.vkGetDisplayModePropertiesKHR.expect("Unable to load vkGetDisplayModePropertiesKHR"))(physicalDevice, display, pPropertyCount, pProperties) }
                }
                /// `vkGetDisplayPlaneCapabilitiesKHR`
                pub unsafe fn GetDisplayPlaneCapabilitiesKHR(&self, physicalDevice: VkPhysicalDevice, mode: VkDisplayModeKHR, planeIndex: uint32_t, pCapabilities: *mut VkDisplayPlaneCapabilitiesKHR) -> VkResult {
                    unsafe { (self.vkGetDisplayPlaneCapabilitiesKHR.expect("Unable to load vkGetDisplayPlaneCapabilitiesKHR"))(physicalDevice, mode, planeIndex, pCapabilities) }
                }
                /// `vkGetDisplayPlaneSupportedDisplaysKHR`
                pub unsafe fn GetDisplayPlaneSupportedDisplaysKHR(&self, physicalDevice: VkPhysicalDevice, planeIndex: uint32_t, pDisplayCount: *mut uint32_t, pDisplays: *mut VkDisplayKHR) -> VkResult {
                    unsafe { (self.vkGetDisplayPlaneSupportedDisplaysKHR.expect("Unable to load vkGetDisplayPlaneSupportedDisplaysKHR"))(physicalDevice, planeIndex, pDisplayCount, pDisplays) }
                }
                /// `vkGetPhysicalDeviceDisplayPlanePropertiesKHR`
                pub unsafe fn GetPhysicalDeviceDisplayPlanePropertiesKHR(&self, physicalDevice: VkPhysicalDevice, pPropertyCount: *mut uint32_t, pProperties: *mut VkDisplayPlanePropertiesKHR) -> VkResult {
                    unsafe { (self.vkGetPhysicalDeviceDisplayPlanePropertiesKHR.expect("Unable to load vkGetPhysicalDeviceDisplayPlanePropertiesKHR"))(physicalDevice, pPropertyCount, pProperties) }
                }
                /// `vkGetPhysicalDeviceDisplayPropertiesKHR`
                pub unsafe fn GetPhysicalDeviceDisplayPropertiesKHR(&self, physicalDevice: VkPhysicalDevice, pPropertyCount: *mut uint32_t, pProperties: *mut VkDisplayPropertiesKHR) -> VkResult {
                    unsafe { (self.vkGetPhysicalDeviceDisplayPropertiesKHR.expect("Unable to load vkGetPhysicalDeviceDisplayPropertiesKHR"))(physicalDevice, pPropertyCount, pProperties) }
                }
            }
        }

        /// `VK_KHR_display_swapchain`
        pub mod display_swapchain {
            use super::*;

            /// `VK_KHR_display_swapchain`
            pub const NAME: &'static CStr = c!("VK_KHR_display_swapchain");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkCreateSharedSwapchainsKHR: PFN_vkCreateSharedSwapchainsKHR,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkCreateSharedSwapchainsKHR: get(c!("vkCreateSharedSwapchainsKHR")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkCreateSharedSwapchainsKHR`
                pub unsafe fn CreateSharedSwapchainsKHR(&self, device: VkDevice, swapchainCount: uint32_t, pCreateInfos: *const VkSwapchainCreateInfoKHR, pAllocator: *const VkAllocationCallbacks, pSwapchains: *mut VkSwapchainKHR) -> VkResult {
                    unsafe { (self.vkCreateSharedSwapchainsKHR.expect("Unable to load vkCreateSharedSwapchainsKHR"))(device, swapchainCount, pCreateInfos, pAllocator, pSwapchains) }
                }
            }
        }

        /// `VK_KHR_xlib_surface`
        pub mod xlib_surface {
            use super::*;

            /// `VK_KHR_xlib_surface`
            pub const NAME: &'static CStr = c!("VK_KHR_xlib_surface");

            /// InstanceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct InstanceCommands {
                pub vkCreateXlibSurfaceKHR: PFN_vkCreateXlibSurfaceKHR,
                pub vkGetPhysicalDeviceXlibPresentationSupportKHR: PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR,
            }

            impl InstanceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkCreateXlibSurfaceKHR: get(c!("vkCreateXlibSurfaceKHR")).map(|a| a.cast()),
                        vkGetPhysicalDeviceXlibPresentationSupportKHR: get(c!("vkGetPhysicalDeviceXlibPresentationSupportKHR")).map(|a| a.cast()),
                    } }
                }
            }

            impl InstanceCommands {
                /// `vkCreateXlibSurfaceKHR`
                pub unsafe fn CreateXlibSurfaceKHR(&self, instance: VkInstance, pCreateInfo: *const VkXlibSurfaceCreateInfoKHR, pAllocator: *const VkAllocationCallbacks, pSurface: *mut VkSurfaceKHR) -> VkResult {
                    unsafe { (self.vkCreateXlibSurfaceKHR.expect("Unable to load vkCreateXlibSurfaceKHR"))(instance, pCreateInfo, pAllocator, pSurface) }
                }
                /// `vkGetPhysicalDeviceXlibPresentationSupportKHR`
                pub unsafe fn GetPhysicalDeviceXlibPresentationSupportKHR(&self, physicalDevice: VkPhysicalDevice, queueFamilyIndex: uint32_t, dpy: *mut Display, visualID: VisualID) -> VkBool32 {
                    unsafe { (self.vkGetPhysicalDeviceXlibPresentationSupportKHR.expect("Unable to load vkGetPhysicalDeviceXlibPresentationSupportKHR"))(physicalDevice, queueFamilyIndex, dpy, visualID) }
                }
            }
        }

        /// `VK_KHR_xcb_surface`
        pub mod xcb_surface {
            use super::*;

            /// `VK_KHR_xcb_surface`
            pub const NAME: &'static CStr = c!("VK_KHR_xcb_surface");

            /// InstanceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct InstanceCommands {
                pub vkCreateXcbSurfaceKHR: PFN_vkCreateXcbSurfaceKHR,
                pub vkGetPhysicalDeviceXcbPresentationSupportKHR: PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR,
            }

            impl InstanceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkCreateXcbSurfaceKHR: get(c!("vkCreateXcbSurfaceKHR")).map(|a| a.cast()),
                        vkGetPhysicalDeviceXcbPresentationSupportKHR: get(c!("vkGetPhysicalDeviceXcbPresentationSupportKHR")).map(|a| a.cast()),
                    } }
                }
            }

            impl InstanceCommands {
                /// `vkCreateXcbSurfaceKHR`
                pub unsafe fn CreateXcbSurfaceKHR(&self, instance: VkInstance, pCreateInfo: *const VkXcbSurfaceCreateInfoKHR, pAllocator: *const VkAllocationCallbacks, pSurface: *mut VkSurfaceKHR) -> VkResult {
                    unsafe { (self.vkCreateXcbSurfaceKHR.expect("Unable to load vkCreateXcbSurfaceKHR"))(instance, pCreateInfo, pAllocator, pSurface) }
                }
                /// `vkGetPhysicalDeviceXcbPresentationSupportKHR`
                pub unsafe fn GetPhysicalDeviceXcbPresentationSupportKHR(&self, physicalDevice: VkPhysicalDevice, queueFamilyIndex: uint32_t, connection: *mut xcb_connection_t, visual_id: xcb_visualid_t) -> VkBool32 {
                    unsafe { (self.vkGetPhysicalDeviceXcbPresentationSupportKHR.expect("Unable to load vkGetPhysicalDeviceXcbPresentationSupportKHR"))(physicalDevice, queueFamilyIndex, connection, visual_id) }
                }
            }
        }

        /// `VK_KHR_wayland_surface`
        pub mod wayland_surface {
            use super::*;

            /// `VK_KHR_wayland_surface`
            pub const NAME: &'static CStr = c!("VK_KHR_wayland_surface");

            /// InstanceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct InstanceCommands {
                pub vkCreateWaylandSurfaceKHR: PFN_vkCreateWaylandSurfaceKHR,
                pub vkGetPhysicalDeviceWaylandPresentationSupportKHR: PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR,
            }

            impl InstanceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkCreateWaylandSurfaceKHR: get(c!("vkCreateWaylandSurfaceKHR")).map(|a| a.cast()),
                        vkGetPhysicalDeviceWaylandPresentationSupportKHR: get(c!("vkGetPhysicalDeviceWaylandPresentationSupportKHR")).map(|a| a.cast()),
                    } }
                }
            }

            impl InstanceCommands {
                /// `vkCreateWaylandSurfaceKHR`
                pub unsafe fn CreateWaylandSurfaceKHR(&self, instance: VkInstance, pCreateInfo: *const VkWaylandSurfaceCreateInfoKHR, pAllocator: *const VkAllocationCallbacks, pSurface: *mut VkSurfaceKHR) -> VkResult {
                    unsafe { (self.vkCreateWaylandSurfaceKHR.expect("Unable to load vkCreateWaylandSurfaceKHR"))(instance, pCreateInfo, pAllocator, pSurface) }
                }
                /// `vkGetPhysicalDeviceWaylandPresentationSupportKHR`
                pub unsafe fn GetPhysicalDeviceWaylandPresentationSupportKHR(&self, physicalDevice: VkPhysicalDevice, queueFamilyIndex: uint32_t, display: *mut wl_display) -> VkBool32 {
                    unsafe { (self.vkGetPhysicalDeviceWaylandPresentationSupportKHR.expect("Unable to load vkGetPhysicalDeviceWaylandPresentationSupportKHR"))(physicalDevice, queueFamilyIndex, display) }
                }
            }
        }

        /// `VK_KHR_android_surface`
        pub mod android_surface {
            use super::*;

            /// `VK_KHR_android_surface`
            pub const NAME: &'static CStr = c!("VK_KHR_android_surface");

            /// InstanceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct InstanceCommands {
                pub vkCreateAndroidSurfaceKHR: PFN_vkCreateAndroidSurfaceKHR,
            }

            impl InstanceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkCreateAndroidSurfaceKHR: get(c!("vkCreateAndroidSurfaceKHR")).map(|a| a.cast()),
                    } }
                }
            }

            impl InstanceCommands {
                /// `vkCreateAndroidSurfaceKHR`
                pub unsafe fn CreateAndroidSurfaceKHR(&self, instance: VkInstance, pCreateInfo: *const VkAndroidSurfaceCreateInfoKHR, pAllocator: *const VkAllocationCallbacks, pSurface: *mut VkSurfaceKHR) -> VkResult {
                    unsafe { (self.vkCreateAndroidSurfaceKHR.expect("Unable to load vkCreateAndroidSurfaceKHR"))(instance, pCreateInfo, pAllocator, pSurface) }
                }
            }
        }

        /// `VK_KHR_win32_surface`
        pub mod win32_surface {
            use super::*;

            /// `VK_KHR_win32_surface`
            pub const NAME: &'static CStr = c!("VK_KHR_win32_surface");

            /// InstanceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct InstanceCommands {
                pub vkCreateWin32SurfaceKHR: PFN_vkCreateWin32SurfaceKHR,
                pub vkGetPhysicalDeviceWin32PresentationSupportKHR: PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR,
            }

            impl InstanceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkCreateWin32SurfaceKHR: get(c!("vkCreateWin32SurfaceKHR")).map(|a| a.cast()),
                        vkGetPhysicalDeviceWin32PresentationSupportKHR: get(c!("vkGetPhysicalDeviceWin32PresentationSupportKHR")).map(|a| a.cast()),
                    } }
                }
            }

            impl InstanceCommands {
                /// `vkCreateWin32SurfaceKHR`
                pub unsafe fn CreateWin32SurfaceKHR(&self, instance: VkInstance, pCreateInfo: *const VkWin32SurfaceCreateInfoKHR, pAllocator: *const VkAllocationCallbacks, pSurface: *mut VkSurfaceKHR) -> VkResult {
                    unsafe { (self.vkCreateWin32SurfaceKHR.expect("Unable to load vkCreateWin32SurfaceKHR"))(instance, pCreateInfo, pAllocator, pSurface) }
                }
                /// `vkGetPhysicalDeviceWin32PresentationSupportKHR`
                pub unsafe fn GetPhysicalDeviceWin32PresentationSupportKHR(&self, physicalDevice: VkPhysicalDevice, queueFamilyIndex: uint32_t) -> VkBool32 {
                    unsafe { (self.vkGetPhysicalDeviceWin32PresentationSupportKHR.expect("Unable to load vkGetPhysicalDeviceWin32PresentationSupportKHR"))(physicalDevice, queueFamilyIndex) }
                }
            }
        }

        /// `VK_KHR_sampler_mirror_clamp_to_edge`
        pub mod sampler_mirror_clamp_to_edge {
            use super::*;

            /// `VK_KHR_sampler_mirror_clamp_to_edge`
            pub const NAME: &'static CStr = c!("VK_KHR_sampler_mirror_clamp_to_edge");
        }

        /// `VK_KHR_video_queue`
        pub mod video_queue {
            use super::*;

            /// `VK_KHR_video_queue`
            pub const NAME: &'static CStr = c!("VK_KHR_video_queue");

            /// InstanceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct InstanceCommands {
                pub vkGetPhysicalDeviceVideoCapabilitiesKHR: PFN_vkGetPhysicalDeviceVideoCapabilitiesKHR,
                pub vkGetPhysicalDeviceVideoFormatPropertiesKHR: PFN_vkGetPhysicalDeviceVideoFormatPropertiesKHR,
            }

            impl InstanceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkGetPhysicalDeviceVideoCapabilitiesKHR: get(c!("vkGetPhysicalDeviceVideoCapabilitiesKHR")).map(|a| a.cast()),
                        vkGetPhysicalDeviceVideoFormatPropertiesKHR: get(c!("vkGetPhysicalDeviceVideoFormatPropertiesKHR")).map(|a| a.cast()),
                    } }
                }
            }

            impl InstanceCommands {
                /// `vkGetPhysicalDeviceVideoCapabilitiesKHR`
                pub unsafe fn GetPhysicalDeviceVideoCapabilitiesKHR(&self, physicalDevice: VkPhysicalDevice, pVideoProfile: *const VkVideoProfileInfoKHR, pCapabilities: *mut VkVideoCapabilitiesKHR) -> VkResult {
                    unsafe { (self.vkGetPhysicalDeviceVideoCapabilitiesKHR.expect("Unable to load vkGetPhysicalDeviceVideoCapabilitiesKHR"))(physicalDevice, pVideoProfile, pCapabilities) }
                }
                /// `vkGetPhysicalDeviceVideoFormatPropertiesKHR`
                pub unsafe fn GetPhysicalDeviceVideoFormatPropertiesKHR(&self, physicalDevice: VkPhysicalDevice, pVideoFormatInfo: *const VkPhysicalDeviceVideoFormatInfoKHR, pVideoFormatPropertyCount: *mut uint32_t, pVideoFormatProperties: *mut VkVideoFormatPropertiesKHR) -> VkResult {
                    unsafe { (self.vkGetPhysicalDeviceVideoFormatPropertiesKHR.expect("Unable to load vkGetPhysicalDeviceVideoFormatPropertiesKHR"))(physicalDevice, pVideoFormatInfo, pVideoFormatPropertyCount, pVideoFormatProperties) }
                }
            }

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkBindVideoSessionMemoryKHR: PFN_vkBindVideoSessionMemoryKHR,
                pub vkCmdBeginVideoCodingKHR: PFN_vkCmdBeginVideoCodingKHR,
                pub vkCmdControlVideoCodingKHR: PFN_vkCmdControlVideoCodingKHR,
                pub vkCmdEndVideoCodingKHR: PFN_vkCmdEndVideoCodingKHR,
                pub vkCreateVideoSessionKHR: PFN_vkCreateVideoSessionKHR,
                pub vkCreateVideoSessionParametersKHR: PFN_vkCreateVideoSessionParametersKHR,
                pub vkDestroyVideoSessionKHR: PFN_vkDestroyVideoSessionKHR,
                pub vkDestroyVideoSessionParametersKHR: PFN_vkDestroyVideoSessionParametersKHR,
                pub vkGetVideoSessionMemoryRequirementsKHR: PFN_vkGetVideoSessionMemoryRequirementsKHR,
                pub vkUpdateVideoSessionParametersKHR: PFN_vkUpdateVideoSessionParametersKHR,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkBindVideoSessionMemoryKHR: get(c!("vkBindVideoSessionMemoryKHR")).map(|a| a.cast()),
                        vkCmdBeginVideoCodingKHR: get(c!("vkCmdBeginVideoCodingKHR")).map(|a| a.cast()),
                        vkCmdControlVideoCodingKHR: get(c!("vkCmdControlVideoCodingKHR")).map(|a| a.cast()),
                        vkCmdEndVideoCodingKHR: get(c!("vkCmdEndVideoCodingKHR")).map(|a| a.cast()),
                        vkCreateVideoSessionKHR: get(c!("vkCreateVideoSessionKHR")).map(|a| a.cast()),
                        vkCreateVideoSessionParametersKHR: get(c!("vkCreateVideoSessionParametersKHR")).map(|a| a.cast()),
                        vkDestroyVideoSessionKHR: get(c!("vkDestroyVideoSessionKHR")).map(|a| a.cast()),
                        vkDestroyVideoSessionParametersKHR: get(c!("vkDestroyVideoSessionParametersKHR")).map(|a| a.cast()),
                        vkGetVideoSessionMemoryRequirementsKHR: get(c!("vkGetVideoSessionMemoryRequirementsKHR")).map(|a| a.cast()),
                        vkUpdateVideoSessionParametersKHR: get(c!("vkUpdateVideoSessionParametersKHR")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkBindVideoSessionMemoryKHR`
                pub unsafe fn BindVideoSessionMemoryKHR(&self, device: VkDevice, videoSession: VkVideoSessionKHR, bindSessionMemoryInfoCount: uint32_t, pBindSessionMemoryInfos: *const VkBindVideoSessionMemoryInfoKHR) -> VkResult {
                    unsafe { (self.vkBindVideoSessionMemoryKHR.expect("Unable to load vkBindVideoSessionMemoryKHR"))(device, videoSession, bindSessionMemoryInfoCount, pBindSessionMemoryInfos) }
                }
                /// `vkCmdBeginVideoCodingKHR`
                pub unsafe fn CmdBeginVideoCodingKHR(&self, commandBuffer: VkCommandBuffer, pBeginInfo: *const VkVideoBeginCodingInfoKHR) -> () {
                    unsafe { (self.vkCmdBeginVideoCodingKHR.expect("Unable to load vkCmdBeginVideoCodingKHR"))(commandBuffer, pBeginInfo) }
                }
                /// `vkCmdControlVideoCodingKHR`
                pub unsafe fn CmdControlVideoCodingKHR(&self, commandBuffer: VkCommandBuffer, pCodingControlInfo: *const VkVideoCodingControlInfoKHR) -> () {
                    unsafe { (self.vkCmdControlVideoCodingKHR.expect("Unable to load vkCmdControlVideoCodingKHR"))(commandBuffer, pCodingControlInfo) }
                }
                /// `vkCmdEndVideoCodingKHR`
                pub unsafe fn CmdEndVideoCodingKHR(&self, commandBuffer: VkCommandBuffer, pEndCodingInfo: *const VkVideoEndCodingInfoKHR) -> () {
                    unsafe { (self.vkCmdEndVideoCodingKHR.expect("Unable to load vkCmdEndVideoCodingKHR"))(commandBuffer, pEndCodingInfo) }
                }
                /// `vkCreateVideoSessionKHR`
                pub unsafe fn CreateVideoSessionKHR(&self, device: VkDevice, pCreateInfo: *const VkVideoSessionCreateInfoKHR, pAllocator: *const VkAllocationCallbacks, pVideoSession: *mut VkVideoSessionKHR) -> VkResult {
                    unsafe { (self.vkCreateVideoSessionKHR.expect("Unable to load vkCreateVideoSessionKHR"))(device, pCreateInfo, pAllocator, pVideoSession) }
                }
                /// `vkCreateVideoSessionParametersKHR`
                pub unsafe fn CreateVideoSessionParametersKHR(&self, device: VkDevice, pCreateInfo: *const VkVideoSessionParametersCreateInfoKHR, pAllocator: *const VkAllocationCallbacks, pVideoSessionParameters: *mut VkVideoSessionParametersKHR) -> VkResult {
                    unsafe { (self.vkCreateVideoSessionParametersKHR.expect("Unable to load vkCreateVideoSessionParametersKHR"))(device, pCreateInfo, pAllocator, pVideoSessionParameters) }
                }
                /// `vkDestroyVideoSessionKHR`
                pub unsafe fn DestroyVideoSessionKHR(&self, device: VkDevice, videoSession: VkVideoSessionKHR, pAllocator: *const VkAllocationCallbacks) -> () {
                    unsafe { (self.vkDestroyVideoSessionKHR.expect("Unable to load vkDestroyVideoSessionKHR"))(device, videoSession, pAllocator) }
                }
                /// `vkDestroyVideoSessionParametersKHR`
                pub unsafe fn DestroyVideoSessionParametersKHR(&self, device: VkDevice, videoSessionParameters: VkVideoSessionParametersKHR, pAllocator: *const VkAllocationCallbacks) -> () {
                    unsafe { (self.vkDestroyVideoSessionParametersKHR.expect("Unable to load vkDestroyVideoSessionParametersKHR"))(device, videoSessionParameters, pAllocator) }
                }
                /// `vkGetVideoSessionMemoryRequirementsKHR`
                pub unsafe fn GetVideoSessionMemoryRequirementsKHR(&self, device: VkDevice, videoSession: VkVideoSessionKHR, pMemoryRequirementsCount: *mut uint32_t, pMemoryRequirements: *mut VkVideoSessionMemoryRequirementsKHR) -> VkResult {
                    unsafe { (self.vkGetVideoSessionMemoryRequirementsKHR.expect("Unable to load vkGetVideoSessionMemoryRequirementsKHR"))(device, videoSession, pMemoryRequirementsCount, pMemoryRequirements) }
                }
                /// `vkUpdateVideoSessionParametersKHR`
                pub unsafe fn UpdateVideoSessionParametersKHR(&self, device: VkDevice, videoSessionParameters: VkVideoSessionParametersKHR, pUpdateInfo: *const VkVideoSessionParametersUpdateInfoKHR) -> VkResult {
                    unsafe { (self.vkUpdateVideoSessionParametersKHR.expect("Unable to load vkUpdateVideoSessionParametersKHR"))(device, videoSessionParameters, pUpdateInfo) }
                }
            }
        }

        /// `VK_KHR_video_decode_queue`
        pub mod video_decode_queue {
            use super::*;

            /// `VK_KHR_video_decode_queue`
            pub const NAME: &'static CStr = c!("VK_KHR_video_decode_queue");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkCmdDecodeVideoKHR: PFN_vkCmdDecodeVideoKHR,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkCmdDecodeVideoKHR: get(c!("vkCmdDecodeVideoKHR")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkCmdDecodeVideoKHR`
                pub unsafe fn CmdDecodeVideoKHR(&self, commandBuffer: VkCommandBuffer, pDecodeInfo: *const VkVideoDecodeInfoKHR) -> () {
                    unsafe { (self.vkCmdDecodeVideoKHR.expect("Unable to load vkCmdDecodeVideoKHR"))(commandBuffer, pDecodeInfo) }
                }
            }
        }

        /// `VK_KHR_video_encode_h264`
        pub mod video_encode_h264 {
            use super::*;

            /// `VK_KHR_video_encode_h264`
            pub const NAME: &'static CStr = c!("VK_KHR_video_encode_h264");
        }

        /// `VK_KHR_video_encode_h265`
        pub mod video_encode_h265 {
            use super::*;

            /// `VK_KHR_video_encode_h265`
            pub const NAME: &'static CStr = c!("VK_KHR_video_encode_h265");
        }

        /// `VK_KHR_video_decode_h264`
        pub mod video_decode_h264 {
            use super::*;

            /// `VK_KHR_video_decode_h264`
            pub const NAME: &'static CStr = c!("VK_KHR_video_decode_h264");
        }

        /// `VK_KHR_dynamic_rendering`
        pub mod dynamic_rendering {
            use super::*;

            /// `VK_KHR_dynamic_rendering`
            pub const NAME: &'static CStr = c!("VK_KHR_dynamic_rendering");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkCmdBeginRenderingKHR: PFN_vkCmdBeginRenderingKHR,
                pub vkCmdEndRenderingKHR: PFN_vkCmdEndRenderingKHR,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkCmdBeginRenderingKHR: get(c!("vkCmdBeginRenderingKHR")).map(|a| a.cast()),
                        vkCmdEndRenderingKHR: get(c!("vkCmdEndRenderingKHR")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkCmdBeginRenderingKHR`
                pub unsafe fn CmdBeginRenderingKHR(&self, commandBuffer: VkCommandBuffer, pRenderingInfo: *const VkRenderingInfo) -> () {
                    unsafe { (self.vkCmdBeginRenderingKHR.expect("Unable to load vkCmdBeginRenderingKHR"))(commandBuffer, pRenderingInfo) }
                }
                /// `vkCmdEndRenderingKHR`
                pub unsafe fn CmdEndRenderingKHR(&self, commandBuffer: VkCommandBuffer) -> () {
                    unsafe { (self.vkCmdEndRenderingKHR.expect("Unable to load vkCmdEndRenderingKHR"))(commandBuffer) }
                }
            }
        }

        /// `VK_KHR_multiview`
        pub mod multiview {
            use super::*;

            /// `VK_KHR_multiview`
            pub const NAME: &'static CStr = c!("VK_KHR_multiview");
        }

        /// `VK_KHR_get_physical_device_properties2`
        pub mod get_physical_device_properties2 {
            use super::*;

            /// `VK_KHR_get_physical_device_properties2`
            pub const NAME: &'static CStr = c!("VK_KHR_get_physical_device_properties2");

            /// InstanceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct InstanceCommands {
                pub vkGetPhysicalDeviceFeatures2KHR: PFN_vkGetPhysicalDeviceFeatures2KHR,
                pub vkGetPhysicalDeviceFormatProperties2KHR: PFN_vkGetPhysicalDeviceFormatProperties2KHR,
                pub vkGetPhysicalDeviceImageFormatProperties2KHR: PFN_vkGetPhysicalDeviceImageFormatProperties2KHR,
                pub vkGetPhysicalDeviceMemoryProperties2KHR: PFN_vkGetPhysicalDeviceMemoryProperties2KHR,
                pub vkGetPhysicalDeviceProperties2KHR: PFN_vkGetPhysicalDeviceProperties2KHR,
                pub vkGetPhysicalDeviceQueueFamilyProperties2KHR: PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR,
                pub vkGetPhysicalDeviceSparseImageFormatProperties2KHR: PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR,
            }

            impl InstanceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkGetPhysicalDeviceFeatures2KHR: get(c!("vkGetPhysicalDeviceFeatures2KHR")).map(|a| a.cast()),
                        vkGetPhysicalDeviceFormatProperties2KHR: get(c!("vkGetPhysicalDeviceFormatProperties2KHR")).map(|a| a.cast()),
                        vkGetPhysicalDeviceImageFormatProperties2KHR: get(c!("vkGetPhysicalDeviceImageFormatProperties2KHR")).map(|a| a.cast()),
                        vkGetPhysicalDeviceMemoryProperties2KHR: get(c!("vkGetPhysicalDeviceMemoryProperties2KHR")).map(|a| a.cast()),
                        vkGetPhysicalDeviceProperties2KHR: get(c!("vkGetPhysicalDeviceProperties2KHR")).map(|a| a.cast()),
                        vkGetPhysicalDeviceQueueFamilyProperties2KHR: get(c!("vkGetPhysicalDeviceQueueFamilyProperties2KHR")).map(|a| a.cast()),
                        vkGetPhysicalDeviceSparseImageFormatProperties2KHR: get(c!("vkGetPhysicalDeviceSparseImageFormatProperties2KHR")).map(|a| a.cast()),
                    } }
                }
            }

            impl InstanceCommands {
                /// `vkGetPhysicalDeviceFeatures2KHR`
                pub unsafe fn GetPhysicalDeviceFeatures2KHR(&self, physicalDevice: VkPhysicalDevice, pFeatures: *mut VkPhysicalDeviceFeatures2) -> () {
                    unsafe { (self.vkGetPhysicalDeviceFeatures2KHR.expect("Unable to load vkGetPhysicalDeviceFeatures2KHR"))(physicalDevice, pFeatures) }
                }
                /// `vkGetPhysicalDeviceFormatProperties2KHR`
                pub unsafe fn GetPhysicalDeviceFormatProperties2KHR(&self, physicalDevice: VkPhysicalDevice, format: VkFormat, pFormatProperties: *mut VkFormatProperties2) -> () {
                    unsafe { (self.vkGetPhysicalDeviceFormatProperties2KHR.expect("Unable to load vkGetPhysicalDeviceFormatProperties2KHR"))(physicalDevice, format, pFormatProperties) }
                }
                /// `vkGetPhysicalDeviceImageFormatProperties2KHR`
                pub unsafe fn GetPhysicalDeviceImageFormatProperties2KHR(&self, physicalDevice: VkPhysicalDevice, pImageFormatInfo: *const VkPhysicalDeviceImageFormatInfo2, pImageFormatProperties: *mut VkImageFormatProperties2) -> VkResult {
                    unsafe { (self.vkGetPhysicalDeviceImageFormatProperties2KHR.expect("Unable to load vkGetPhysicalDeviceImageFormatProperties2KHR"))(physicalDevice, pImageFormatInfo, pImageFormatProperties) }
                }
                /// `vkGetPhysicalDeviceMemoryProperties2KHR`
                pub unsafe fn GetPhysicalDeviceMemoryProperties2KHR(&self, physicalDevice: VkPhysicalDevice, pMemoryProperties: *mut VkPhysicalDeviceMemoryProperties2) -> () {
                    unsafe { (self.vkGetPhysicalDeviceMemoryProperties2KHR.expect("Unable to load vkGetPhysicalDeviceMemoryProperties2KHR"))(physicalDevice, pMemoryProperties) }
                }
                /// `vkGetPhysicalDeviceProperties2KHR`
                pub unsafe fn GetPhysicalDeviceProperties2KHR(&self, physicalDevice: VkPhysicalDevice, pProperties: *mut VkPhysicalDeviceProperties2) -> () {
                    unsafe { (self.vkGetPhysicalDeviceProperties2KHR.expect("Unable to load vkGetPhysicalDeviceProperties2KHR"))(physicalDevice, pProperties) }
                }
                /// `vkGetPhysicalDeviceQueueFamilyProperties2KHR`
                pub unsafe fn GetPhysicalDeviceQueueFamilyProperties2KHR(&self, physicalDevice: VkPhysicalDevice, pQueueFamilyPropertyCount: *mut uint32_t, pQueueFamilyProperties: *mut VkQueueFamilyProperties2) -> () {
                    unsafe { (self.vkGetPhysicalDeviceQueueFamilyProperties2KHR.expect("Unable to load vkGetPhysicalDeviceQueueFamilyProperties2KHR"))(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties) }
                }
                /// `vkGetPhysicalDeviceSparseImageFormatProperties2KHR`
                pub unsafe fn GetPhysicalDeviceSparseImageFormatProperties2KHR(&self, physicalDevice: VkPhysicalDevice, pFormatInfo: *const VkPhysicalDeviceSparseImageFormatInfo2, pPropertyCount: *mut uint32_t, pProperties: *mut VkSparseImageFormatProperties2) -> () {
                    unsafe { (self.vkGetPhysicalDeviceSparseImageFormatProperties2KHR.expect("Unable to load vkGetPhysicalDeviceSparseImageFormatProperties2KHR"))(physicalDevice, pFormatInfo, pPropertyCount, pProperties) }
                }
            }
        }

        /// `VK_KHR_device_group`
        pub mod device_group {
            use super::*;

            /// `VK_KHR_device_group`
            pub const NAME: &'static CStr = c!("VK_KHR_device_group");

            /// InstanceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct InstanceCommands {
                pub vkGetPhysicalDevicePresentRectanglesKHR: PFN_vkGetPhysicalDevicePresentRectanglesKHR,
            }

            impl InstanceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkGetPhysicalDevicePresentRectanglesKHR: get(c!("vkGetPhysicalDevicePresentRectanglesKHR")).map(|a| a.cast()),
                    } }
                }
            }

            impl InstanceCommands {
                /// `vkGetPhysicalDevicePresentRectanglesKHR`
                pub unsafe fn GetPhysicalDevicePresentRectanglesKHR(&self, physicalDevice: VkPhysicalDevice, surface: VkSurfaceKHR, pRectCount: *mut uint32_t, pRects: *mut VkRect2D) -> VkResult {
                    unsafe { (self.vkGetPhysicalDevicePresentRectanglesKHR.expect("Unable to load vkGetPhysicalDevicePresentRectanglesKHR"))(physicalDevice, surface, pRectCount, pRects) }
                }
            }

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkAcquireNextImage2KHR: PFN_vkAcquireNextImage2KHR,
                pub vkCmdDispatchBaseKHR: PFN_vkCmdDispatchBaseKHR,
                pub vkCmdSetDeviceMaskKHR: PFN_vkCmdSetDeviceMaskKHR,
                pub vkGetDeviceGroupPeerMemoryFeaturesKHR: PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR,
                pub vkGetDeviceGroupPresentCapabilitiesKHR: PFN_vkGetDeviceGroupPresentCapabilitiesKHR,
                pub vkGetDeviceGroupSurfacePresentModesKHR: PFN_vkGetDeviceGroupSurfacePresentModesKHR,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkAcquireNextImage2KHR: get(c!("vkAcquireNextImage2KHR")).map(|a| a.cast()),
                        vkCmdDispatchBaseKHR: get(c!("vkCmdDispatchBaseKHR")).map(|a| a.cast()),
                        vkCmdSetDeviceMaskKHR: get(c!("vkCmdSetDeviceMaskKHR")).map(|a| a.cast()),
                        vkGetDeviceGroupPeerMemoryFeaturesKHR: get(c!("vkGetDeviceGroupPeerMemoryFeaturesKHR")).map(|a| a.cast()),
                        vkGetDeviceGroupPresentCapabilitiesKHR: get(c!("vkGetDeviceGroupPresentCapabilitiesKHR")).map(|a| a.cast()),
                        vkGetDeviceGroupSurfacePresentModesKHR: get(c!("vkGetDeviceGroupSurfacePresentModesKHR")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkAcquireNextImage2KHR`
                pub unsafe fn AcquireNextImage2KHR(&self, device: VkDevice, pAcquireInfo: *const VkAcquireNextImageInfoKHR, pImageIndex: *mut uint32_t) -> VkResult {
                    unsafe { (self.vkAcquireNextImage2KHR.expect("Unable to load vkAcquireNextImage2KHR"))(device, pAcquireInfo, pImageIndex) }
                }
                /// `vkCmdDispatchBaseKHR`
                pub unsafe fn CmdDispatchBaseKHR(&self, commandBuffer: VkCommandBuffer, baseGroupX: uint32_t, baseGroupY: uint32_t, baseGroupZ: uint32_t, groupCountX: uint32_t, groupCountY: uint32_t, groupCountZ: uint32_t) -> () {
                    unsafe { (self.vkCmdDispatchBaseKHR.expect("Unable to load vkCmdDispatchBaseKHR"))(commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ) }
                }
                /// `vkCmdSetDeviceMaskKHR`
                pub unsafe fn CmdSetDeviceMaskKHR(&self, commandBuffer: VkCommandBuffer, deviceMask: uint32_t) -> () {
                    unsafe { (self.vkCmdSetDeviceMaskKHR.expect("Unable to load vkCmdSetDeviceMaskKHR"))(commandBuffer, deviceMask) }
                }
                /// `vkGetDeviceGroupPeerMemoryFeaturesKHR`
                pub unsafe fn GetDeviceGroupPeerMemoryFeaturesKHR(&self, device: VkDevice, heapIndex: uint32_t, localDeviceIndex: uint32_t, remoteDeviceIndex: uint32_t, pPeerMemoryFeatures: *mut VkPeerMemoryFeatureFlags) -> () {
                    unsafe { (self.vkGetDeviceGroupPeerMemoryFeaturesKHR.expect("Unable to load vkGetDeviceGroupPeerMemoryFeaturesKHR"))(device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures) }
                }
                /// `vkGetDeviceGroupPresentCapabilitiesKHR`
                pub unsafe fn GetDeviceGroupPresentCapabilitiesKHR(&self, device: VkDevice, pDeviceGroupPresentCapabilities: *mut VkDeviceGroupPresentCapabilitiesKHR) -> VkResult {
                    unsafe { (self.vkGetDeviceGroupPresentCapabilitiesKHR.expect("Unable to load vkGetDeviceGroupPresentCapabilitiesKHR"))(device, pDeviceGroupPresentCapabilities) }
                }
                /// `vkGetDeviceGroupSurfacePresentModesKHR`
                pub unsafe fn GetDeviceGroupSurfacePresentModesKHR(&self, device: VkDevice, surface: VkSurfaceKHR, pModes: *mut VkDeviceGroupPresentModeFlagsKHR) -> VkResult {
                    unsafe { (self.vkGetDeviceGroupSurfacePresentModesKHR.expect("Unable to load vkGetDeviceGroupSurfacePresentModesKHR"))(device, surface, pModes) }
                }
            }
        }

        /// `VK_KHR_shader_draw_parameters`
        pub mod shader_draw_parameters {
            use super::*;

            /// `VK_KHR_shader_draw_parameters`
            pub const NAME: &'static CStr = c!("VK_KHR_shader_draw_parameters");
        }

        /// `VK_KHR_maintenance1`
        pub mod maintenance1 {
            use super::*;

            /// `VK_KHR_maintenance1`
            pub const NAME: &'static CStr = c!("VK_KHR_maintenance1");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkTrimCommandPoolKHR: PFN_vkTrimCommandPoolKHR,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkTrimCommandPoolKHR: get(c!("vkTrimCommandPoolKHR")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkTrimCommandPoolKHR`
                pub unsafe fn TrimCommandPoolKHR(&self, device: VkDevice, commandPool: VkCommandPool, flags: VkCommandPoolTrimFlags) -> () {
                    unsafe { (self.vkTrimCommandPoolKHR.expect("Unable to load vkTrimCommandPoolKHR"))(device, commandPool, flags) }
                }
            }
        }

        /// `VK_KHR_device_group_creation`
        pub mod device_group_creation {
            use super::*;

            /// `VK_KHR_device_group_creation`
            pub const NAME: &'static CStr = c!("VK_KHR_device_group_creation");

            /// InstanceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct InstanceCommands {
                pub vkEnumeratePhysicalDeviceGroupsKHR: PFN_vkEnumeratePhysicalDeviceGroupsKHR,
            }

            impl InstanceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkEnumeratePhysicalDeviceGroupsKHR: get(c!("vkEnumeratePhysicalDeviceGroupsKHR")).map(|a| a.cast()),
                    } }
                }
            }

            impl InstanceCommands {
                /// `vkEnumeratePhysicalDeviceGroupsKHR`
                pub unsafe fn EnumeratePhysicalDeviceGroupsKHR(&self, instance: VkInstance, pPhysicalDeviceGroupCount: *mut uint32_t, pPhysicalDeviceGroupProperties: *mut VkPhysicalDeviceGroupProperties) -> VkResult {
                    unsafe { (self.vkEnumeratePhysicalDeviceGroupsKHR.expect("Unable to load vkEnumeratePhysicalDeviceGroupsKHR"))(instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties) }
                }
            }
        }

        /// `VK_KHR_external_memory_capabilities`
        pub mod external_memory_capabilities {
            use super::*;

            /// `VK_KHR_external_memory_capabilities`
            pub const NAME: &'static CStr = c!("VK_KHR_external_memory_capabilities");

            /// InstanceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct InstanceCommands {
                pub vkGetPhysicalDeviceExternalBufferPropertiesKHR: PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR,
            }

            impl InstanceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkGetPhysicalDeviceExternalBufferPropertiesKHR: get(c!("vkGetPhysicalDeviceExternalBufferPropertiesKHR")).map(|a| a.cast()),
                    } }
                }
            }

            impl InstanceCommands {
                /// `vkGetPhysicalDeviceExternalBufferPropertiesKHR`
                pub unsafe fn GetPhysicalDeviceExternalBufferPropertiesKHR(&self, physicalDevice: VkPhysicalDevice, pExternalBufferInfo: *const VkPhysicalDeviceExternalBufferInfo, pExternalBufferProperties: *mut VkExternalBufferProperties) -> () {
                    unsafe { (self.vkGetPhysicalDeviceExternalBufferPropertiesKHR.expect("Unable to load vkGetPhysicalDeviceExternalBufferPropertiesKHR"))(physicalDevice, pExternalBufferInfo, pExternalBufferProperties) }
                }
            }
        }

        /// `VK_KHR_external_memory`
        pub mod external_memory {
            use super::*;

            /// `VK_KHR_external_memory`
            pub const NAME: &'static CStr = c!("VK_KHR_external_memory");
        }

        /// `VK_KHR_external_memory_win32`
        pub mod external_memory_win32 {
            use super::*;

            /// `VK_KHR_external_memory_win32`
            pub const NAME: &'static CStr = c!("VK_KHR_external_memory_win32");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkGetMemoryWin32HandleKHR: PFN_vkGetMemoryWin32HandleKHR,
                pub vkGetMemoryWin32HandlePropertiesKHR: PFN_vkGetMemoryWin32HandlePropertiesKHR,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkGetMemoryWin32HandleKHR: get(c!("vkGetMemoryWin32HandleKHR")).map(|a| a.cast()),
                        vkGetMemoryWin32HandlePropertiesKHR: get(c!("vkGetMemoryWin32HandlePropertiesKHR")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkGetMemoryWin32HandleKHR`
                pub unsafe fn GetMemoryWin32HandleKHR(&self, device: VkDevice, pGetWin32HandleInfo: *const VkMemoryGetWin32HandleInfoKHR, pHandle: *mut HANDLE) -> VkResult {
                    unsafe { (self.vkGetMemoryWin32HandleKHR.expect("Unable to load vkGetMemoryWin32HandleKHR"))(device, pGetWin32HandleInfo, pHandle) }
                }
                /// `vkGetMemoryWin32HandlePropertiesKHR`
                pub unsafe fn GetMemoryWin32HandlePropertiesKHR(&self, device: VkDevice, handleType: VkExternalMemoryHandleTypeFlags, handle: HANDLE, pMemoryWin32HandleProperties: *mut VkMemoryWin32HandlePropertiesKHR) -> VkResult {
                    unsafe { (self.vkGetMemoryWin32HandlePropertiesKHR.expect("Unable to load vkGetMemoryWin32HandlePropertiesKHR"))(device, handleType, handle, pMemoryWin32HandleProperties) }
                }
            }
        }

        /// `VK_KHR_external_memory_fd`
        pub mod external_memory_fd {
            use super::*;

            /// `VK_KHR_external_memory_fd`
            pub const NAME: &'static CStr = c!("VK_KHR_external_memory_fd");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkGetMemoryFdKHR: PFN_vkGetMemoryFdKHR,
                pub vkGetMemoryFdPropertiesKHR: PFN_vkGetMemoryFdPropertiesKHR,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkGetMemoryFdKHR: get(c!("vkGetMemoryFdKHR")).map(|a| a.cast()),
                        vkGetMemoryFdPropertiesKHR: get(c!("vkGetMemoryFdPropertiesKHR")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkGetMemoryFdKHR`
                pub unsafe fn GetMemoryFdKHR(&self, device: VkDevice, pGetFdInfo: *const VkMemoryGetFdInfoKHR, pFd: *mut int) -> VkResult {
                    unsafe { (self.vkGetMemoryFdKHR.expect("Unable to load vkGetMemoryFdKHR"))(device, pGetFdInfo, pFd) }
                }
                /// `vkGetMemoryFdPropertiesKHR`
                pub unsafe fn GetMemoryFdPropertiesKHR(&self, device: VkDevice, handleType: VkExternalMemoryHandleTypeFlags, fd: int, pMemoryFdProperties: *mut VkMemoryFdPropertiesKHR) -> VkResult {
                    unsafe { (self.vkGetMemoryFdPropertiesKHR.expect("Unable to load vkGetMemoryFdPropertiesKHR"))(device, handleType, fd, pMemoryFdProperties) }
                }
            }
        }

        /// `VK_KHR_win32_keyed_mutex`
        pub mod win32_keyed_mutex {
            use super::*;

            /// `VK_KHR_win32_keyed_mutex`
            pub const NAME: &'static CStr = c!("VK_KHR_win32_keyed_mutex");
        }

        /// `VK_KHR_external_semaphore_capabilities`
        pub mod external_semaphore_capabilities {
            use super::*;

            /// `VK_KHR_external_semaphore_capabilities`
            pub const NAME: &'static CStr = c!("VK_KHR_external_semaphore_capabilities");

            /// InstanceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct InstanceCommands {
                pub vkGetPhysicalDeviceExternalSemaphorePropertiesKHR: PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR,
            }

            impl InstanceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkGetPhysicalDeviceExternalSemaphorePropertiesKHR: get(c!("vkGetPhysicalDeviceExternalSemaphorePropertiesKHR")).map(|a| a.cast()),
                    } }
                }
            }

            impl InstanceCommands {
                /// `vkGetPhysicalDeviceExternalSemaphorePropertiesKHR`
                pub unsafe fn GetPhysicalDeviceExternalSemaphorePropertiesKHR(&self, physicalDevice: VkPhysicalDevice, pExternalSemaphoreInfo: *const VkPhysicalDeviceExternalSemaphoreInfo, pExternalSemaphoreProperties: *mut VkExternalSemaphoreProperties) -> () {
                    unsafe { (self.vkGetPhysicalDeviceExternalSemaphorePropertiesKHR.expect("Unable to load vkGetPhysicalDeviceExternalSemaphorePropertiesKHR"))(physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties) }
                }
            }
        }

        /// `VK_KHR_external_semaphore`
        pub mod external_semaphore {
            use super::*;

            /// `VK_KHR_external_semaphore`
            pub const NAME: &'static CStr = c!("VK_KHR_external_semaphore");
        }

        /// `VK_KHR_external_semaphore_win32`
        pub mod external_semaphore_win32 {
            use super::*;

            /// `VK_KHR_external_semaphore_win32`
            pub const NAME: &'static CStr = c!("VK_KHR_external_semaphore_win32");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkGetSemaphoreWin32HandleKHR: PFN_vkGetSemaphoreWin32HandleKHR,
                pub vkImportSemaphoreWin32HandleKHR: PFN_vkImportSemaphoreWin32HandleKHR,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkGetSemaphoreWin32HandleKHR: get(c!("vkGetSemaphoreWin32HandleKHR")).map(|a| a.cast()),
                        vkImportSemaphoreWin32HandleKHR: get(c!("vkImportSemaphoreWin32HandleKHR")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkGetSemaphoreWin32HandleKHR`
                pub unsafe fn GetSemaphoreWin32HandleKHR(&self, device: VkDevice, pGetWin32HandleInfo: *const VkSemaphoreGetWin32HandleInfoKHR, pHandle: *mut HANDLE) -> VkResult {
                    unsafe { (self.vkGetSemaphoreWin32HandleKHR.expect("Unable to load vkGetSemaphoreWin32HandleKHR"))(device, pGetWin32HandleInfo, pHandle) }
                }
                /// `vkImportSemaphoreWin32HandleKHR`
                pub unsafe fn ImportSemaphoreWin32HandleKHR(&self, device: VkDevice, pImportSemaphoreWin32HandleInfo: *const VkImportSemaphoreWin32HandleInfoKHR) -> VkResult {
                    unsafe { (self.vkImportSemaphoreWin32HandleKHR.expect("Unable to load vkImportSemaphoreWin32HandleKHR"))(device, pImportSemaphoreWin32HandleInfo) }
                }
            }
        }

        /// `VK_KHR_external_semaphore_fd`
        pub mod external_semaphore_fd {
            use super::*;

            /// `VK_KHR_external_semaphore_fd`
            pub const NAME: &'static CStr = c!("VK_KHR_external_semaphore_fd");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkGetSemaphoreFdKHR: PFN_vkGetSemaphoreFdKHR,
                pub vkImportSemaphoreFdKHR: PFN_vkImportSemaphoreFdKHR,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkGetSemaphoreFdKHR: get(c!("vkGetSemaphoreFdKHR")).map(|a| a.cast()),
                        vkImportSemaphoreFdKHR: get(c!("vkImportSemaphoreFdKHR")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkGetSemaphoreFdKHR`
                pub unsafe fn GetSemaphoreFdKHR(&self, device: VkDevice, pGetFdInfo: *const VkSemaphoreGetFdInfoKHR, pFd: *mut int) -> VkResult {
                    unsafe { (self.vkGetSemaphoreFdKHR.expect("Unable to load vkGetSemaphoreFdKHR"))(device, pGetFdInfo, pFd) }
                }
                /// `vkImportSemaphoreFdKHR`
                pub unsafe fn ImportSemaphoreFdKHR(&self, device: VkDevice, pImportSemaphoreFdInfo: *const VkImportSemaphoreFdInfoKHR) -> VkResult {
                    unsafe { (self.vkImportSemaphoreFdKHR.expect("Unable to load vkImportSemaphoreFdKHR"))(device, pImportSemaphoreFdInfo) }
                }
            }
        }

        /// `VK_KHR_push_descriptor`
        pub mod push_descriptor {
            use super::*;

            /// `VK_KHR_push_descriptor`
            pub const NAME: &'static CStr = c!("VK_KHR_push_descriptor");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkCmdPushDescriptorSetKHR: PFN_vkCmdPushDescriptorSetKHR,
                pub vkCmdPushDescriptorSetWithTemplateKHR: PFN_vkCmdPushDescriptorSetWithTemplateKHR,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkCmdPushDescriptorSetKHR: get(c!("vkCmdPushDescriptorSetKHR")).map(|a| a.cast()),
                        vkCmdPushDescriptorSetWithTemplateKHR: get(c!("vkCmdPushDescriptorSetWithTemplateKHR")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkCmdPushDescriptorSetKHR`
                pub unsafe fn CmdPushDescriptorSetKHR(&self, commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, layout: VkPipelineLayout, set: uint32_t, descriptorWriteCount: uint32_t, pDescriptorWrites: *const VkWriteDescriptorSet) -> () {
                    unsafe { (self.vkCmdPushDescriptorSetKHR.expect("Unable to load vkCmdPushDescriptorSetKHR"))(commandBuffer, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites) }
                }
                /// `vkCmdPushDescriptorSetWithTemplateKHR`
                pub unsafe fn CmdPushDescriptorSetWithTemplateKHR(&self, commandBuffer: VkCommandBuffer, descriptorUpdateTemplate: VkDescriptorUpdateTemplate, layout: VkPipelineLayout, set: uint32_t, pData: *const void) -> () {
                    unsafe { (self.vkCmdPushDescriptorSetWithTemplateKHR.expect("Unable to load vkCmdPushDescriptorSetWithTemplateKHR"))(commandBuffer, descriptorUpdateTemplate, layout, set, pData) }
                }
            }
        }

        /// `VK_KHR_shader_float16_int8`
        pub mod shader_float16_int8 {
            use super::*;

            /// `VK_KHR_shader_float16_int8`
            pub const NAME: &'static CStr = c!("VK_KHR_shader_float16_int8");
        }

        /// `VK_KHR_16bit_storage`
        pub mod _16bit_storage {
            use super::*;

            /// `VK_KHR_16bit_storage`
            pub const NAME: &'static CStr = c!("VK_KHR_16bit_storage");
        }

        /// `VK_KHR_incremental_present`
        pub mod incremental_present {
            use super::*;

            /// `VK_KHR_incremental_present`
            pub const NAME: &'static CStr = c!("VK_KHR_incremental_present");
        }

        /// `VK_KHR_descriptor_update_template`
        pub mod descriptor_update_template {
            use super::*;

            /// `VK_KHR_descriptor_update_template`
            pub const NAME: &'static CStr = c!("VK_KHR_descriptor_update_template");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkCmdPushDescriptorSetWithTemplateKHR: PFN_vkCmdPushDescriptorSetWithTemplateKHR,
                pub vkCreateDescriptorUpdateTemplateKHR: PFN_vkCreateDescriptorUpdateTemplateKHR,
                pub vkDestroyDescriptorUpdateTemplateKHR: PFN_vkDestroyDescriptorUpdateTemplateKHR,
                pub vkUpdateDescriptorSetWithTemplateKHR: PFN_vkUpdateDescriptorSetWithTemplateKHR,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkCmdPushDescriptorSetWithTemplateKHR: get(c!("vkCmdPushDescriptorSetWithTemplateKHR")).map(|a| a.cast()),
                        vkCreateDescriptorUpdateTemplateKHR: get(c!("vkCreateDescriptorUpdateTemplateKHR")).map(|a| a.cast()),
                        vkDestroyDescriptorUpdateTemplateKHR: get(c!("vkDestroyDescriptorUpdateTemplateKHR")).map(|a| a.cast()),
                        vkUpdateDescriptorSetWithTemplateKHR: get(c!("vkUpdateDescriptorSetWithTemplateKHR")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkCmdPushDescriptorSetWithTemplateKHR`
                pub unsafe fn CmdPushDescriptorSetWithTemplateKHR(&self, commandBuffer: VkCommandBuffer, descriptorUpdateTemplate: VkDescriptorUpdateTemplate, layout: VkPipelineLayout, set: uint32_t, pData: *const void) -> () {
                    unsafe { (self.vkCmdPushDescriptorSetWithTemplateKHR.expect("Unable to load vkCmdPushDescriptorSetWithTemplateKHR"))(commandBuffer, descriptorUpdateTemplate, layout, set, pData) }
                }
                /// `vkCreateDescriptorUpdateTemplateKHR`
                pub unsafe fn CreateDescriptorUpdateTemplateKHR(&self, device: VkDevice, pCreateInfo: *const VkDescriptorUpdateTemplateCreateInfo, pAllocator: *const VkAllocationCallbacks, pDescriptorUpdateTemplate: *mut VkDescriptorUpdateTemplate) -> VkResult {
                    unsafe { (self.vkCreateDescriptorUpdateTemplateKHR.expect("Unable to load vkCreateDescriptorUpdateTemplateKHR"))(device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate) }
                }
                /// `vkDestroyDescriptorUpdateTemplateKHR`
                pub unsafe fn DestroyDescriptorUpdateTemplateKHR(&self, device: VkDevice, descriptorUpdateTemplate: VkDescriptorUpdateTemplate, pAllocator: *const VkAllocationCallbacks) -> () {
                    unsafe { (self.vkDestroyDescriptorUpdateTemplateKHR.expect("Unable to load vkDestroyDescriptorUpdateTemplateKHR"))(device, descriptorUpdateTemplate, pAllocator) }
                }
                /// `vkUpdateDescriptorSetWithTemplateKHR`
                pub unsafe fn UpdateDescriptorSetWithTemplateKHR(&self, device: VkDevice, descriptorSet: VkDescriptorSet, descriptorUpdateTemplate: VkDescriptorUpdateTemplate, pData: *const void) -> () {
                    unsafe { (self.vkUpdateDescriptorSetWithTemplateKHR.expect("Unable to load vkUpdateDescriptorSetWithTemplateKHR"))(device, descriptorSet, descriptorUpdateTemplate, pData) }
                }
            }
        }

        /// `VK_KHR_imageless_framebuffer`
        pub mod imageless_framebuffer {
            use super::*;

            /// `VK_KHR_imageless_framebuffer`
            pub const NAME: &'static CStr = c!("VK_KHR_imageless_framebuffer");
        }

        /// `VK_KHR_create_renderpass2`
        pub mod create_renderpass2 {
            use super::*;

            /// `VK_KHR_create_renderpass2`
            pub const NAME: &'static CStr = c!("VK_KHR_create_renderpass2");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkCmdBeginRenderPass2KHR: PFN_vkCmdBeginRenderPass2KHR,
                pub vkCmdEndRenderPass2KHR: PFN_vkCmdEndRenderPass2KHR,
                pub vkCmdNextSubpass2KHR: PFN_vkCmdNextSubpass2KHR,
                pub vkCreateRenderPass2KHR: PFN_vkCreateRenderPass2KHR,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkCmdBeginRenderPass2KHR: get(c!("vkCmdBeginRenderPass2KHR")).map(|a| a.cast()),
                        vkCmdEndRenderPass2KHR: get(c!("vkCmdEndRenderPass2KHR")).map(|a| a.cast()),
                        vkCmdNextSubpass2KHR: get(c!("vkCmdNextSubpass2KHR")).map(|a| a.cast()),
                        vkCreateRenderPass2KHR: get(c!("vkCreateRenderPass2KHR")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkCmdBeginRenderPass2KHR`
                pub unsafe fn CmdBeginRenderPass2KHR(&self, commandBuffer: VkCommandBuffer, pRenderPassBegin: *const VkRenderPassBeginInfo, pSubpassBeginInfo: *const VkSubpassBeginInfo) -> () {
                    unsafe { (self.vkCmdBeginRenderPass2KHR.expect("Unable to load vkCmdBeginRenderPass2KHR"))(commandBuffer, pRenderPassBegin, pSubpassBeginInfo) }
                }
                /// `vkCmdEndRenderPass2KHR`
                pub unsafe fn CmdEndRenderPass2KHR(&self, commandBuffer: VkCommandBuffer, pSubpassEndInfo: *const VkSubpassEndInfo) -> () {
                    unsafe { (self.vkCmdEndRenderPass2KHR.expect("Unable to load vkCmdEndRenderPass2KHR"))(commandBuffer, pSubpassEndInfo) }
                }
                /// `vkCmdNextSubpass2KHR`
                pub unsafe fn CmdNextSubpass2KHR(&self, commandBuffer: VkCommandBuffer, pSubpassBeginInfo: *const VkSubpassBeginInfo, pSubpassEndInfo: *const VkSubpassEndInfo) -> () {
                    unsafe { (self.vkCmdNextSubpass2KHR.expect("Unable to load vkCmdNextSubpass2KHR"))(commandBuffer, pSubpassBeginInfo, pSubpassEndInfo) }
                }
                /// `vkCreateRenderPass2KHR`
                pub unsafe fn CreateRenderPass2KHR(&self, device: VkDevice, pCreateInfo: *const VkRenderPassCreateInfo2, pAllocator: *const VkAllocationCallbacks, pRenderPass: *mut VkRenderPass) -> VkResult {
                    unsafe { (self.vkCreateRenderPass2KHR.expect("Unable to load vkCreateRenderPass2KHR"))(device, pCreateInfo, pAllocator, pRenderPass) }
                }
            }
        }

        /// `VK_KHR_shared_presentable_image`
        pub mod shared_presentable_image {
            use super::*;

            /// `VK_KHR_shared_presentable_image`
            pub const NAME: &'static CStr = c!("VK_KHR_shared_presentable_image");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkGetSwapchainStatusKHR: PFN_vkGetSwapchainStatusKHR,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkGetSwapchainStatusKHR: get(c!("vkGetSwapchainStatusKHR")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkGetSwapchainStatusKHR`
                pub unsafe fn GetSwapchainStatusKHR(&self, device: VkDevice, swapchain: VkSwapchainKHR) -> VkResult {
                    unsafe { (self.vkGetSwapchainStatusKHR.expect("Unable to load vkGetSwapchainStatusKHR"))(device, swapchain) }
                }
            }
        }

        /// `VK_KHR_external_fence_capabilities`
        pub mod external_fence_capabilities {
            use super::*;

            /// `VK_KHR_external_fence_capabilities`
            pub const NAME: &'static CStr = c!("VK_KHR_external_fence_capabilities");

            /// InstanceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct InstanceCommands {
                pub vkGetPhysicalDeviceExternalFencePropertiesKHR: PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR,
            }

            impl InstanceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkGetPhysicalDeviceExternalFencePropertiesKHR: get(c!("vkGetPhysicalDeviceExternalFencePropertiesKHR")).map(|a| a.cast()),
                    } }
                }
            }

            impl InstanceCommands {
                /// `vkGetPhysicalDeviceExternalFencePropertiesKHR`
                pub unsafe fn GetPhysicalDeviceExternalFencePropertiesKHR(&self, physicalDevice: VkPhysicalDevice, pExternalFenceInfo: *const VkPhysicalDeviceExternalFenceInfo, pExternalFenceProperties: *mut VkExternalFenceProperties) -> () {
                    unsafe { (self.vkGetPhysicalDeviceExternalFencePropertiesKHR.expect("Unable to load vkGetPhysicalDeviceExternalFencePropertiesKHR"))(physicalDevice, pExternalFenceInfo, pExternalFenceProperties) }
                }
            }
        }

        /// `VK_KHR_external_fence`
        pub mod external_fence {
            use super::*;

            /// `VK_KHR_external_fence`
            pub const NAME: &'static CStr = c!("VK_KHR_external_fence");
        }

        /// `VK_KHR_external_fence_win32`
        pub mod external_fence_win32 {
            use super::*;

            /// `VK_KHR_external_fence_win32`
            pub const NAME: &'static CStr = c!("VK_KHR_external_fence_win32");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkGetFenceWin32HandleKHR: PFN_vkGetFenceWin32HandleKHR,
                pub vkImportFenceWin32HandleKHR: PFN_vkImportFenceWin32HandleKHR,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkGetFenceWin32HandleKHR: get(c!("vkGetFenceWin32HandleKHR")).map(|a| a.cast()),
                        vkImportFenceWin32HandleKHR: get(c!("vkImportFenceWin32HandleKHR")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkGetFenceWin32HandleKHR`
                pub unsafe fn GetFenceWin32HandleKHR(&self, device: VkDevice, pGetWin32HandleInfo: *const VkFenceGetWin32HandleInfoKHR, pHandle: *mut HANDLE) -> VkResult {
                    unsafe { (self.vkGetFenceWin32HandleKHR.expect("Unable to load vkGetFenceWin32HandleKHR"))(device, pGetWin32HandleInfo, pHandle) }
                }
                /// `vkImportFenceWin32HandleKHR`
                pub unsafe fn ImportFenceWin32HandleKHR(&self, device: VkDevice, pImportFenceWin32HandleInfo: *const VkImportFenceWin32HandleInfoKHR) -> VkResult {
                    unsafe { (self.vkImportFenceWin32HandleKHR.expect("Unable to load vkImportFenceWin32HandleKHR"))(device, pImportFenceWin32HandleInfo) }
                }
            }
        }

        /// `VK_KHR_external_fence_fd`
        pub mod external_fence_fd {
            use super::*;

            /// `VK_KHR_external_fence_fd`
            pub const NAME: &'static CStr = c!("VK_KHR_external_fence_fd");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkGetFenceFdKHR: PFN_vkGetFenceFdKHR,
                pub vkImportFenceFdKHR: PFN_vkImportFenceFdKHR,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkGetFenceFdKHR: get(c!("vkGetFenceFdKHR")).map(|a| a.cast()),
                        vkImportFenceFdKHR: get(c!("vkImportFenceFdKHR")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkGetFenceFdKHR`
                pub unsafe fn GetFenceFdKHR(&self, device: VkDevice, pGetFdInfo: *const VkFenceGetFdInfoKHR, pFd: *mut int) -> VkResult {
                    unsafe { (self.vkGetFenceFdKHR.expect("Unable to load vkGetFenceFdKHR"))(device, pGetFdInfo, pFd) }
                }
                /// `vkImportFenceFdKHR`
                pub unsafe fn ImportFenceFdKHR(&self, device: VkDevice, pImportFenceFdInfo: *const VkImportFenceFdInfoKHR) -> VkResult {
                    unsafe { (self.vkImportFenceFdKHR.expect("Unable to load vkImportFenceFdKHR"))(device, pImportFenceFdInfo) }
                }
            }
        }

        /// `VK_KHR_performance_query`
        pub mod performance_query {
            use super::*;

            /// `VK_KHR_performance_query`
            pub const NAME: &'static CStr = c!("VK_KHR_performance_query");

            /// InstanceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct InstanceCommands {
                pub vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR: PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR,
                pub vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR: PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR,
            }

            impl InstanceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR: get(c!("vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR")).map(|a| a.cast()),
                        vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR: get(c!("vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR")).map(|a| a.cast()),
                    } }
                }
            }

            impl InstanceCommands {
                /// `vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR`
                pub unsafe fn EnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(&self, physicalDevice: VkPhysicalDevice, queueFamilyIndex: uint32_t, pCounterCount: *mut uint32_t, pCounters: *mut VkPerformanceCounterKHR, pCounterDescriptions: *mut VkPerformanceCounterDescriptionKHR) -> VkResult {
                    unsafe { (self.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR.expect("Unable to load vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR"))(physicalDevice, queueFamilyIndex, pCounterCount, pCounters, pCounterDescriptions) }
                }
                /// `vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR`
                pub unsafe fn GetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(&self, physicalDevice: VkPhysicalDevice, pPerformanceQueryCreateInfo: *const VkQueryPoolPerformanceCreateInfoKHR, pNumPasses: *mut uint32_t) -> () {
                    unsafe { (self.vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR.expect("Unable to load vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR"))(physicalDevice, pPerformanceQueryCreateInfo, pNumPasses) }
                }
            }

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkAcquireProfilingLockKHR: PFN_vkAcquireProfilingLockKHR,
                pub vkReleaseProfilingLockKHR: PFN_vkReleaseProfilingLockKHR,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkAcquireProfilingLockKHR: get(c!("vkAcquireProfilingLockKHR")).map(|a| a.cast()),
                        vkReleaseProfilingLockKHR: get(c!("vkReleaseProfilingLockKHR")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkAcquireProfilingLockKHR`
                pub unsafe fn AcquireProfilingLockKHR(&self, device: VkDevice, pInfo: *const VkAcquireProfilingLockInfoKHR) -> VkResult {
                    unsafe { (self.vkAcquireProfilingLockKHR.expect("Unable to load vkAcquireProfilingLockKHR"))(device, pInfo) }
                }
                /// `vkReleaseProfilingLockKHR`
                pub unsafe fn ReleaseProfilingLockKHR(&self, device: VkDevice) -> () {
                    unsafe { (self.vkReleaseProfilingLockKHR.expect("Unable to load vkReleaseProfilingLockKHR"))(device) }
                }
            }
        }

        /// `VK_KHR_maintenance2`
        pub mod maintenance2 {
            use super::*;

            /// `VK_KHR_maintenance2`
            pub const NAME: &'static CStr = c!("VK_KHR_maintenance2");
        }

        /// `VK_KHR_get_surface_capabilities2`
        pub mod get_surface_capabilities2 {
            use super::*;

            /// `VK_KHR_get_surface_capabilities2`
            pub const NAME: &'static CStr = c!("VK_KHR_get_surface_capabilities2");

            /// InstanceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct InstanceCommands {
                pub vkGetPhysicalDeviceSurfaceCapabilities2KHR: PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR,
                pub vkGetPhysicalDeviceSurfaceFormats2KHR: PFN_vkGetPhysicalDeviceSurfaceFormats2KHR,
            }

            impl InstanceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkGetPhysicalDeviceSurfaceCapabilities2KHR: get(c!("vkGetPhysicalDeviceSurfaceCapabilities2KHR")).map(|a| a.cast()),
                        vkGetPhysicalDeviceSurfaceFormats2KHR: get(c!("vkGetPhysicalDeviceSurfaceFormats2KHR")).map(|a| a.cast()),
                    } }
                }
            }

            impl InstanceCommands {
                /// `vkGetPhysicalDeviceSurfaceCapabilities2KHR`
                pub unsafe fn GetPhysicalDeviceSurfaceCapabilities2KHR(&self, physicalDevice: VkPhysicalDevice, pSurfaceInfo: *const VkPhysicalDeviceSurfaceInfo2KHR, pSurfaceCapabilities: *mut VkSurfaceCapabilities2KHR) -> VkResult {
                    unsafe { (self.vkGetPhysicalDeviceSurfaceCapabilities2KHR.expect("Unable to load vkGetPhysicalDeviceSurfaceCapabilities2KHR"))(physicalDevice, pSurfaceInfo, pSurfaceCapabilities) }
                }
                /// `vkGetPhysicalDeviceSurfaceFormats2KHR`
                pub unsafe fn GetPhysicalDeviceSurfaceFormats2KHR(&self, physicalDevice: VkPhysicalDevice, pSurfaceInfo: *const VkPhysicalDeviceSurfaceInfo2KHR, pSurfaceFormatCount: *mut uint32_t, pSurfaceFormats: *mut VkSurfaceFormat2KHR) -> VkResult {
                    unsafe { (self.vkGetPhysicalDeviceSurfaceFormats2KHR.expect("Unable to load vkGetPhysicalDeviceSurfaceFormats2KHR"))(physicalDevice, pSurfaceInfo, pSurfaceFormatCount, pSurfaceFormats) }
                }
            }
        }

        /// `VK_KHR_variable_pointers`
        pub mod variable_pointers {
            use super::*;

            /// `VK_KHR_variable_pointers`
            pub const NAME: &'static CStr = c!("VK_KHR_variable_pointers");
        }

        /// `VK_KHR_get_display_properties2`
        pub mod get_display_properties2 {
            use super::*;

            /// `VK_KHR_get_display_properties2`
            pub const NAME: &'static CStr = c!("VK_KHR_get_display_properties2");

            /// InstanceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct InstanceCommands {
                pub vkGetDisplayModeProperties2KHR: PFN_vkGetDisplayModeProperties2KHR,
                pub vkGetDisplayPlaneCapabilities2KHR: PFN_vkGetDisplayPlaneCapabilities2KHR,
                pub vkGetPhysicalDeviceDisplayPlaneProperties2KHR: PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR,
                pub vkGetPhysicalDeviceDisplayProperties2KHR: PFN_vkGetPhysicalDeviceDisplayProperties2KHR,
            }

            impl InstanceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkGetDisplayModeProperties2KHR: get(c!("vkGetDisplayModeProperties2KHR")).map(|a| a.cast()),
                        vkGetDisplayPlaneCapabilities2KHR: get(c!("vkGetDisplayPlaneCapabilities2KHR")).map(|a| a.cast()),
                        vkGetPhysicalDeviceDisplayPlaneProperties2KHR: get(c!("vkGetPhysicalDeviceDisplayPlaneProperties2KHR")).map(|a| a.cast()),
                        vkGetPhysicalDeviceDisplayProperties2KHR: get(c!("vkGetPhysicalDeviceDisplayProperties2KHR")).map(|a| a.cast()),
                    } }
                }
            }

            impl InstanceCommands {
                /// `vkGetDisplayModeProperties2KHR`
                pub unsafe fn GetDisplayModeProperties2KHR(&self, physicalDevice: VkPhysicalDevice, display: VkDisplayKHR, pPropertyCount: *mut uint32_t, pProperties: *mut VkDisplayModeProperties2KHR) -> VkResult {
                    unsafe { (self.vkGetDisplayModeProperties2KHR.expect("Unable to load vkGetDisplayModeProperties2KHR"))(physicalDevice, display, pPropertyCount, pProperties) }
                }
                /// `vkGetDisplayPlaneCapabilities2KHR`
                pub unsafe fn GetDisplayPlaneCapabilities2KHR(&self, physicalDevice: VkPhysicalDevice, pDisplayPlaneInfo: *const VkDisplayPlaneInfo2KHR, pCapabilities: *mut VkDisplayPlaneCapabilities2KHR) -> VkResult {
                    unsafe { (self.vkGetDisplayPlaneCapabilities2KHR.expect("Unable to load vkGetDisplayPlaneCapabilities2KHR"))(physicalDevice, pDisplayPlaneInfo, pCapabilities) }
                }
                /// `vkGetPhysicalDeviceDisplayPlaneProperties2KHR`
                pub unsafe fn GetPhysicalDeviceDisplayPlaneProperties2KHR(&self, physicalDevice: VkPhysicalDevice, pPropertyCount: *mut uint32_t, pProperties: *mut VkDisplayPlaneProperties2KHR) -> VkResult {
                    unsafe { (self.vkGetPhysicalDeviceDisplayPlaneProperties2KHR.expect("Unable to load vkGetPhysicalDeviceDisplayPlaneProperties2KHR"))(physicalDevice, pPropertyCount, pProperties) }
                }
                /// `vkGetPhysicalDeviceDisplayProperties2KHR`
                pub unsafe fn GetPhysicalDeviceDisplayProperties2KHR(&self, physicalDevice: VkPhysicalDevice, pPropertyCount: *mut uint32_t, pProperties: *mut VkDisplayProperties2KHR) -> VkResult {
                    unsafe { (self.vkGetPhysicalDeviceDisplayProperties2KHR.expect("Unable to load vkGetPhysicalDeviceDisplayProperties2KHR"))(physicalDevice, pPropertyCount, pProperties) }
                }
            }
        }

        /// `VK_KHR_dedicated_allocation`
        pub mod dedicated_allocation {
            use super::*;

            /// `VK_KHR_dedicated_allocation`
            pub const NAME: &'static CStr = c!("VK_KHR_dedicated_allocation");
        }

        /// `VK_KHR_storage_buffer_storage_class`
        pub mod storage_buffer_storage_class {
            use super::*;

            /// `VK_KHR_storage_buffer_storage_class`
            pub const NAME: &'static CStr = c!("VK_KHR_storage_buffer_storage_class");
        }

        /// `VK_KHR_shader_bfloat16`
        pub mod shader_bfloat16 {
            use super::*;

            /// `VK_KHR_shader_bfloat16`
            pub const NAME: &'static CStr = c!("VK_KHR_shader_bfloat16");
        }

        /// `VK_KHR_relaxed_block_layout`
        pub mod relaxed_block_layout {
            use super::*;

            /// `VK_KHR_relaxed_block_layout`
            pub const NAME: &'static CStr = c!("VK_KHR_relaxed_block_layout");
        }

        /// `VK_KHR_get_memory_requirements2`
        pub mod get_memory_requirements2 {
            use super::*;

            /// `VK_KHR_get_memory_requirements2`
            pub const NAME: &'static CStr = c!("VK_KHR_get_memory_requirements2");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkGetBufferMemoryRequirements2KHR: PFN_vkGetBufferMemoryRequirements2KHR,
                pub vkGetImageMemoryRequirements2KHR: PFN_vkGetImageMemoryRequirements2KHR,
                pub vkGetImageSparseMemoryRequirements2KHR: PFN_vkGetImageSparseMemoryRequirements2KHR,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkGetBufferMemoryRequirements2KHR: get(c!("vkGetBufferMemoryRequirements2KHR")).map(|a| a.cast()),
                        vkGetImageMemoryRequirements2KHR: get(c!("vkGetImageMemoryRequirements2KHR")).map(|a| a.cast()),
                        vkGetImageSparseMemoryRequirements2KHR: get(c!("vkGetImageSparseMemoryRequirements2KHR")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkGetBufferMemoryRequirements2KHR`
                pub unsafe fn GetBufferMemoryRequirements2KHR(&self, device: VkDevice, pInfo: *const VkBufferMemoryRequirementsInfo2, pMemoryRequirements: *mut VkMemoryRequirements2) -> () {
                    unsafe { (self.vkGetBufferMemoryRequirements2KHR.expect("Unable to load vkGetBufferMemoryRequirements2KHR"))(device, pInfo, pMemoryRequirements) }
                }
                /// `vkGetImageMemoryRequirements2KHR`
                pub unsafe fn GetImageMemoryRequirements2KHR(&self, device: VkDevice, pInfo: *const VkImageMemoryRequirementsInfo2, pMemoryRequirements: *mut VkMemoryRequirements2) -> () {
                    unsafe { (self.vkGetImageMemoryRequirements2KHR.expect("Unable to load vkGetImageMemoryRequirements2KHR"))(device, pInfo, pMemoryRequirements) }
                }
                /// `vkGetImageSparseMemoryRequirements2KHR`
                pub unsafe fn GetImageSparseMemoryRequirements2KHR(&self, device: VkDevice, pInfo: *const VkImageSparseMemoryRequirementsInfo2, pSparseMemoryRequirementCount: *mut uint32_t, pSparseMemoryRequirements: *mut VkSparseImageMemoryRequirements2) -> () {
                    unsafe { (self.vkGetImageSparseMemoryRequirements2KHR.expect("Unable to load vkGetImageSparseMemoryRequirements2KHR"))(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements) }
                }
            }
        }

        /// `VK_KHR_image_format_list`
        pub mod image_format_list {
            use super::*;

            /// `VK_KHR_image_format_list`
            pub const NAME: &'static CStr = c!("VK_KHR_image_format_list");
        }

        /// `VK_KHR_acceleration_structure`
        pub mod acceleration_structure {
            use super::*;

            /// `VK_KHR_acceleration_structure`
            pub const NAME: &'static CStr = c!("VK_KHR_acceleration_structure");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkBuildAccelerationStructuresKHR: PFN_vkBuildAccelerationStructuresKHR,
                pub vkCmdBuildAccelerationStructuresIndirectKHR: PFN_vkCmdBuildAccelerationStructuresIndirectKHR,
                pub vkCmdBuildAccelerationStructuresKHR: PFN_vkCmdBuildAccelerationStructuresKHR,
                pub vkCmdCopyAccelerationStructureKHR: PFN_vkCmdCopyAccelerationStructureKHR,
                pub vkCmdCopyAccelerationStructureToMemoryKHR: PFN_vkCmdCopyAccelerationStructureToMemoryKHR,
                pub vkCmdCopyMemoryToAccelerationStructureKHR: PFN_vkCmdCopyMemoryToAccelerationStructureKHR,
                pub vkCmdWriteAccelerationStructuresPropertiesKHR: PFN_vkCmdWriteAccelerationStructuresPropertiesKHR,
                pub vkCopyAccelerationStructureKHR: PFN_vkCopyAccelerationStructureKHR,
                pub vkCopyAccelerationStructureToMemoryKHR: PFN_vkCopyAccelerationStructureToMemoryKHR,
                pub vkCopyMemoryToAccelerationStructureKHR: PFN_vkCopyMemoryToAccelerationStructureKHR,
                pub vkCreateAccelerationStructureKHR: PFN_vkCreateAccelerationStructureKHR,
                pub vkDestroyAccelerationStructureKHR: PFN_vkDestroyAccelerationStructureKHR,
                pub vkGetAccelerationStructureBuildSizesKHR: PFN_vkGetAccelerationStructureBuildSizesKHR,
                pub vkGetAccelerationStructureDeviceAddressKHR: PFN_vkGetAccelerationStructureDeviceAddressKHR,
                pub vkGetDeviceAccelerationStructureCompatibilityKHR: PFN_vkGetDeviceAccelerationStructureCompatibilityKHR,
                pub vkWriteAccelerationStructuresPropertiesKHR: PFN_vkWriteAccelerationStructuresPropertiesKHR,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkBuildAccelerationStructuresKHR: get(c!("vkBuildAccelerationStructuresKHR")).map(|a| a.cast()),
                        vkCmdBuildAccelerationStructuresIndirectKHR: get(c!("vkCmdBuildAccelerationStructuresIndirectKHR")).map(|a| a.cast()),
                        vkCmdBuildAccelerationStructuresKHR: get(c!("vkCmdBuildAccelerationStructuresKHR")).map(|a| a.cast()),
                        vkCmdCopyAccelerationStructureKHR: get(c!("vkCmdCopyAccelerationStructureKHR")).map(|a| a.cast()),
                        vkCmdCopyAccelerationStructureToMemoryKHR: get(c!("vkCmdCopyAccelerationStructureToMemoryKHR")).map(|a| a.cast()),
                        vkCmdCopyMemoryToAccelerationStructureKHR: get(c!("vkCmdCopyMemoryToAccelerationStructureKHR")).map(|a| a.cast()),
                        vkCmdWriteAccelerationStructuresPropertiesKHR: get(c!("vkCmdWriteAccelerationStructuresPropertiesKHR")).map(|a| a.cast()),
                        vkCopyAccelerationStructureKHR: get(c!("vkCopyAccelerationStructureKHR")).map(|a| a.cast()),
                        vkCopyAccelerationStructureToMemoryKHR: get(c!("vkCopyAccelerationStructureToMemoryKHR")).map(|a| a.cast()),
                        vkCopyMemoryToAccelerationStructureKHR: get(c!("vkCopyMemoryToAccelerationStructureKHR")).map(|a| a.cast()),
                        vkCreateAccelerationStructureKHR: get(c!("vkCreateAccelerationStructureKHR")).map(|a| a.cast()),
                        vkDestroyAccelerationStructureKHR: get(c!("vkDestroyAccelerationStructureKHR")).map(|a| a.cast()),
                        vkGetAccelerationStructureBuildSizesKHR: get(c!("vkGetAccelerationStructureBuildSizesKHR")).map(|a| a.cast()),
                        vkGetAccelerationStructureDeviceAddressKHR: get(c!("vkGetAccelerationStructureDeviceAddressKHR")).map(|a| a.cast()),
                        vkGetDeviceAccelerationStructureCompatibilityKHR: get(c!("vkGetDeviceAccelerationStructureCompatibilityKHR")).map(|a| a.cast()),
                        vkWriteAccelerationStructuresPropertiesKHR: get(c!("vkWriteAccelerationStructuresPropertiesKHR")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkBuildAccelerationStructuresKHR`
                pub unsafe fn BuildAccelerationStructuresKHR(&self, device: VkDevice, deferredOperation: VkDeferredOperationKHR, infoCount: uint32_t, pInfos: *const VkAccelerationStructureBuildGeometryInfoKHR, ppBuildRangeInfos: *const *const VkAccelerationStructureBuildRangeInfoKHR) -> VkResult {
                    unsafe { (self.vkBuildAccelerationStructuresKHR.expect("Unable to load vkBuildAccelerationStructuresKHR"))(device, deferredOperation, infoCount, pInfos, ppBuildRangeInfos) }
                }
                /// `vkCmdBuildAccelerationStructuresIndirectKHR`
                pub unsafe fn CmdBuildAccelerationStructuresIndirectKHR(&self, commandBuffer: VkCommandBuffer, infoCount: uint32_t, pInfos: *const VkAccelerationStructureBuildGeometryInfoKHR, pIndirectDeviceAddresses: *const VkDeviceAddress, pIndirectStrides: *const uint32_t, ppMaxPrimitiveCounts: *const *const uint32_t) -> () {
                    unsafe { (self.vkCmdBuildAccelerationStructuresIndirectKHR.expect("Unable to load vkCmdBuildAccelerationStructuresIndirectKHR"))(commandBuffer, infoCount, pInfos, pIndirectDeviceAddresses, pIndirectStrides, ppMaxPrimitiveCounts) }
                }
                /// `vkCmdBuildAccelerationStructuresKHR`
                pub unsafe fn CmdBuildAccelerationStructuresKHR(&self, commandBuffer: VkCommandBuffer, infoCount: uint32_t, pInfos: *const VkAccelerationStructureBuildGeometryInfoKHR, ppBuildRangeInfos: *const *const VkAccelerationStructureBuildRangeInfoKHR) -> () {
                    unsafe { (self.vkCmdBuildAccelerationStructuresKHR.expect("Unable to load vkCmdBuildAccelerationStructuresKHR"))(commandBuffer, infoCount, pInfos, ppBuildRangeInfos) }
                }
                /// `vkCmdCopyAccelerationStructureKHR`
                pub unsafe fn CmdCopyAccelerationStructureKHR(&self, commandBuffer: VkCommandBuffer, pInfo: *const VkCopyAccelerationStructureInfoKHR) -> () {
                    unsafe { (self.vkCmdCopyAccelerationStructureKHR.expect("Unable to load vkCmdCopyAccelerationStructureKHR"))(commandBuffer, pInfo) }
                }
                /// `vkCmdCopyAccelerationStructureToMemoryKHR`
                pub unsafe fn CmdCopyAccelerationStructureToMemoryKHR(&self, commandBuffer: VkCommandBuffer, pInfo: *const VkCopyAccelerationStructureToMemoryInfoKHR) -> () {
                    unsafe { (self.vkCmdCopyAccelerationStructureToMemoryKHR.expect("Unable to load vkCmdCopyAccelerationStructureToMemoryKHR"))(commandBuffer, pInfo) }
                }
                /// `vkCmdCopyMemoryToAccelerationStructureKHR`
                pub unsafe fn CmdCopyMemoryToAccelerationStructureKHR(&self, commandBuffer: VkCommandBuffer, pInfo: *const VkCopyMemoryToAccelerationStructureInfoKHR) -> () {
                    unsafe { (self.vkCmdCopyMemoryToAccelerationStructureKHR.expect("Unable to load vkCmdCopyMemoryToAccelerationStructureKHR"))(commandBuffer, pInfo) }
                }
                /// `vkCmdWriteAccelerationStructuresPropertiesKHR`
                pub unsafe fn CmdWriteAccelerationStructuresPropertiesKHR(&self, commandBuffer: VkCommandBuffer, accelerationStructureCount: uint32_t, pAccelerationStructures: *const VkAccelerationStructureKHR, queryType: VkQueryType, queryPool: VkQueryPool, firstQuery: uint32_t) -> () {
                    unsafe { (self.vkCmdWriteAccelerationStructuresPropertiesKHR.expect("Unable to load vkCmdWriteAccelerationStructuresPropertiesKHR"))(commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery) }
                }
                /// `vkCopyAccelerationStructureKHR`
                pub unsafe fn CopyAccelerationStructureKHR(&self, device: VkDevice, deferredOperation: VkDeferredOperationKHR, pInfo: *const VkCopyAccelerationStructureInfoKHR) -> VkResult {
                    unsafe { (self.vkCopyAccelerationStructureKHR.expect("Unable to load vkCopyAccelerationStructureKHR"))(device, deferredOperation, pInfo) }
                }
                /// `vkCopyAccelerationStructureToMemoryKHR`
                pub unsafe fn CopyAccelerationStructureToMemoryKHR(&self, device: VkDevice, deferredOperation: VkDeferredOperationKHR, pInfo: *const VkCopyAccelerationStructureToMemoryInfoKHR) -> VkResult {
                    unsafe { (self.vkCopyAccelerationStructureToMemoryKHR.expect("Unable to load vkCopyAccelerationStructureToMemoryKHR"))(device, deferredOperation, pInfo) }
                }
                /// `vkCopyMemoryToAccelerationStructureKHR`
                pub unsafe fn CopyMemoryToAccelerationStructureKHR(&self, device: VkDevice, deferredOperation: VkDeferredOperationKHR, pInfo: *const VkCopyMemoryToAccelerationStructureInfoKHR) -> VkResult {
                    unsafe { (self.vkCopyMemoryToAccelerationStructureKHR.expect("Unable to load vkCopyMemoryToAccelerationStructureKHR"))(device, deferredOperation, pInfo) }
                }
                /// `vkCreateAccelerationStructureKHR`
                pub unsafe fn CreateAccelerationStructureKHR(&self, device: VkDevice, pCreateInfo: *const VkAccelerationStructureCreateInfoKHR, pAllocator: *const VkAllocationCallbacks, pAccelerationStructure: *mut VkAccelerationStructureKHR) -> VkResult {
                    unsafe { (self.vkCreateAccelerationStructureKHR.expect("Unable to load vkCreateAccelerationStructureKHR"))(device, pCreateInfo, pAllocator, pAccelerationStructure) }
                }
                /// `vkDestroyAccelerationStructureKHR`
                pub unsafe fn DestroyAccelerationStructureKHR(&self, device: VkDevice, accelerationStructure: VkAccelerationStructureKHR, pAllocator: *const VkAllocationCallbacks) -> () {
                    unsafe { (self.vkDestroyAccelerationStructureKHR.expect("Unable to load vkDestroyAccelerationStructureKHR"))(device, accelerationStructure, pAllocator) }
                }
                /// `vkGetAccelerationStructureBuildSizesKHR`
                pub unsafe fn GetAccelerationStructureBuildSizesKHR(&self, device: VkDevice, buildType: VkAccelerationStructureBuildTypeKHR, pBuildInfo: *const VkAccelerationStructureBuildGeometryInfoKHR, pMaxPrimitiveCounts: *const uint32_t, pSizeInfo: *mut VkAccelerationStructureBuildSizesInfoKHR) -> () {
                    unsafe { (self.vkGetAccelerationStructureBuildSizesKHR.expect("Unable to load vkGetAccelerationStructureBuildSizesKHR"))(device, buildType, pBuildInfo, pMaxPrimitiveCounts, pSizeInfo) }
                }
                /// `vkGetAccelerationStructureDeviceAddressKHR`
                pub unsafe fn GetAccelerationStructureDeviceAddressKHR(&self, device: VkDevice, pInfo: *const VkAccelerationStructureDeviceAddressInfoKHR) -> VkDeviceAddress {
                    unsafe { (self.vkGetAccelerationStructureDeviceAddressKHR.expect("Unable to load vkGetAccelerationStructureDeviceAddressKHR"))(device, pInfo) }
                }
                /// `vkGetDeviceAccelerationStructureCompatibilityKHR`
                pub unsafe fn GetDeviceAccelerationStructureCompatibilityKHR(&self, device: VkDevice, pVersionInfo: *const VkAccelerationStructureVersionInfoKHR, pCompatibility: *mut VkAccelerationStructureCompatibilityKHR) -> () {
                    unsafe { (self.vkGetDeviceAccelerationStructureCompatibilityKHR.expect("Unable to load vkGetDeviceAccelerationStructureCompatibilityKHR"))(device, pVersionInfo, pCompatibility) }
                }
                /// `vkWriteAccelerationStructuresPropertiesKHR`
                pub unsafe fn WriteAccelerationStructuresPropertiesKHR(&self, device: VkDevice, accelerationStructureCount: uint32_t, pAccelerationStructures: *const VkAccelerationStructureKHR, queryType: VkQueryType, dataSize: size_t, pData: *mut void, stride: size_t) -> VkResult {
                    unsafe { (self.vkWriteAccelerationStructuresPropertiesKHR.expect("Unable to load vkWriteAccelerationStructuresPropertiesKHR"))(device, accelerationStructureCount, pAccelerationStructures, queryType, dataSize, pData, stride) }
                }
            }
        }

        /// `VK_KHR_sampler_ycbcr_conversion`
        pub mod sampler_ycbcr_conversion {
            use super::*;

            /// `VK_KHR_sampler_ycbcr_conversion`
            pub const NAME: &'static CStr = c!("VK_KHR_sampler_ycbcr_conversion");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkCreateSamplerYcbcrConversionKHR: PFN_vkCreateSamplerYcbcrConversionKHR,
                pub vkDestroySamplerYcbcrConversionKHR: PFN_vkDestroySamplerYcbcrConversionKHR,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkCreateSamplerYcbcrConversionKHR: get(c!("vkCreateSamplerYcbcrConversionKHR")).map(|a| a.cast()),
                        vkDestroySamplerYcbcrConversionKHR: get(c!("vkDestroySamplerYcbcrConversionKHR")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkCreateSamplerYcbcrConversionKHR`
                pub unsafe fn CreateSamplerYcbcrConversionKHR(&self, device: VkDevice, pCreateInfo: *const VkSamplerYcbcrConversionCreateInfo, pAllocator: *const VkAllocationCallbacks, pYcbcrConversion: *mut VkSamplerYcbcrConversion) -> VkResult {
                    unsafe { (self.vkCreateSamplerYcbcrConversionKHR.expect("Unable to load vkCreateSamplerYcbcrConversionKHR"))(device, pCreateInfo, pAllocator, pYcbcrConversion) }
                }
                /// `vkDestroySamplerYcbcrConversionKHR`
                pub unsafe fn DestroySamplerYcbcrConversionKHR(&self, device: VkDevice, ycbcrConversion: VkSamplerYcbcrConversion, pAllocator: *const VkAllocationCallbacks) -> () {
                    unsafe { (self.vkDestroySamplerYcbcrConversionKHR.expect("Unable to load vkDestroySamplerYcbcrConversionKHR"))(device, ycbcrConversion, pAllocator) }
                }
            }
        }

        /// `VK_KHR_bind_memory2`
        pub mod bind_memory2 {
            use super::*;

            /// `VK_KHR_bind_memory2`
            pub const NAME: &'static CStr = c!("VK_KHR_bind_memory2");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkBindBufferMemory2KHR: PFN_vkBindBufferMemory2KHR,
                pub vkBindImageMemory2KHR: PFN_vkBindImageMemory2KHR,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkBindBufferMemory2KHR: get(c!("vkBindBufferMemory2KHR")).map(|a| a.cast()),
                        vkBindImageMemory2KHR: get(c!("vkBindImageMemory2KHR")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkBindBufferMemory2KHR`
                pub unsafe fn BindBufferMemory2KHR(&self, device: VkDevice, bindInfoCount: uint32_t, pBindInfos: *const VkBindBufferMemoryInfo) -> VkResult {
                    unsafe { (self.vkBindBufferMemory2KHR.expect("Unable to load vkBindBufferMemory2KHR"))(device, bindInfoCount, pBindInfos) }
                }
                /// `vkBindImageMemory2KHR`
                pub unsafe fn BindImageMemory2KHR(&self, device: VkDevice, bindInfoCount: uint32_t, pBindInfos: *const VkBindImageMemoryInfo) -> VkResult {
                    unsafe { (self.vkBindImageMemory2KHR.expect("Unable to load vkBindImageMemory2KHR"))(device, bindInfoCount, pBindInfos) }
                }
            }
        }

        /// `VK_KHR_portability_subset`
        pub mod portability_subset {
            use super::*;

            /// `VK_KHR_portability_subset`
            pub const NAME: &'static CStr = c!("VK_KHR_portability_subset");
        }

        /// `VK_KHR_maintenance3`
        pub mod maintenance3 {
            use super::*;

            /// `VK_KHR_maintenance3`
            pub const NAME: &'static CStr = c!("VK_KHR_maintenance3");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkGetDescriptorSetLayoutSupportKHR: PFN_vkGetDescriptorSetLayoutSupportKHR,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkGetDescriptorSetLayoutSupportKHR: get(c!("vkGetDescriptorSetLayoutSupportKHR")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkGetDescriptorSetLayoutSupportKHR`
                pub unsafe fn GetDescriptorSetLayoutSupportKHR(&self, device: VkDevice, pCreateInfo: *const VkDescriptorSetLayoutCreateInfo, pSupport: *mut VkDescriptorSetLayoutSupport) -> () {
                    unsafe { (self.vkGetDescriptorSetLayoutSupportKHR.expect("Unable to load vkGetDescriptorSetLayoutSupportKHR"))(device, pCreateInfo, pSupport) }
                }
            }
        }

        /// `VK_KHR_draw_indirect_count`
        pub mod draw_indirect_count {
            use super::*;

            /// `VK_KHR_draw_indirect_count`
            pub const NAME: &'static CStr = c!("VK_KHR_draw_indirect_count");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkCmdDrawIndexedIndirectCountKHR: PFN_vkCmdDrawIndexedIndirectCountKHR,
                pub vkCmdDrawIndirectCountKHR: PFN_vkCmdDrawIndirectCountKHR,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkCmdDrawIndexedIndirectCountKHR: get(c!("vkCmdDrawIndexedIndirectCountKHR")).map(|a| a.cast()),
                        vkCmdDrawIndirectCountKHR: get(c!("vkCmdDrawIndirectCountKHR")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkCmdDrawIndexedIndirectCountKHR`
                pub unsafe fn CmdDrawIndexedIndirectCountKHR(&self, commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, countBuffer: VkBuffer, countBufferOffset: VkDeviceSize, maxDrawCount: uint32_t, stride: uint32_t) -> () {
                    unsafe { (self.vkCmdDrawIndexedIndirectCountKHR.expect("Unable to load vkCmdDrawIndexedIndirectCountKHR"))(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride) }
                }
                /// `vkCmdDrawIndirectCountKHR`
                pub unsafe fn CmdDrawIndirectCountKHR(&self, commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, countBuffer: VkBuffer, countBufferOffset: VkDeviceSize, maxDrawCount: uint32_t, stride: uint32_t) -> () {
                    unsafe { (self.vkCmdDrawIndirectCountKHR.expect("Unable to load vkCmdDrawIndirectCountKHR"))(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride) }
                }
            }
        }

        /// `VK_KHR_shader_subgroup_extended_types`
        pub mod shader_subgroup_extended_types {
            use super::*;

            /// `VK_KHR_shader_subgroup_extended_types`
            pub const NAME: &'static CStr = c!("VK_KHR_shader_subgroup_extended_types");
        }

        /// `VK_KHR_8bit_storage`
        pub mod _8bit_storage {
            use super::*;

            /// `VK_KHR_8bit_storage`
            pub const NAME: &'static CStr = c!("VK_KHR_8bit_storage");
        }

        /// `VK_KHR_shader_atomic_int64`
        pub mod shader_atomic_int64 {
            use super::*;

            /// `VK_KHR_shader_atomic_int64`
            pub const NAME: &'static CStr = c!("VK_KHR_shader_atomic_int64");
        }

        /// `VK_KHR_shader_clock`
        pub mod shader_clock {
            use super::*;

            /// `VK_KHR_shader_clock`
            pub const NAME: &'static CStr = c!("VK_KHR_shader_clock");
        }

        /// `VK_KHR_video_decode_h265`
        pub mod video_decode_h265 {
            use super::*;

            /// `VK_KHR_video_decode_h265`
            pub const NAME: &'static CStr = c!("VK_KHR_video_decode_h265");
        }

        /// `VK_KHR_global_priority`
        pub mod global_priority {
            use super::*;

            /// `VK_KHR_global_priority`
            pub const NAME: &'static CStr = c!("VK_KHR_global_priority");
        }

        /// `VK_KHR_driver_properties`
        pub mod driver_properties {
            use super::*;

            /// `VK_KHR_driver_properties`
            pub const NAME: &'static CStr = c!("VK_KHR_driver_properties");
        }

        /// `VK_KHR_shader_float_controls`
        pub mod shader_float_controls {
            use super::*;

            /// `VK_KHR_shader_float_controls`
            pub const NAME: &'static CStr = c!("VK_KHR_shader_float_controls");
        }

        /// `VK_KHR_depth_stencil_resolve`
        pub mod depth_stencil_resolve {
            use super::*;

            /// `VK_KHR_depth_stencil_resolve`
            pub const NAME: &'static CStr = c!("VK_KHR_depth_stencil_resolve");
        }

        /// `VK_KHR_swapchain_mutable_format`
        pub mod swapchain_mutable_format {
            use super::*;

            /// `VK_KHR_swapchain_mutable_format`
            pub const NAME: &'static CStr = c!("VK_KHR_swapchain_mutable_format");
        }

        /// `VK_KHR_timeline_semaphore`
        pub mod timeline_semaphore {
            use super::*;

            /// `VK_KHR_timeline_semaphore`
            pub const NAME: &'static CStr = c!("VK_KHR_timeline_semaphore");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkGetSemaphoreCounterValueKHR: PFN_vkGetSemaphoreCounterValueKHR,
                pub vkSignalSemaphoreKHR: PFN_vkSignalSemaphoreKHR,
                pub vkWaitSemaphoresKHR: PFN_vkWaitSemaphoresKHR,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkGetSemaphoreCounterValueKHR: get(c!("vkGetSemaphoreCounterValueKHR")).map(|a| a.cast()),
                        vkSignalSemaphoreKHR: get(c!("vkSignalSemaphoreKHR")).map(|a| a.cast()),
                        vkWaitSemaphoresKHR: get(c!("vkWaitSemaphoresKHR")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkGetSemaphoreCounterValueKHR`
                pub unsafe fn GetSemaphoreCounterValueKHR(&self, device: VkDevice, semaphore: VkSemaphore, pValue: *mut uint64_t) -> VkResult {
                    unsafe { (self.vkGetSemaphoreCounterValueKHR.expect("Unable to load vkGetSemaphoreCounterValueKHR"))(device, semaphore, pValue) }
                }
                /// `vkSignalSemaphoreKHR`
                pub unsafe fn SignalSemaphoreKHR(&self, device: VkDevice, pSignalInfo: *const VkSemaphoreSignalInfo) -> VkResult {
                    unsafe { (self.vkSignalSemaphoreKHR.expect("Unable to load vkSignalSemaphoreKHR"))(device, pSignalInfo) }
                }
                /// `vkWaitSemaphoresKHR`
                pub unsafe fn WaitSemaphoresKHR(&self, device: VkDevice, pWaitInfo: *const VkSemaphoreWaitInfo, timeout: uint64_t) -> VkResult {
                    unsafe { (self.vkWaitSemaphoresKHR.expect("Unable to load vkWaitSemaphoresKHR"))(device, pWaitInfo, timeout) }
                }
            }
        }

        /// `VK_KHR_vulkan_memory_model`
        pub mod vulkan_memory_model {
            use super::*;

            /// `VK_KHR_vulkan_memory_model`
            pub const NAME: &'static CStr = c!("VK_KHR_vulkan_memory_model");
        }

        /// `VK_KHR_shader_terminate_invocation`
        pub mod shader_terminate_invocation {
            use super::*;

            /// `VK_KHR_shader_terminate_invocation`
            pub const NAME: &'static CStr = c!("VK_KHR_shader_terminate_invocation");
        }

        /// `VK_KHR_fragment_shading_rate`
        pub mod fragment_shading_rate {
            use super::*;

            /// `VK_KHR_fragment_shading_rate`
            pub const NAME: &'static CStr = c!("VK_KHR_fragment_shading_rate");

            /// InstanceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct InstanceCommands {
                pub vkGetPhysicalDeviceFragmentShadingRatesKHR: PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR,
            }

            impl InstanceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkGetPhysicalDeviceFragmentShadingRatesKHR: get(c!("vkGetPhysicalDeviceFragmentShadingRatesKHR")).map(|a| a.cast()),
                    } }
                }
            }

            impl InstanceCommands {
                /// `vkGetPhysicalDeviceFragmentShadingRatesKHR`
                pub unsafe fn GetPhysicalDeviceFragmentShadingRatesKHR(&self, physicalDevice: VkPhysicalDevice, pFragmentShadingRateCount: *mut uint32_t, pFragmentShadingRates: *mut VkPhysicalDeviceFragmentShadingRateKHR) -> VkResult {
                    unsafe { (self.vkGetPhysicalDeviceFragmentShadingRatesKHR.expect("Unable to load vkGetPhysicalDeviceFragmentShadingRatesKHR"))(physicalDevice, pFragmentShadingRateCount, pFragmentShadingRates) }
                }
            }

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkCmdSetFragmentShadingRateKHR: PFN_vkCmdSetFragmentShadingRateKHR,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkCmdSetFragmentShadingRateKHR: get(c!("vkCmdSetFragmentShadingRateKHR")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkCmdSetFragmentShadingRateKHR`
                pub unsafe fn CmdSetFragmentShadingRateKHR(&self, commandBuffer: VkCommandBuffer, pFragmentSize: *const VkExtent2D, combinerOps: *const VkFragmentShadingRateCombinerOpKHR) -> () {
                    unsafe { (self.vkCmdSetFragmentShadingRateKHR.expect("Unable to load vkCmdSetFragmentShadingRateKHR"))(commandBuffer, pFragmentSize, combinerOps) }
                }
            }
        }

        /// `VK_KHR_dynamic_rendering_local_read`
        pub mod dynamic_rendering_local_read {
            use super::*;

            /// `VK_KHR_dynamic_rendering_local_read`
            pub const NAME: &'static CStr = c!("VK_KHR_dynamic_rendering_local_read");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkCmdSetRenderingAttachmentLocationsKHR: PFN_vkCmdSetRenderingAttachmentLocationsKHR,
                pub vkCmdSetRenderingInputAttachmentIndicesKHR: PFN_vkCmdSetRenderingInputAttachmentIndicesKHR,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkCmdSetRenderingAttachmentLocationsKHR: get(c!("vkCmdSetRenderingAttachmentLocationsKHR")).map(|a| a.cast()),
                        vkCmdSetRenderingInputAttachmentIndicesKHR: get(c!("vkCmdSetRenderingInputAttachmentIndicesKHR")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkCmdSetRenderingAttachmentLocationsKHR`
                pub unsafe fn CmdSetRenderingAttachmentLocationsKHR(&self, commandBuffer: VkCommandBuffer, pLocationInfo: *const VkRenderingAttachmentLocationInfo) -> () {
                    unsafe { (self.vkCmdSetRenderingAttachmentLocationsKHR.expect("Unable to load vkCmdSetRenderingAttachmentLocationsKHR"))(commandBuffer, pLocationInfo) }
                }
                /// `vkCmdSetRenderingInputAttachmentIndicesKHR`
                pub unsafe fn CmdSetRenderingInputAttachmentIndicesKHR(&self, commandBuffer: VkCommandBuffer, pInputAttachmentIndexInfo: *const VkRenderingInputAttachmentIndexInfo) -> () {
                    unsafe { (self.vkCmdSetRenderingInputAttachmentIndicesKHR.expect("Unable to load vkCmdSetRenderingInputAttachmentIndicesKHR"))(commandBuffer, pInputAttachmentIndexInfo) }
                }
            }
        }

        /// `VK_KHR_shader_quad_control`
        pub mod shader_quad_control {
            use super::*;

            /// `VK_KHR_shader_quad_control`
            pub const NAME: &'static CStr = c!("VK_KHR_shader_quad_control");
        }

        /// `VK_KHR_spirv_1_4`
        pub mod spirv_1_4 {
            use super::*;

            /// `VK_KHR_spirv_1_4`
            pub const NAME: &'static CStr = c!("VK_KHR_spirv_1_4");
        }

        /// `VK_KHR_surface_protected_capabilities`
        pub mod surface_protected_capabilities {
            use super::*;

            /// `VK_KHR_surface_protected_capabilities`
            pub const NAME: &'static CStr = c!("VK_KHR_surface_protected_capabilities");
        }

        /// `VK_KHR_separate_depth_stencil_layouts`
        pub mod separate_depth_stencil_layouts {
            use super::*;

            /// `VK_KHR_separate_depth_stencil_layouts`
            pub const NAME: &'static CStr = c!("VK_KHR_separate_depth_stencil_layouts");
        }

        /// `VK_KHR_present_wait`
        pub mod present_wait {
            use super::*;

            /// `VK_KHR_present_wait`
            pub const NAME: &'static CStr = c!("VK_KHR_present_wait");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkWaitForPresentKHR: PFN_vkWaitForPresentKHR,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkWaitForPresentKHR: get(c!("vkWaitForPresentKHR")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkWaitForPresentKHR`
                pub unsafe fn WaitForPresentKHR(&self, device: VkDevice, swapchain: VkSwapchainKHR, presentId: uint64_t, timeout: uint64_t) -> VkResult {
                    unsafe { (self.vkWaitForPresentKHR.expect("Unable to load vkWaitForPresentKHR"))(device, swapchain, presentId, timeout) }
                }
            }
        }

        /// `VK_KHR_uniform_buffer_standard_layout`
        pub mod uniform_buffer_standard_layout {
            use super::*;

            /// `VK_KHR_uniform_buffer_standard_layout`
            pub const NAME: &'static CStr = c!("VK_KHR_uniform_buffer_standard_layout");
        }

        /// `VK_KHR_buffer_device_address`
        pub mod buffer_device_address {
            use super::*;

            /// `VK_KHR_buffer_device_address`
            pub const NAME: &'static CStr = c!("VK_KHR_buffer_device_address");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkGetBufferDeviceAddressKHR: PFN_vkGetBufferDeviceAddressKHR,
                pub vkGetBufferOpaqueCaptureAddressKHR: PFN_vkGetBufferOpaqueCaptureAddressKHR,
                pub vkGetDeviceMemoryOpaqueCaptureAddressKHR: PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkGetBufferDeviceAddressKHR: get(c!("vkGetBufferDeviceAddressKHR")).map(|a| a.cast()),
                        vkGetBufferOpaqueCaptureAddressKHR: get(c!("vkGetBufferOpaqueCaptureAddressKHR")).map(|a| a.cast()),
                        vkGetDeviceMemoryOpaqueCaptureAddressKHR: get(c!("vkGetDeviceMemoryOpaqueCaptureAddressKHR")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkGetBufferDeviceAddressKHR`
                pub unsafe fn GetBufferDeviceAddressKHR(&self, device: VkDevice, pInfo: *const VkBufferDeviceAddressInfo) -> VkDeviceAddress {
                    unsafe { (self.vkGetBufferDeviceAddressKHR.expect("Unable to load vkGetBufferDeviceAddressKHR"))(device, pInfo) }
                }
                /// `vkGetBufferOpaqueCaptureAddressKHR`
                pub unsafe fn GetBufferOpaqueCaptureAddressKHR(&self, device: VkDevice, pInfo: *const VkBufferDeviceAddressInfo) -> uint64_t {
                    unsafe { (self.vkGetBufferOpaqueCaptureAddressKHR.expect("Unable to load vkGetBufferOpaqueCaptureAddressKHR"))(device, pInfo) }
                }
                /// `vkGetDeviceMemoryOpaqueCaptureAddressKHR`
                pub unsafe fn GetDeviceMemoryOpaqueCaptureAddressKHR(&self, device: VkDevice, pInfo: *const VkDeviceMemoryOpaqueCaptureAddressInfo) -> uint64_t {
                    unsafe { (self.vkGetDeviceMemoryOpaqueCaptureAddressKHR.expect("Unable to load vkGetDeviceMemoryOpaqueCaptureAddressKHR"))(device, pInfo) }
                }
            }
        }

        /// `VK_KHR_deferred_host_operations`
        pub mod deferred_host_operations {
            use super::*;

            /// `VK_KHR_deferred_host_operations`
            pub const NAME: &'static CStr = c!("VK_KHR_deferred_host_operations");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkCreateDeferredOperationKHR: PFN_vkCreateDeferredOperationKHR,
                pub vkDeferredOperationJoinKHR: PFN_vkDeferredOperationJoinKHR,
                pub vkDestroyDeferredOperationKHR: PFN_vkDestroyDeferredOperationKHR,
                pub vkGetDeferredOperationMaxConcurrencyKHR: PFN_vkGetDeferredOperationMaxConcurrencyKHR,
                pub vkGetDeferredOperationResultKHR: PFN_vkGetDeferredOperationResultKHR,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkCreateDeferredOperationKHR: get(c!("vkCreateDeferredOperationKHR")).map(|a| a.cast()),
                        vkDeferredOperationJoinKHR: get(c!("vkDeferredOperationJoinKHR")).map(|a| a.cast()),
                        vkDestroyDeferredOperationKHR: get(c!("vkDestroyDeferredOperationKHR")).map(|a| a.cast()),
                        vkGetDeferredOperationMaxConcurrencyKHR: get(c!("vkGetDeferredOperationMaxConcurrencyKHR")).map(|a| a.cast()),
                        vkGetDeferredOperationResultKHR: get(c!("vkGetDeferredOperationResultKHR")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkCreateDeferredOperationKHR`
                pub unsafe fn CreateDeferredOperationKHR(&self, device: VkDevice, pAllocator: *const VkAllocationCallbacks, pDeferredOperation: *mut VkDeferredOperationKHR) -> VkResult {
                    unsafe { (self.vkCreateDeferredOperationKHR.expect("Unable to load vkCreateDeferredOperationKHR"))(device, pAllocator, pDeferredOperation) }
                }
                /// `vkDeferredOperationJoinKHR`
                pub unsafe fn DeferredOperationJoinKHR(&self, device: VkDevice, operation: VkDeferredOperationKHR) -> VkResult {
                    unsafe { (self.vkDeferredOperationJoinKHR.expect("Unable to load vkDeferredOperationJoinKHR"))(device, operation) }
                }
                /// `vkDestroyDeferredOperationKHR`
                pub unsafe fn DestroyDeferredOperationKHR(&self, device: VkDevice, operation: VkDeferredOperationKHR, pAllocator: *const VkAllocationCallbacks) -> () {
                    unsafe { (self.vkDestroyDeferredOperationKHR.expect("Unable to load vkDestroyDeferredOperationKHR"))(device, operation, pAllocator) }
                }
                /// `vkGetDeferredOperationMaxConcurrencyKHR`
                pub unsafe fn GetDeferredOperationMaxConcurrencyKHR(&self, device: VkDevice, operation: VkDeferredOperationKHR) -> uint32_t {
                    unsafe { (self.vkGetDeferredOperationMaxConcurrencyKHR.expect("Unable to load vkGetDeferredOperationMaxConcurrencyKHR"))(device, operation) }
                }
                /// `vkGetDeferredOperationResultKHR`
                pub unsafe fn GetDeferredOperationResultKHR(&self, device: VkDevice, operation: VkDeferredOperationKHR) -> VkResult {
                    unsafe { (self.vkGetDeferredOperationResultKHR.expect("Unable to load vkGetDeferredOperationResultKHR"))(device, operation) }
                }
            }
        }

        /// `VK_KHR_pipeline_executable_properties`
        pub mod pipeline_executable_properties {
            use super::*;

            /// `VK_KHR_pipeline_executable_properties`
            pub const NAME: &'static CStr = c!("VK_KHR_pipeline_executable_properties");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkGetPipelineExecutableInternalRepresentationsKHR: PFN_vkGetPipelineExecutableInternalRepresentationsKHR,
                pub vkGetPipelineExecutablePropertiesKHR: PFN_vkGetPipelineExecutablePropertiesKHR,
                pub vkGetPipelineExecutableStatisticsKHR: PFN_vkGetPipelineExecutableStatisticsKHR,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkGetPipelineExecutableInternalRepresentationsKHR: get(c!("vkGetPipelineExecutableInternalRepresentationsKHR")).map(|a| a.cast()),
                        vkGetPipelineExecutablePropertiesKHR: get(c!("vkGetPipelineExecutablePropertiesKHR")).map(|a| a.cast()),
                        vkGetPipelineExecutableStatisticsKHR: get(c!("vkGetPipelineExecutableStatisticsKHR")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkGetPipelineExecutableInternalRepresentationsKHR`
                pub unsafe fn GetPipelineExecutableInternalRepresentationsKHR(&self, device: VkDevice, pExecutableInfo: *const VkPipelineExecutableInfoKHR, pInternalRepresentationCount: *mut uint32_t, pInternalRepresentations: *mut VkPipelineExecutableInternalRepresentationKHR) -> VkResult {
                    unsafe { (self.vkGetPipelineExecutableInternalRepresentationsKHR.expect("Unable to load vkGetPipelineExecutableInternalRepresentationsKHR"))(device, pExecutableInfo, pInternalRepresentationCount, pInternalRepresentations) }
                }
                /// `vkGetPipelineExecutablePropertiesKHR`
                pub unsafe fn GetPipelineExecutablePropertiesKHR(&self, device: VkDevice, pPipelineInfo: *const VkPipelineInfoKHR, pExecutableCount: *mut uint32_t, pProperties: *mut VkPipelineExecutablePropertiesKHR) -> VkResult {
                    unsafe { (self.vkGetPipelineExecutablePropertiesKHR.expect("Unable to load vkGetPipelineExecutablePropertiesKHR"))(device, pPipelineInfo, pExecutableCount, pProperties) }
                }
                /// `vkGetPipelineExecutableStatisticsKHR`
                pub unsafe fn GetPipelineExecutableStatisticsKHR(&self, device: VkDevice, pExecutableInfo: *const VkPipelineExecutableInfoKHR, pStatisticCount: *mut uint32_t, pStatistics: *mut VkPipelineExecutableStatisticKHR) -> VkResult {
                    unsafe { (self.vkGetPipelineExecutableStatisticsKHR.expect("Unable to load vkGetPipelineExecutableStatisticsKHR"))(device, pExecutableInfo, pStatisticCount, pStatistics) }
                }
            }
        }

        /// `VK_KHR_map_memory2`
        pub mod map_memory2 {
            use super::*;

            /// `VK_KHR_map_memory2`
            pub const NAME: &'static CStr = c!("VK_KHR_map_memory2");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkMapMemory2KHR: PFN_vkMapMemory2KHR,
                pub vkUnmapMemory2KHR: PFN_vkUnmapMemory2KHR,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkMapMemory2KHR: get(c!("vkMapMemory2KHR")).map(|a| a.cast()),
                        vkUnmapMemory2KHR: get(c!("vkUnmapMemory2KHR")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkMapMemory2KHR`
                pub unsafe fn MapMemory2KHR(&self, device: VkDevice, pMemoryMapInfo: *const VkMemoryMapInfo, ppData: *mut *mut void) -> VkResult {
                    unsafe { (self.vkMapMemory2KHR.expect("Unable to load vkMapMemory2KHR"))(device, pMemoryMapInfo, ppData) }
                }
                /// `vkUnmapMemory2KHR`
                pub unsafe fn UnmapMemory2KHR(&self, device: VkDevice, pMemoryUnmapInfo: *const VkMemoryUnmapInfo) -> VkResult {
                    unsafe { (self.vkUnmapMemory2KHR.expect("Unable to load vkUnmapMemory2KHR"))(device, pMemoryUnmapInfo) }
                }
            }
        }

        /// `VK_KHR_shader_integer_dot_product`
        pub mod shader_integer_dot_product {
            use super::*;

            /// `VK_KHR_shader_integer_dot_product`
            pub const NAME: &'static CStr = c!("VK_KHR_shader_integer_dot_product");
        }

        /// `VK_KHR_pipeline_library`
        pub mod pipeline_library {
            use super::*;

            /// `VK_KHR_pipeline_library`
            pub const NAME: &'static CStr = c!("VK_KHR_pipeline_library");
        }

        /// `VK_KHR_shader_non_semantic_info`
        pub mod shader_non_semantic_info {
            use super::*;

            /// `VK_KHR_shader_non_semantic_info`
            pub const NAME: &'static CStr = c!("VK_KHR_shader_non_semantic_info");
        }

        /// `VK_KHR_present_id`
        pub mod present_id {
            use super::*;

            /// `VK_KHR_present_id`
            pub const NAME: &'static CStr = c!("VK_KHR_present_id");
        }

        /// `VK_KHR_video_encode_queue`
        pub mod video_encode_queue {
            use super::*;

            /// `VK_KHR_video_encode_queue`
            pub const NAME: &'static CStr = c!("VK_KHR_video_encode_queue");

            /// InstanceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct InstanceCommands {
                pub vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR: PFN_vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR,
            }

            impl InstanceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR: get(c!("vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR")).map(|a| a.cast()),
                    } }
                }
            }

            impl InstanceCommands {
                /// `vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR`
                pub unsafe fn GetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR(&self, physicalDevice: VkPhysicalDevice, pQualityLevelInfo: *const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR, pQualityLevelProperties: *mut VkVideoEncodeQualityLevelPropertiesKHR) -> VkResult {
                    unsafe { (self.vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR.expect("Unable to load vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR"))(physicalDevice, pQualityLevelInfo, pQualityLevelProperties) }
                }
            }

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkCmdEncodeVideoKHR: PFN_vkCmdEncodeVideoKHR,
                pub vkGetEncodedVideoSessionParametersKHR: PFN_vkGetEncodedVideoSessionParametersKHR,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkCmdEncodeVideoKHR: get(c!("vkCmdEncodeVideoKHR")).map(|a| a.cast()),
                        vkGetEncodedVideoSessionParametersKHR: get(c!("vkGetEncodedVideoSessionParametersKHR")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkCmdEncodeVideoKHR`
                pub unsafe fn CmdEncodeVideoKHR(&self, commandBuffer: VkCommandBuffer, pEncodeInfo: *const VkVideoEncodeInfoKHR) -> () {
                    unsafe { (self.vkCmdEncodeVideoKHR.expect("Unable to load vkCmdEncodeVideoKHR"))(commandBuffer, pEncodeInfo) }
                }
                /// `vkGetEncodedVideoSessionParametersKHR`
                pub unsafe fn GetEncodedVideoSessionParametersKHR(&self, device: VkDevice, pVideoSessionParametersInfo: *const VkVideoEncodeSessionParametersGetInfoKHR, pFeedbackInfo: *mut VkVideoEncodeSessionParametersFeedbackInfoKHR, pDataSize: *mut size_t, pData: *mut void) -> VkResult {
                    unsafe { (self.vkGetEncodedVideoSessionParametersKHR.expect("Unable to load vkGetEncodedVideoSessionParametersKHR"))(device, pVideoSessionParametersInfo, pFeedbackInfo, pDataSize, pData) }
                }
            }
        }

        /// `VK_KHR_object_refresh`
        pub mod object_refresh {
            use super::*;

            /// `VK_KHR_object_refresh`
            pub const NAME: &'static CStr = c!("VK_KHR_object_refresh");

            /// InstanceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct InstanceCommands {
                pub vkGetPhysicalDeviceRefreshableObjectTypesKHR: PFN_vkGetPhysicalDeviceRefreshableObjectTypesKHR,
            }

            impl InstanceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkGetPhysicalDeviceRefreshableObjectTypesKHR: get(c!("vkGetPhysicalDeviceRefreshableObjectTypesKHR")).map(|a| a.cast()),
                    } }
                }
            }

            impl InstanceCommands {
                /// `vkGetPhysicalDeviceRefreshableObjectTypesKHR`
                pub unsafe fn GetPhysicalDeviceRefreshableObjectTypesKHR(&self, physicalDevice: VkPhysicalDevice, pRefreshableObjectTypeCount: *mut uint32_t, pRefreshableObjectTypes: *mut VkObjectType) -> VkResult {
                    unsafe { (self.vkGetPhysicalDeviceRefreshableObjectTypesKHR.expect("Unable to load vkGetPhysicalDeviceRefreshableObjectTypesKHR"))(physicalDevice, pRefreshableObjectTypeCount, pRefreshableObjectTypes) }
                }
            }

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkCmdRefreshObjectsKHR: PFN_vkCmdRefreshObjectsKHR,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkCmdRefreshObjectsKHR: get(c!("vkCmdRefreshObjectsKHR")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkCmdRefreshObjectsKHR`
                pub unsafe fn CmdRefreshObjectsKHR(&self, commandBuffer: VkCommandBuffer, pRefreshObjects: *const VkRefreshObjectListKHR) -> () {
                    unsafe { (self.vkCmdRefreshObjectsKHR.expect("Unable to load vkCmdRefreshObjectsKHR"))(commandBuffer, pRefreshObjects) }
                }
            }
        }

        /// `VK_KHR_synchronization2`
        pub mod synchronization2 {
            use super::*;

            /// `VK_KHR_synchronization2`
            pub const NAME: &'static CStr = c!("VK_KHR_synchronization2");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkCmdPipelineBarrier2KHR: PFN_vkCmdPipelineBarrier2KHR,
                pub vkCmdResetEvent2KHR: PFN_vkCmdResetEvent2KHR,
                pub vkCmdSetEvent2KHR: PFN_vkCmdSetEvent2KHR,
                pub vkCmdWaitEvents2KHR: PFN_vkCmdWaitEvents2KHR,
                pub vkCmdWriteTimestamp2KHR: PFN_vkCmdWriteTimestamp2KHR,
                pub vkQueueSubmit2KHR: PFN_vkQueueSubmit2KHR,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkCmdPipelineBarrier2KHR: get(c!("vkCmdPipelineBarrier2KHR")).map(|a| a.cast()),
                        vkCmdResetEvent2KHR: get(c!("vkCmdResetEvent2KHR")).map(|a| a.cast()),
                        vkCmdSetEvent2KHR: get(c!("vkCmdSetEvent2KHR")).map(|a| a.cast()),
                        vkCmdWaitEvents2KHR: get(c!("vkCmdWaitEvents2KHR")).map(|a| a.cast()),
                        vkCmdWriteTimestamp2KHR: get(c!("vkCmdWriteTimestamp2KHR")).map(|a| a.cast()),
                        vkQueueSubmit2KHR: get(c!("vkQueueSubmit2KHR")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkCmdPipelineBarrier2KHR`
                pub unsafe fn CmdPipelineBarrier2KHR(&self, commandBuffer: VkCommandBuffer, pDependencyInfo: *const VkDependencyInfo) -> () {
                    unsafe { (self.vkCmdPipelineBarrier2KHR.expect("Unable to load vkCmdPipelineBarrier2KHR"))(commandBuffer, pDependencyInfo) }
                }
                /// `vkCmdResetEvent2KHR`
                pub unsafe fn CmdResetEvent2KHR(&self, commandBuffer: VkCommandBuffer, event: VkEvent, stageMask: VkPipelineStageFlags2) -> () {
                    unsafe { (self.vkCmdResetEvent2KHR.expect("Unable to load vkCmdResetEvent2KHR"))(commandBuffer, event, stageMask) }
                }
                /// `vkCmdSetEvent2KHR`
                pub unsafe fn CmdSetEvent2KHR(&self, commandBuffer: VkCommandBuffer, event: VkEvent, pDependencyInfo: *const VkDependencyInfo) -> () {
                    unsafe { (self.vkCmdSetEvent2KHR.expect("Unable to load vkCmdSetEvent2KHR"))(commandBuffer, event, pDependencyInfo) }
                }
                /// `vkCmdWaitEvents2KHR`
                pub unsafe fn CmdWaitEvents2KHR(&self, commandBuffer: VkCommandBuffer, eventCount: uint32_t, pEvents: *const VkEvent, pDependencyInfos: *const VkDependencyInfo) -> () {
                    unsafe { (self.vkCmdWaitEvents2KHR.expect("Unable to load vkCmdWaitEvents2KHR"))(commandBuffer, eventCount, pEvents, pDependencyInfos) }
                }
                /// `vkCmdWriteTimestamp2KHR`
                pub unsafe fn CmdWriteTimestamp2KHR(&self, commandBuffer: VkCommandBuffer, stage: VkPipelineStageFlags2, queryPool: VkQueryPool, query: uint32_t) -> () {
                    unsafe { (self.vkCmdWriteTimestamp2KHR.expect("Unable to load vkCmdWriteTimestamp2KHR"))(commandBuffer, stage, queryPool, query) }
                }
                /// `vkQueueSubmit2KHR`
                pub unsafe fn QueueSubmit2KHR(&self, queue: VkQueue, submitCount: uint32_t, pSubmits: *const VkSubmitInfo2, fence: VkFence) -> VkResult {
                    unsafe { (self.vkQueueSubmit2KHR.expect("Unable to load vkQueueSubmit2KHR"))(queue, submitCount, pSubmits, fence) }
                }
            }
        }

        /// `VK_KHR_fragment_shader_barycentric`
        pub mod fragment_shader_barycentric {
            use super::*;

            /// `VK_KHR_fragment_shader_barycentric`
            pub const NAME: &'static CStr = c!("VK_KHR_fragment_shader_barycentric");
        }

        /// `VK_KHR_shader_subgroup_uniform_control_flow`
        pub mod shader_subgroup_uniform_control_flow {
            use super::*;

            /// `VK_KHR_shader_subgroup_uniform_control_flow`
            pub const NAME: &'static CStr = c!("VK_KHR_shader_subgroup_uniform_control_flow");
        }

        /// `VK_KHR_zero_initialize_workgroup_memory`
        pub mod zero_initialize_workgroup_memory {
            use super::*;

            /// `VK_KHR_zero_initialize_workgroup_memory`
            pub const NAME: &'static CStr = c!("VK_KHR_zero_initialize_workgroup_memory");
        }

        /// `VK_KHR_workgroup_memory_explicit_layout`
        pub mod workgroup_memory_explicit_layout {
            use super::*;

            /// `VK_KHR_workgroup_memory_explicit_layout`
            pub const NAME: &'static CStr = c!("VK_KHR_workgroup_memory_explicit_layout");
        }

        /// `VK_KHR_copy_commands2`
        pub mod copy_commands2 {
            use super::*;

            /// `VK_KHR_copy_commands2`
            pub const NAME: &'static CStr = c!("VK_KHR_copy_commands2");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkCmdBlitImage2KHR: PFN_vkCmdBlitImage2KHR,
                pub vkCmdCopyBuffer2KHR: PFN_vkCmdCopyBuffer2KHR,
                pub vkCmdCopyBufferToImage2KHR: PFN_vkCmdCopyBufferToImage2KHR,
                pub vkCmdCopyImage2KHR: PFN_vkCmdCopyImage2KHR,
                pub vkCmdCopyImageToBuffer2KHR: PFN_vkCmdCopyImageToBuffer2KHR,
                pub vkCmdResolveImage2KHR: PFN_vkCmdResolveImage2KHR,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkCmdBlitImage2KHR: get(c!("vkCmdBlitImage2KHR")).map(|a| a.cast()),
                        vkCmdCopyBuffer2KHR: get(c!("vkCmdCopyBuffer2KHR")).map(|a| a.cast()),
                        vkCmdCopyBufferToImage2KHR: get(c!("vkCmdCopyBufferToImage2KHR")).map(|a| a.cast()),
                        vkCmdCopyImage2KHR: get(c!("vkCmdCopyImage2KHR")).map(|a| a.cast()),
                        vkCmdCopyImageToBuffer2KHR: get(c!("vkCmdCopyImageToBuffer2KHR")).map(|a| a.cast()),
                        vkCmdResolveImage2KHR: get(c!("vkCmdResolveImage2KHR")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkCmdBlitImage2KHR`
                pub unsafe fn CmdBlitImage2KHR(&self, commandBuffer: VkCommandBuffer, pBlitImageInfo: *const VkBlitImageInfo2) -> () {
                    unsafe { (self.vkCmdBlitImage2KHR.expect("Unable to load vkCmdBlitImage2KHR"))(commandBuffer, pBlitImageInfo) }
                }
                /// `vkCmdCopyBuffer2KHR`
                pub unsafe fn CmdCopyBuffer2KHR(&self, commandBuffer: VkCommandBuffer, pCopyBufferInfo: *const VkCopyBufferInfo2) -> () {
                    unsafe { (self.vkCmdCopyBuffer2KHR.expect("Unable to load vkCmdCopyBuffer2KHR"))(commandBuffer, pCopyBufferInfo) }
                }
                /// `vkCmdCopyBufferToImage2KHR`
                pub unsafe fn CmdCopyBufferToImage2KHR(&self, commandBuffer: VkCommandBuffer, pCopyBufferToImageInfo: *const VkCopyBufferToImageInfo2) -> () {
                    unsafe { (self.vkCmdCopyBufferToImage2KHR.expect("Unable to load vkCmdCopyBufferToImage2KHR"))(commandBuffer, pCopyBufferToImageInfo) }
                }
                /// `vkCmdCopyImage2KHR`
                pub unsafe fn CmdCopyImage2KHR(&self, commandBuffer: VkCommandBuffer, pCopyImageInfo: *const VkCopyImageInfo2) -> () {
                    unsafe { (self.vkCmdCopyImage2KHR.expect("Unable to load vkCmdCopyImage2KHR"))(commandBuffer, pCopyImageInfo) }
                }
                /// `vkCmdCopyImageToBuffer2KHR`
                pub unsafe fn CmdCopyImageToBuffer2KHR(&self, commandBuffer: VkCommandBuffer, pCopyImageToBufferInfo: *const VkCopyImageToBufferInfo2) -> () {
                    unsafe { (self.vkCmdCopyImageToBuffer2KHR.expect("Unable to load vkCmdCopyImageToBuffer2KHR"))(commandBuffer, pCopyImageToBufferInfo) }
                }
                /// `vkCmdResolveImage2KHR`
                pub unsafe fn CmdResolveImage2KHR(&self, commandBuffer: VkCommandBuffer, pResolveImageInfo: *const VkResolveImageInfo2) -> () {
                    unsafe { (self.vkCmdResolveImage2KHR.expect("Unable to load vkCmdResolveImage2KHR"))(commandBuffer, pResolveImageInfo) }
                }
            }
        }

        /// `VK_KHR_ray_tracing_pipeline`
        pub mod ray_tracing_pipeline {
            use super::*;

            /// `VK_KHR_ray_tracing_pipeline`
            pub const NAME: &'static CStr = c!("VK_KHR_ray_tracing_pipeline");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkCmdSetRayTracingPipelineStackSizeKHR: PFN_vkCmdSetRayTracingPipelineStackSizeKHR,
                pub vkCmdTraceRaysIndirectKHR: PFN_vkCmdTraceRaysIndirectKHR,
                pub vkCmdTraceRaysKHR: PFN_vkCmdTraceRaysKHR,
                pub vkCreateRayTracingPipelinesKHR: PFN_vkCreateRayTracingPipelinesKHR,
                pub vkGetRayTracingCaptureReplayShaderGroupHandlesKHR: PFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR,
                pub vkGetRayTracingShaderGroupHandlesKHR: PFN_vkGetRayTracingShaderGroupHandlesKHR,
                pub vkGetRayTracingShaderGroupStackSizeKHR: PFN_vkGetRayTracingShaderGroupStackSizeKHR,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkCmdSetRayTracingPipelineStackSizeKHR: get(c!("vkCmdSetRayTracingPipelineStackSizeKHR")).map(|a| a.cast()),
                        vkCmdTraceRaysIndirectKHR: get(c!("vkCmdTraceRaysIndirectKHR")).map(|a| a.cast()),
                        vkCmdTraceRaysKHR: get(c!("vkCmdTraceRaysKHR")).map(|a| a.cast()),
                        vkCreateRayTracingPipelinesKHR: get(c!("vkCreateRayTracingPipelinesKHR")).map(|a| a.cast()),
                        vkGetRayTracingCaptureReplayShaderGroupHandlesKHR: get(c!("vkGetRayTracingCaptureReplayShaderGroupHandlesKHR")).map(|a| a.cast()),
                        vkGetRayTracingShaderGroupHandlesKHR: get(c!("vkGetRayTracingShaderGroupHandlesKHR")).map(|a| a.cast()),
                        vkGetRayTracingShaderGroupStackSizeKHR: get(c!("vkGetRayTracingShaderGroupStackSizeKHR")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkCmdSetRayTracingPipelineStackSizeKHR`
                pub unsafe fn CmdSetRayTracingPipelineStackSizeKHR(&self, commandBuffer: VkCommandBuffer, pipelineStackSize: uint32_t) -> () {
                    unsafe { (self.vkCmdSetRayTracingPipelineStackSizeKHR.expect("Unable to load vkCmdSetRayTracingPipelineStackSizeKHR"))(commandBuffer, pipelineStackSize) }
                }
                /// `vkCmdTraceRaysIndirectKHR`
                pub unsafe fn CmdTraceRaysIndirectKHR(&self, commandBuffer: VkCommandBuffer, pRaygenShaderBindingTable: *const VkStridedDeviceAddressRegionKHR, pMissShaderBindingTable: *const VkStridedDeviceAddressRegionKHR, pHitShaderBindingTable: *const VkStridedDeviceAddressRegionKHR, pCallableShaderBindingTable: *const VkStridedDeviceAddressRegionKHR, indirectDeviceAddress: VkDeviceAddress) -> () {
                    unsafe { (self.vkCmdTraceRaysIndirectKHR.expect("Unable to load vkCmdTraceRaysIndirectKHR"))(commandBuffer, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable, pCallableShaderBindingTable, indirectDeviceAddress) }
                }
                /// `vkCmdTraceRaysKHR`
                pub unsafe fn CmdTraceRaysKHR(&self, commandBuffer: VkCommandBuffer, pRaygenShaderBindingTable: *const VkStridedDeviceAddressRegionKHR, pMissShaderBindingTable: *const VkStridedDeviceAddressRegionKHR, pHitShaderBindingTable: *const VkStridedDeviceAddressRegionKHR, pCallableShaderBindingTable: *const VkStridedDeviceAddressRegionKHR, width: uint32_t, height: uint32_t, depth: uint32_t) -> () {
                    unsafe { (self.vkCmdTraceRaysKHR.expect("Unable to load vkCmdTraceRaysKHR"))(commandBuffer, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable, pCallableShaderBindingTable, width, height, depth) }
                }
                /// `vkCreateRayTracingPipelinesKHR`
                pub unsafe fn CreateRayTracingPipelinesKHR(&self, device: VkDevice, deferredOperation: VkDeferredOperationKHR, pipelineCache: VkPipelineCache, createInfoCount: uint32_t, pCreateInfos: *const VkRayTracingPipelineCreateInfoKHR, pAllocator: *const VkAllocationCallbacks, pPipelines: *mut VkPipeline) -> VkResult {
                    unsafe { (self.vkCreateRayTracingPipelinesKHR.expect("Unable to load vkCreateRayTracingPipelinesKHR"))(device, deferredOperation, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines) }
                }
                /// `vkGetRayTracingCaptureReplayShaderGroupHandlesKHR`
                pub unsafe fn GetRayTracingCaptureReplayShaderGroupHandlesKHR(&self, device: VkDevice, pipeline: VkPipeline, firstGroup: uint32_t, groupCount: uint32_t, dataSize: size_t, pData: *mut void) -> VkResult {
                    unsafe { (self.vkGetRayTracingCaptureReplayShaderGroupHandlesKHR.expect("Unable to load vkGetRayTracingCaptureReplayShaderGroupHandlesKHR"))(device, pipeline, firstGroup, groupCount, dataSize, pData) }
                }
                /// `vkGetRayTracingShaderGroupHandlesKHR`
                pub unsafe fn GetRayTracingShaderGroupHandlesKHR(&self, device: VkDevice, pipeline: VkPipeline, firstGroup: uint32_t, groupCount: uint32_t, dataSize: size_t, pData: *mut void) -> VkResult {
                    unsafe { (self.vkGetRayTracingShaderGroupHandlesKHR.expect("Unable to load vkGetRayTracingShaderGroupHandlesKHR"))(device, pipeline, firstGroup, groupCount, dataSize, pData) }
                }
                /// `vkGetRayTracingShaderGroupStackSizeKHR`
                pub unsafe fn GetRayTracingShaderGroupStackSizeKHR(&self, device: VkDevice, pipeline: VkPipeline, group: uint32_t, groupShader: VkShaderGroupShaderKHR) -> VkDeviceSize {
                    unsafe { (self.vkGetRayTracingShaderGroupStackSizeKHR.expect("Unable to load vkGetRayTracingShaderGroupStackSizeKHR"))(device, pipeline, group, groupShader) }
                }
            }
        }

        /// `VK_KHR_ray_query`
        pub mod ray_query {
            use super::*;

            /// `VK_KHR_ray_query`
            pub const NAME: &'static CStr = c!("VK_KHR_ray_query");
        }

        /// `VK_KHR_format_feature_flags2`
        pub mod format_feature_flags2 {
            use super::*;

            /// `VK_KHR_format_feature_flags2`
            pub const NAME: &'static CStr = c!("VK_KHR_format_feature_flags2");
        }

        /// `VK_KHR_ray_tracing_maintenance1`
        pub mod ray_tracing_maintenance1 {
            use super::*;

            /// `VK_KHR_ray_tracing_maintenance1`
            pub const NAME: &'static CStr = c!("VK_KHR_ray_tracing_maintenance1");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkCmdTraceRaysIndirect2KHR: PFN_vkCmdTraceRaysIndirect2KHR,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkCmdTraceRaysIndirect2KHR: get(c!("vkCmdTraceRaysIndirect2KHR")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkCmdTraceRaysIndirect2KHR`
                pub unsafe fn CmdTraceRaysIndirect2KHR(&self, commandBuffer: VkCommandBuffer, indirectDeviceAddress: VkDeviceAddress) -> () {
                    unsafe { (self.vkCmdTraceRaysIndirect2KHR.expect("Unable to load vkCmdTraceRaysIndirect2KHR"))(commandBuffer, indirectDeviceAddress) }
                }
            }
        }

        /// `VK_KHR_shader_untyped_pointers`
        pub mod shader_untyped_pointers {
            use super::*;

            /// `VK_KHR_shader_untyped_pointers`
            pub const NAME: &'static CStr = c!("VK_KHR_shader_untyped_pointers");
        }

        /// `VK_KHR_portability_enumeration`
        pub mod portability_enumeration {
            use super::*;

            /// `VK_KHR_portability_enumeration`
            pub const NAME: &'static CStr = c!("VK_KHR_portability_enumeration");
        }

        /// `VK_KHR_maintenance4`
        pub mod maintenance4 {
            use super::*;

            /// `VK_KHR_maintenance4`
            pub const NAME: &'static CStr = c!("VK_KHR_maintenance4");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkGetDeviceBufferMemoryRequirementsKHR: PFN_vkGetDeviceBufferMemoryRequirementsKHR,
                pub vkGetDeviceImageMemoryRequirementsKHR: PFN_vkGetDeviceImageMemoryRequirementsKHR,
                pub vkGetDeviceImageSparseMemoryRequirementsKHR: PFN_vkGetDeviceImageSparseMemoryRequirementsKHR,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkGetDeviceBufferMemoryRequirementsKHR: get(c!("vkGetDeviceBufferMemoryRequirementsKHR")).map(|a| a.cast()),
                        vkGetDeviceImageMemoryRequirementsKHR: get(c!("vkGetDeviceImageMemoryRequirementsKHR")).map(|a| a.cast()),
                        vkGetDeviceImageSparseMemoryRequirementsKHR: get(c!("vkGetDeviceImageSparseMemoryRequirementsKHR")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkGetDeviceBufferMemoryRequirementsKHR`
                pub unsafe fn GetDeviceBufferMemoryRequirementsKHR(&self, device: VkDevice, pInfo: *const VkDeviceBufferMemoryRequirements, pMemoryRequirements: *mut VkMemoryRequirements2) -> () {
                    unsafe { (self.vkGetDeviceBufferMemoryRequirementsKHR.expect("Unable to load vkGetDeviceBufferMemoryRequirementsKHR"))(device, pInfo, pMemoryRequirements) }
                }
                /// `vkGetDeviceImageMemoryRequirementsKHR`
                pub unsafe fn GetDeviceImageMemoryRequirementsKHR(&self, device: VkDevice, pInfo: *const VkDeviceImageMemoryRequirements, pMemoryRequirements: *mut VkMemoryRequirements2) -> () {
                    unsafe { (self.vkGetDeviceImageMemoryRequirementsKHR.expect("Unable to load vkGetDeviceImageMemoryRequirementsKHR"))(device, pInfo, pMemoryRequirements) }
                }
                /// `vkGetDeviceImageSparseMemoryRequirementsKHR`
                pub unsafe fn GetDeviceImageSparseMemoryRequirementsKHR(&self, device: VkDevice, pInfo: *const VkDeviceImageMemoryRequirements, pSparseMemoryRequirementCount: *mut uint32_t, pSparseMemoryRequirements: *mut VkSparseImageMemoryRequirements2) -> () {
                    unsafe { (self.vkGetDeviceImageSparseMemoryRequirementsKHR.expect("Unable to load vkGetDeviceImageSparseMemoryRequirementsKHR"))(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements) }
                }
            }
        }

        /// `VK_KHR_shader_subgroup_rotate`
        pub mod shader_subgroup_rotate {
            use super::*;

            /// `VK_KHR_shader_subgroup_rotate`
            pub const NAME: &'static CStr = c!("VK_KHR_shader_subgroup_rotate");
        }

        /// `VK_KHR_shader_maximal_reconvergence`
        pub mod shader_maximal_reconvergence {
            use super::*;

            /// `VK_KHR_shader_maximal_reconvergence`
            pub const NAME: &'static CStr = c!("VK_KHR_shader_maximal_reconvergence");
        }

        /// `VK_KHR_maintenance5`
        pub mod maintenance5 {
            use super::*;

            /// `VK_KHR_maintenance5`
            pub const NAME: &'static CStr = c!("VK_KHR_maintenance5");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkCmdBindIndexBuffer2KHR: PFN_vkCmdBindIndexBuffer2KHR,
                pub vkGetDeviceImageSubresourceLayoutKHR: PFN_vkGetDeviceImageSubresourceLayoutKHR,
                pub vkGetImageSubresourceLayout2KHR: PFN_vkGetImageSubresourceLayout2KHR,
                pub vkGetRenderingAreaGranularityKHR: PFN_vkGetRenderingAreaGranularityKHR,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkCmdBindIndexBuffer2KHR: get(c!("vkCmdBindIndexBuffer2KHR")).map(|a| a.cast()),
                        vkGetDeviceImageSubresourceLayoutKHR: get(c!("vkGetDeviceImageSubresourceLayoutKHR")).map(|a| a.cast()),
                        vkGetImageSubresourceLayout2KHR: get(c!("vkGetImageSubresourceLayout2KHR")).map(|a| a.cast()),
                        vkGetRenderingAreaGranularityKHR: get(c!("vkGetRenderingAreaGranularityKHR")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkCmdBindIndexBuffer2KHR`
                pub unsafe fn CmdBindIndexBuffer2KHR(&self, commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, size: VkDeviceSize, indexType: VkIndexType) -> () {
                    unsafe { (self.vkCmdBindIndexBuffer2KHR.expect("Unable to load vkCmdBindIndexBuffer2KHR"))(commandBuffer, buffer, offset, size, indexType) }
                }
                /// `vkGetDeviceImageSubresourceLayoutKHR`
                pub unsafe fn GetDeviceImageSubresourceLayoutKHR(&self, device: VkDevice, pInfo: *const VkDeviceImageSubresourceInfo, pLayout: *mut VkSubresourceLayout2) -> () {
                    unsafe { (self.vkGetDeviceImageSubresourceLayoutKHR.expect("Unable to load vkGetDeviceImageSubresourceLayoutKHR"))(device, pInfo, pLayout) }
                }
                /// `vkGetImageSubresourceLayout2KHR`
                pub unsafe fn GetImageSubresourceLayout2KHR(&self, device: VkDevice, image: VkImage, pSubresource: *const VkImageSubresource2, pLayout: *mut VkSubresourceLayout2) -> () {
                    unsafe { (self.vkGetImageSubresourceLayout2KHR.expect("Unable to load vkGetImageSubresourceLayout2KHR"))(device, image, pSubresource, pLayout) }
                }
                /// `vkGetRenderingAreaGranularityKHR`
                pub unsafe fn GetRenderingAreaGranularityKHR(&self, device: VkDevice, pRenderingAreaInfo: *const VkRenderingAreaInfo, pGranularity: *mut VkExtent2D) -> () {
                    unsafe { (self.vkGetRenderingAreaGranularityKHR.expect("Unable to load vkGetRenderingAreaGranularityKHR"))(device, pRenderingAreaInfo, pGranularity) }
                }
            }
        }

        /// `VK_KHR_present_id2`
        pub mod present_id2 {
            use super::*;

            /// `VK_KHR_present_id2`
            pub const NAME: &'static CStr = c!("VK_KHR_present_id2");
        }

        /// `VK_KHR_present_wait2`
        pub mod present_wait2 {
            use super::*;

            /// `VK_KHR_present_wait2`
            pub const NAME: &'static CStr = c!("VK_KHR_present_wait2");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkWaitForPresent2KHR: PFN_vkWaitForPresent2KHR,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkWaitForPresent2KHR: get(c!("vkWaitForPresent2KHR")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkWaitForPresent2KHR`
                pub unsafe fn WaitForPresent2KHR(&self, device: VkDevice, swapchain: VkSwapchainKHR, pPresentWait2Info: *const VkPresentWait2InfoKHR) -> VkResult {
                    unsafe { (self.vkWaitForPresent2KHR.expect("Unable to load vkWaitForPresent2KHR"))(device, swapchain, pPresentWait2Info) }
                }
            }
        }

        /// `VK_KHR_ray_tracing_position_fetch`
        pub mod ray_tracing_position_fetch {
            use super::*;

            /// `VK_KHR_ray_tracing_position_fetch`
            pub const NAME: &'static CStr = c!("VK_KHR_ray_tracing_position_fetch");
        }

        /// `VK_KHR_pipeline_binary`
        pub mod pipeline_binary {
            use super::*;

            /// `VK_KHR_pipeline_binary`
            pub const NAME: &'static CStr = c!("VK_KHR_pipeline_binary");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkCreatePipelineBinariesKHR: PFN_vkCreatePipelineBinariesKHR,
                pub vkDestroyPipelineBinaryKHR: PFN_vkDestroyPipelineBinaryKHR,
                pub vkGetPipelineBinaryDataKHR: PFN_vkGetPipelineBinaryDataKHR,
                pub vkGetPipelineKeyKHR: PFN_vkGetPipelineKeyKHR,
                pub vkReleaseCapturedPipelineDataKHR: PFN_vkReleaseCapturedPipelineDataKHR,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkCreatePipelineBinariesKHR: get(c!("vkCreatePipelineBinariesKHR")).map(|a| a.cast()),
                        vkDestroyPipelineBinaryKHR: get(c!("vkDestroyPipelineBinaryKHR")).map(|a| a.cast()),
                        vkGetPipelineBinaryDataKHR: get(c!("vkGetPipelineBinaryDataKHR")).map(|a| a.cast()),
                        vkGetPipelineKeyKHR: get(c!("vkGetPipelineKeyKHR")).map(|a| a.cast()),
                        vkReleaseCapturedPipelineDataKHR: get(c!("vkReleaseCapturedPipelineDataKHR")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkCreatePipelineBinariesKHR`
                pub unsafe fn CreatePipelineBinariesKHR(&self, device: VkDevice, pCreateInfo: *const VkPipelineBinaryCreateInfoKHR, pAllocator: *const VkAllocationCallbacks, pBinaries: *mut VkPipelineBinaryHandlesInfoKHR) -> VkResult {
                    unsafe { (self.vkCreatePipelineBinariesKHR.expect("Unable to load vkCreatePipelineBinariesKHR"))(device, pCreateInfo, pAllocator, pBinaries) }
                }
                /// `vkDestroyPipelineBinaryKHR`
                pub unsafe fn DestroyPipelineBinaryKHR(&self, device: VkDevice, pipelineBinary: VkPipelineBinaryKHR, pAllocator: *const VkAllocationCallbacks) -> () {
                    unsafe { (self.vkDestroyPipelineBinaryKHR.expect("Unable to load vkDestroyPipelineBinaryKHR"))(device, pipelineBinary, pAllocator) }
                }
                /// `vkGetPipelineBinaryDataKHR`
                pub unsafe fn GetPipelineBinaryDataKHR(&self, device: VkDevice, pInfo: *const VkPipelineBinaryDataInfoKHR, pPipelineBinaryKey: *mut VkPipelineBinaryKeyKHR, pPipelineBinaryDataSize: *mut size_t, pPipelineBinaryData: *mut void) -> VkResult {
                    unsafe { (self.vkGetPipelineBinaryDataKHR.expect("Unable to load vkGetPipelineBinaryDataKHR"))(device, pInfo, pPipelineBinaryKey, pPipelineBinaryDataSize, pPipelineBinaryData) }
                }
                /// `vkGetPipelineKeyKHR`
                pub unsafe fn GetPipelineKeyKHR(&self, device: VkDevice, pPipelineCreateInfo: *const VkPipelineCreateInfoKHR, pPipelineKey: *mut VkPipelineBinaryKeyKHR) -> VkResult {
                    unsafe { (self.vkGetPipelineKeyKHR.expect("Unable to load vkGetPipelineKeyKHR"))(device, pPipelineCreateInfo, pPipelineKey) }
                }
                /// `vkReleaseCapturedPipelineDataKHR`
                pub unsafe fn ReleaseCapturedPipelineDataKHR(&self, device: VkDevice, pInfo: *const VkReleaseCapturedPipelineDataInfoKHR, pAllocator: *const VkAllocationCallbacks) -> VkResult {
                    unsafe { (self.vkReleaseCapturedPipelineDataKHR.expect("Unable to load vkReleaseCapturedPipelineDataKHR"))(device, pInfo, pAllocator) }
                }
            }
        }

        /// `VK_KHR_surface_maintenance1`
        pub mod surface_maintenance1 {
            use super::*;

            /// `VK_KHR_surface_maintenance1`
            pub const NAME: &'static CStr = c!("VK_KHR_surface_maintenance1");
        }

        /// `VK_KHR_swapchain_maintenance1`
        pub mod swapchain_maintenance1 {
            use super::*;

            /// `VK_KHR_swapchain_maintenance1`
            pub const NAME: &'static CStr = c!("VK_KHR_swapchain_maintenance1");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkReleaseSwapchainImagesKHR: PFN_vkReleaseSwapchainImagesKHR,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkReleaseSwapchainImagesKHR: get(c!("vkReleaseSwapchainImagesKHR")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkReleaseSwapchainImagesKHR`
                pub unsafe fn ReleaseSwapchainImagesKHR(&self, device: VkDevice, pReleaseInfo: *const VkReleaseSwapchainImagesInfoKHR) -> VkResult {
                    unsafe { (self.vkReleaseSwapchainImagesKHR.expect("Unable to load vkReleaseSwapchainImagesKHR"))(device, pReleaseInfo) }
                }
            }
        }

        /// `VK_KHR_internally_synchronized_queues`
        pub mod internally_synchronized_queues {
            use super::*;

            /// `VK_KHR_internally_synchronized_queues`
            pub const NAME: &'static CStr = c!("VK_KHR_internally_synchronized_queues");
        }

        /// `VK_KHR_cooperative_matrix`
        pub mod cooperative_matrix {
            use super::*;

            /// `VK_KHR_cooperative_matrix`
            pub const NAME: &'static CStr = c!("VK_KHR_cooperative_matrix");

            /// InstanceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct InstanceCommands {
                pub vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR: PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR,
            }

            impl InstanceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR: get(c!("vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR")).map(|a| a.cast()),
                    } }
                }
            }

            impl InstanceCommands {
                /// `vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR`
                pub unsafe fn GetPhysicalDeviceCooperativeMatrixPropertiesKHR(&self, physicalDevice: VkPhysicalDevice, pPropertyCount: *mut uint32_t, pProperties: *mut VkCooperativeMatrixPropertiesKHR) -> VkResult {
                    unsafe { (self.vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR.expect("Unable to load vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR"))(physicalDevice, pPropertyCount, pProperties) }
                }
            }
        }

        /// `VK_KHR_compute_shader_derivatives`
        pub mod compute_shader_derivatives {
            use super::*;

            /// `VK_KHR_compute_shader_derivatives`
            pub const NAME: &'static CStr = c!("VK_KHR_compute_shader_derivatives");
        }

        /// `VK_KHR_video_decode_av1`
        pub mod video_decode_av1 {
            use super::*;

            /// `VK_KHR_video_decode_av1`
            pub const NAME: &'static CStr = c!("VK_KHR_video_decode_av1");
        }

        /// `VK_KHR_video_encode_av1`
        pub mod video_encode_av1 {
            use super::*;

            /// `VK_KHR_video_encode_av1`
            pub const NAME: &'static CStr = c!("VK_KHR_video_encode_av1");
        }

        /// `VK_KHR_video_decode_vp9`
        pub mod video_decode_vp9 {
            use super::*;

            /// `VK_KHR_video_decode_vp9`
            pub const NAME: &'static CStr = c!("VK_KHR_video_decode_vp9");
        }

        /// `VK_KHR_video_maintenance1`
        pub mod video_maintenance1 {
            use super::*;

            /// `VK_KHR_video_maintenance1`
            pub const NAME: &'static CStr = c!("VK_KHR_video_maintenance1");
        }

        /// `VK_KHR_vertex_attribute_divisor`
        pub mod vertex_attribute_divisor {
            use super::*;

            /// `VK_KHR_vertex_attribute_divisor`
            pub const NAME: &'static CStr = c!("VK_KHR_vertex_attribute_divisor");
        }

        /// `VK_KHR_load_store_op_none`
        pub mod load_store_op_none {
            use super::*;

            /// `VK_KHR_load_store_op_none`
            pub const NAME: &'static CStr = c!("VK_KHR_load_store_op_none");
        }

        /// `VK_KHR_unified_image_layouts`
        pub mod unified_image_layouts {
            use super::*;

            /// `VK_KHR_unified_image_layouts`
            pub const NAME: &'static CStr = c!("VK_KHR_unified_image_layouts");
        }

        /// `VK_KHR_shader_float_controls2`
        pub mod shader_float_controls2 {
            use super::*;

            /// `VK_KHR_shader_float_controls2`
            pub const NAME: &'static CStr = c!("VK_KHR_shader_float_controls2");
        }

        /// `VK_KHR_index_type_uint8`
        pub mod index_type_uint8 {
            use super::*;

            /// `VK_KHR_index_type_uint8`
            pub const NAME: &'static CStr = c!("VK_KHR_index_type_uint8");
        }

        /// `VK_KHR_line_rasterization`
        pub mod line_rasterization {
            use super::*;

            /// `VK_KHR_line_rasterization`
            pub const NAME: &'static CStr = c!("VK_KHR_line_rasterization");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkCmdSetLineStippleKHR: PFN_vkCmdSetLineStippleKHR,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkCmdSetLineStippleKHR: get(c!("vkCmdSetLineStippleKHR")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkCmdSetLineStippleKHR`
                pub unsafe fn CmdSetLineStippleKHR(&self, commandBuffer: VkCommandBuffer, lineStippleFactor: uint32_t, lineStipplePattern: uint16_t) -> () {
                    unsafe { (self.vkCmdSetLineStippleKHR.expect("Unable to load vkCmdSetLineStippleKHR"))(commandBuffer, lineStippleFactor, lineStipplePattern) }
                }
            }
        }

        /// `VK_KHR_calibrated_timestamps`
        pub mod calibrated_timestamps {
            use super::*;

            /// `VK_KHR_calibrated_timestamps`
            pub const NAME: &'static CStr = c!("VK_KHR_calibrated_timestamps");

            /// InstanceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct InstanceCommands {
                pub vkGetPhysicalDeviceCalibrateableTimeDomainsKHR: PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR,
            }

            impl InstanceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkGetPhysicalDeviceCalibrateableTimeDomainsKHR: get(c!("vkGetPhysicalDeviceCalibrateableTimeDomainsKHR")).map(|a| a.cast()),
                    } }
                }
            }

            impl InstanceCommands {
                /// `vkGetPhysicalDeviceCalibrateableTimeDomainsKHR`
                pub unsafe fn GetPhysicalDeviceCalibrateableTimeDomainsKHR(&self, physicalDevice: VkPhysicalDevice, pTimeDomainCount: *mut uint32_t, pTimeDomains: *mut VkTimeDomainKHR) -> VkResult {
                    unsafe { (self.vkGetPhysicalDeviceCalibrateableTimeDomainsKHR.expect("Unable to load vkGetPhysicalDeviceCalibrateableTimeDomainsKHR"))(physicalDevice, pTimeDomainCount, pTimeDomains) }
                }
            }

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkGetCalibratedTimestampsKHR: PFN_vkGetCalibratedTimestampsKHR,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkGetCalibratedTimestampsKHR: get(c!("vkGetCalibratedTimestampsKHR")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkGetCalibratedTimestampsKHR`
                pub unsafe fn GetCalibratedTimestampsKHR(&self, device: VkDevice, timestampCount: uint32_t, pTimestampInfos: *const VkCalibratedTimestampInfoKHR, pTimestamps: *mut uint64_t, pMaxDeviation: *mut uint64_t) -> VkResult {
                    unsafe { (self.vkGetCalibratedTimestampsKHR.expect("Unable to load vkGetCalibratedTimestampsKHR"))(device, timestampCount, pTimestampInfos, pTimestamps, pMaxDeviation) }
                }
            }
        }

        /// `VK_KHR_shader_expect_assume`
        pub mod shader_expect_assume {
            use super::*;

            /// `VK_KHR_shader_expect_assume`
            pub const NAME: &'static CStr = c!("VK_KHR_shader_expect_assume");
        }

        /// `VK_KHR_maintenance6`
        pub mod maintenance6 {
            use super::*;

            /// `VK_KHR_maintenance6`
            pub const NAME: &'static CStr = c!("VK_KHR_maintenance6");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkCmdBindDescriptorBufferEmbeddedSamplers2EXT: PFN_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT,
                pub vkCmdBindDescriptorSets2KHR: PFN_vkCmdBindDescriptorSets2KHR,
                pub vkCmdPushConstants2KHR: PFN_vkCmdPushConstants2KHR,
                pub vkCmdPushDescriptorSet2KHR: PFN_vkCmdPushDescriptorSet2KHR,
                pub vkCmdPushDescriptorSetWithTemplate2KHR: PFN_vkCmdPushDescriptorSetWithTemplate2KHR,
                pub vkCmdSetDescriptorBufferOffsets2EXT: PFN_vkCmdSetDescriptorBufferOffsets2EXT,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkCmdBindDescriptorBufferEmbeddedSamplers2EXT: get(c!("vkCmdBindDescriptorBufferEmbeddedSamplers2EXT")).map(|a| a.cast()),
                        vkCmdBindDescriptorSets2KHR: get(c!("vkCmdBindDescriptorSets2KHR")).map(|a| a.cast()),
                        vkCmdPushConstants2KHR: get(c!("vkCmdPushConstants2KHR")).map(|a| a.cast()),
                        vkCmdPushDescriptorSet2KHR: get(c!("vkCmdPushDescriptorSet2KHR")).map(|a| a.cast()),
                        vkCmdPushDescriptorSetWithTemplate2KHR: get(c!("vkCmdPushDescriptorSetWithTemplate2KHR")).map(|a| a.cast()),
                        vkCmdSetDescriptorBufferOffsets2EXT: get(c!("vkCmdSetDescriptorBufferOffsets2EXT")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkCmdBindDescriptorBufferEmbeddedSamplers2EXT`
                pub unsafe fn CmdBindDescriptorBufferEmbeddedSamplers2EXT(&self, commandBuffer: VkCommandBuffer, pBindDescriptorBufferEmbeddedSamplersInfo: *const VkBindDescriptorBufferEmbeddedSamplersInfoEXT) -> () {
                    unsafe { (self.vkCmdBindDescriptorBufferEmbeddedSamplers2EXT.expect("Unable to load vkCmdBindDescriptorBufferEmbeddedSamplers2EXT"))(commandBuffer, pBindDescriptorBufferEmbeddedSamplersInfo) }
                }
                /// `vkCmdBindDescriptorSets2KHR`
                pub unsafe fn CmdBindDescriptorSets2KHR(&self, commandBuffer: VkCommandBuffer, pBindDescriptorSetsInfo: *const VkBindDescriptorSetsInfo) -> () {
                    unsafe { (self.vkCmdBindDescriptorSets2KHR.expect("Unable to load vkCmdBindDescriptorSets2KHR"))(commandBuffer, pBindDescriptorSetsInfo) }
                }
                /// `vkCmdPushConstants2KHR`
                pub unsafe fn CmdPushConstants2KHR(&self, commandBuffer: VkCommandBuffer, pPushConstantsInfo: *const VkPushConstantsInfo) -> () {
                    unsafe { (self.vkCmdPushConstants2KHR.expect("Unable to load vkCmdPushConstants2KHR"))(commandBuffer, pPushConstantsInfo) }
                }
                /// `vkCmdPushDescriptorSet2KHR`
                pub unsafe fn CmdPushDescriptorSet2KHR(&self, commandBuffer: VkCommandBuffer, pPushDescriptorSetInfo: *const VkPushDescriptorSetInfo) -> () {
                    unsafe { (self.vkCmdPushDescriptorSet2KHR.expect("Unable to load vkCmdPushDescriptorSet2KHR"))(commandBuffer, pPushDescriptorSetInfo) }
                }
                /// `vkCmdPushDescriptorSetWithTemplate2KHR`
                pub unsafe fn CmdPushDescriptorSetWithTemplate2KHR(&self, commandBuffer: VkCommandBuffer, pPushDescriptorSetWithTemplateInfo: *const VkPushDescriptorSetWithTemplateInfo) -> () {
                    unsafe { (self.vkCmdPushDescriptorSetWithTemplate2KHR.expect("Unable to load vkCmdPushDescriptorSetWithTemplate2KHR"))(commandBuffer, pPushDescriptorSetWithTemplateInfo) }
                }
                /// `vkCmdSetDescriptorBufferOffsets2EXT`
                pub unsafe fn CmdSetDescriptorBufferOffsets2EXT(&self, commandBuffer: VkCommandBuffer, pSetDescriptorBufferOffsetsInfo: *const VkSetDescriptorBufferOffsetsInfoEXT) -> () {
                    unsafe { (self.vkCmdSetDescriptorBufferOffsets2EXT.expect("Unable to load vkCmdSetDescriptorBufferOffsets2EXT"))(commandBuffer, pSetDescriptorBufferOffsetsInfo) }
                }
            }
        }

        /// `VK_KHR_copy_memory_indirect`
        pub mod copy_memory_indirect {
            use super::*;

            /// `VK_KHR_copy_memory_indirect`
            pub const NAME: &'static CStr = c!("VK_KHR_copy_memory_indirect");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkCmdCopyMemoryIndirectKHR: PFN_vkCmdCopyMemoryIndirectKHR,
                pub vkCmdCopyMemoryToImageIndirectKHR: PFN_vkCmdCopyMemoryToImageIndirectKHR,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkCmdCopyMemoryIndirectKHR: get(c!("vkCmdCopyMemoryIndirectKHR")).map(|a| a.cast()),
                        vkCmdCopyMemoryToImageIndirectKHR: get(c!("vkCmdCopyMemoryToImageIndirectKHR")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkCmdCopyMemoryIndirectKHR`
                pub unsafe fn CmdCopyMemoryIndirectKHR(&self, commandBuffer: VkCommandBuffer, pCopyMemoryIndirectInfo: *const VkCopyMemoryIndirectInfoKHR) -> () {
                    unsafe { (self.vkCmdCopyMemoryIndirectKHR.expect("Unable to load vkCmdCopyMemoryIndirectKHR"))(commandBuffer, pCopyMemoryIndirectInfo) }
                }
                /// `vkCmdCopyMemoryToImageIndirectKHR`
                pub unsafe fn CmdCopyMemoryToImageIndirectKHR(&self, commandBuffer: VkCommandBuffer, pCopyMemoryToImageIndirectInfo: *const VkCopyMemoryToImageIndirectInfoKHR) -> () {
                    unsafe { (self.vkCmdCopyMemoryToImageIndirectKHR.expect("Unable to load vkCmdCopyMemoryToImageIndirectKHR"))(commandBuffer, pCopyMemoryToImageIndirectInfo) }
                }
            }
        }

        /// `VK_KHR_video_encode_intra_refresh`
        pub mod video_encode_intra_refresh {
            use super::*;

            /// `VK_KHR_video_encode_intra_refresh`
            pub const NAME: &'static CStr = c!("VK_KHR_video_encode_intra_refresh");
        }

        /// `VK_KHR_video_encode_quantization_map`
        pub mod video_encode_quantization_map {
            use super::*;

            /// `VK_KHR_video_encode_quantization_map`
            pub const NAME: &'static CStr = c!("VK_KHR_video_encode_quantization_map");
        }

        /// `VK_KHR_shader_relaxed_extended_instruction`
        pub mod shader_relaxed_extended_instruction {
            use super::*;

            /// `VK_KHR_shader_relaxed_extended_instruction`
            pub const NAME: &'static CStr = c!("VK_KHR_shader_relaxed_extended_instruction");
        }

        /// `VK_KHR_maintenance7`
        pub mod maintenance7 {
            use super::*;

            /// `VK_KHR_maintenance7`
            pub const NAME: &'static CStr = c!("VK_KHR_maintenance7");
        }

        /// `VK_KHR_maintenance8`
        pub mod maintenance8 {
            use super::*;

            /// `VK_KHR_maintenance8`
            pub const NAME: &'static CStr = c!("VK_KHR_maintenance8");
        }

        /// `VK_KHR_shader_fma`
        pub mod shader_fma {
            use super::*;

            /// `VK_KHR_shader_fma`
            pub const NAME: &'static CStr = c!("VK_KHR_shader_fma");
        }

        /// `VK_KHR_maintenance9`
        pub mod maintenance9 {
            use super::*;

            /// `VK_KHR_maintenance9`
            pub const NAME: &'static CStr = c!("VK_KHR_maintenance9");
        }

        /// `VK_KHR_video_maintenance2`
        pub mod video_maintenance2 {
            use super::*;

            /// `VK_KHR_video_maintenance2`
            pub const NAME: &'static CStr = c!("VK_KHR_video_maintenance2");
        }

        /// `VK_KHR_depth_clamp_zero_one`
        pub mod depth_clamp_zero_one {
            use super::*;

            /// `VK_KHR_depth_clamp_zero_one`
            pub const NAME: &'static CStr = c!("VK_KHR_depth_clamp_zero_one");
        }

        /// `VK_KHR_robustness2`
        pub mod robustness2 {
            use super::*;

            /// `VK_KHR_robustness2`
            pub const NAME: &'static CStr = c!("VK_KHR_robustness2");
        }

        /// `VK_KHR_present_mode_fifo_latest_ready`
        pub mod present_mode_fifo_latest_ready {
            use super::*;

            /// `VK_KHR_present_mode_fifo_latest_ready`
            pub const NAME: &'static CStr = c!("VK_KHR_present_mode_fifo_latest_ready");
        }

        /// `VK_KHR_maintenance10`
        pub mod maintenance10 {
            use super::*;

            /// `VK_KHR_maintenance10`
            pub const NAME: &'static CStr = c!("VK_KHR_maintenance10");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkCmdEndRendering2KHR: PFN_vkCmdEndRendering2KHR,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkCmdEndRendering2KHR: get(c!("vkCmdEndRendering2KHR")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkCmdEndRendering2KHR`
                pub unsafe fn CmdEndRendering2KHR(&self, commandBuffer: VkCommandBuffer, pRenderingEndInfo: *const VkRenderingEndInfoKHR) -> () {
                    unsafe { (self.vkCmdEndRendering2KHR.expect("Unable to load vkCmdEndRendering2KHR"))(commandBuffer, pRenderingEndInfo) }
                }
            }
        }
    }
    /// `LUNARG` prefix extensions
    pub mod lunarg {
        use core::ffi::CStr;
        use crate::loader::*;
        use crate::ffi::*;
        use crate::*;

        /// `VK_LUNARG_direct_driver_loading`
        pub mod direct_driver_loading {
            use super::*;

            /// `VK_LUNARG_direct_driver_loading`
            pub const NAME: &'static CStr = c!("VK_LUNARG_direct_driver_loading");
        }
    }
    /// `MESA` prefix extensions
    pub mod mesa {
        use core::ffi::CStr;
        use crate::loader::*;
        use crate::ffi::*;
        use crate::*;

        /// `VK_MESA_image_alignment_control`
        pub mod image_alignment_control {
            use super::*;

            /// `VK_MESA_image_alignment_control`
            pub const NAME: &'static CStr = c!("VK_MESA_image_alignment_control");
        }
    }
    /// `MSFT` prefix extensions
    pub mod msft {
        use core::ffi::CStr;
        use crate::loader::*;
        use crate::ffi::*;
        use crate::*;

        /// `VK_MSFT_layered_driver`
        pub mod layered_driver {
            use super::*;

            /// `VK_MSFT_layered_driver`
            pub const NAME: &'static CStr = c!("VK_MSFT_layered_driver");
        }
    }
    /// `MVK` prefix extensions
    pub mod mvk {
        use core::ffi::CStr;
        use crate::loader::*;
        use crate::ffi::*;
        use crate::*;

        /// `VK_MVK_ios_surface`
        pub mod ios_surface {
            use super::*;

            /// `VK_MVK_ios_surface`
            pub const NAME: &'static CStr = c!("VK_MVK_ios_surface");

            /// InstanceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct InstanceCommands {
                pub vkCreateIOSSurfaceMVK: PFN_vkCreateIOSSurfaceMVK,
            }

            impl InstanceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkCreateIOSSurfaceMVK: get(c!("vkCreateIOSSurfaceMVK")).map(|a| a.cast()),
                    } }
                }
            }

            impl InstanceCommands {
                /// `vkCreateIOSSurfaceMVK`
                pub unsafe fn CreateIOSSurfaceMVK(&self, instance: VkInstance, pCreateInfo: *const VkIOSSurfaceCreateInfoMVK, pAllocator: *const VkAllocationCallbacks, pSurface: *mut VkSurfaceKHR) -> VkResult {
                    unsafe { (self.vkCreateIOSSurfaceMVK.expect("Unable to load vkCreateIOSSurfaceMVK"))(instance, pCreateInfo, pAllocator, pSurface) }
                }
            }
        }

        /// `VK_MVK_macos_surface`
        pub mod macos_surface {
            use super::*;

            /// `VK_MVK_macos_surface`
            pub const NAME: &'static CStr = c!("VK_MVK_macos_surface");

            /// InstanceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct InstanceCommands {
                pub vkCreateMacOSSurfaceMVK: PFN_vkCreateMacOSSurfaceMVK,
            }

            impl InstanceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkCreateMacOSSurfaceMVK: get(c!("vkCreateMacOSSurfaceMVK")).map(|a| a.cast()),
                    } }
                }
            }

            impl InstanceCommands {
                /// `vkCreateMacOSSurfaceMVK`
                pub unsafe fn CreateMacOSSurfaceMVK(&self, instance: VkInstance, pCreateInfo: *const VkMacOSSurfaceCreateInfoMVK, pAllocator: *const VkAllocationCallbacks, pSurface: *mut VkSurfaceKHR) -> VkResult {
                    unsafe { (self.vkCreateMacOSSurfaceMVK.expect("Unable to load vkCreateMacOSSurfaceMVK"))(instance, pCreateInfo, pAllocator, pSurface) }
                }
            }
        }
    }
    /// `NN` prefix extensions
    pub mod nn {
        use core::ffi::CStr;
        use crate::loader::*;
        use crate::ffi::*;
        use crate::*;

        /// `VK_NN_vi_surface`
        pub mod vi_surface {
            use super::*;

            /// `VK_NN_vi_surface`
            pub const NAME: &'static CStr = c!("VK_NN_vi_surface");

            /// InstanceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct InstanceCommands {
                pub vkCreateViSurfaceNN: PFN_vkCreateViSurfaceNN,
            }

            impl InstanceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkCreateViSurfaceNN: get(c!("vkCreateViSurfaceNN")).map(|a| a.cast()),
                    } }
                }
            }

            impl InstanceCommands {
                /// `vkCreateViSurfaceNN`
                pub unsafe fn CreateViSurfaceNN(&self, instance: VkInstance, pCreateInfo: *const VkViSurfaceCreateInfoNN, pAllocator: *const VkAllocationCallbacks, pSurface: *mut VkSurfaceKHR) -> VkResult {
                    unsafe { (self.vkCreateViSurfaceNN.expect("Unable to load vkCreateViSurfaceNN"))(instance, pCreateInfo, pAllocator, pSurface) }
                }
            }
        }
    }
    /// `NV` prefix extensions
    pub mod nv {
        use core::ffi::CStr;
        use crate::loader::*;
        use crate::ffi::*;
        use crate::*;

        /// `VK_NV_glsl_shader`
        pub mod glsl_shader {
            use super::*;

            /// `VK_NV_glsl_shader`
            pub const NAME: &'static CStr = c!("VK_NV_glsl_shader");
        }

        /// `VK_NV_dedicated_allocation`
        pub mod dedicated_allocation {
            use super::*;

            /// `VK_NV_dedicated_allocation`
            pub const NAME: &'static CStr = c!("VK_NV_dedicated_allocation");
        }

        /// `VK_NV_corner_sampled_image`
        pub mod corner_sampled_image {
            use super::*;

            /// `VK_NV_corner_sampled_image`
            pub const NAME: &'static CStr = c!("VK_NV_corner_sampled_image");
        }

        /// `VK_NV_private_vendor_info`
        pub mod private_vendor_info {
            use super::*;

            /// `VK_NV_private_vendor_info`
            pub const NAME: &'static CStr = c!("VK_NV_private_vendor_info");
        }

        /// `VK_NV_external_memory_capabilities`
        pub mod external_memory_capabilities {
            use super::*;

            /// `VK_NV_external_memory_capabilities`
            pub const NAME: &'static CStr = c!("VK_NV_external_memory_capabilities");

            /// InstanceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct InstanceCommands {
                pub vkGetPhysicalDeviceExternalImageFormatPropertiesNV: PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV,
            }

            impl InstanceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkGetPhysicalDeviceExternalImageFormatPropertiesNV: get(c!("vkGetPhysicalDeviceExternalImageFormatPropertiesNV")).map(|a| a.cast()),
                    } }
                }
            }

            impl InstanceCommands {
                /// `vkGetPhysicalDeviceExternalImageFormatPropertiesNV`
                pub unsafe fn GetPhysicalDeviceExternalImageFormatPropertiesNV(&self, physicalDevice: VkPhysicalDevice, format: VkFormat, r#type: VkImageType, tiling: VkImageTiling, usage: VkImageUsageFlags, flags: VkImageCreateFlags, externalHandleType: VkExternalMemoryHandleTypeFlagsNV, pExternalImageFormatProperties: *mut VkExternalImageFormatPropertiesNV) -> VkResult {
                    unsafe { (self.vkGetPhysicalDeviceExternalImageFormatPropertiesNV.expect("Unable to load vkGetPhysicalDeviceExternalImageFormatPropertiesNV"))(physicalDevice, format, r#type, tiling, usage, flags, externalHandleType, pExternalImageFormatProperties) }
                }
            }
        }

        /// `VK_NV_external_memory`
        pub mod external_memory {
            use super::*;

            /// `VK_NV_external_memory`
            pub const NAME: &'static CStr = c!("VK_NV_external_memory");
        }

        /// `VK_NV_external_memory_win32`
        pub mod external_memory_win32 {
            use super::*;

            /// `VK_NV_external_memory_win32`
            pub const NAME: &'static CStr = c!("VK_NV_external_memory_win32");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkGetMemoryWin32HandleNV: PFN_vkGetMemoryWin32HandleNV,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkGetMemoryWin32HandleNV: get(c!("vkGetMemoryWin32HandleNV")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkGetMemoryWin32HandleNV`
                pub unsafe fn GetMemoryWin32HandleNV(&self, device: VkDevice, memory: VkDeviceMemory, handleType: VkExternalMemoryHandleTypeFlagsNV, pHandle: *mut HANDLE) -> VkResult {
                    unsafe { (self.vkGetMemoryWin32HandleNV.expect("Unable to load vkGetMemoryWin32HandleNV"))(device, memory, handleType, pHandle) }
                }
            }
        }

        /// `VK_NV_win32_keyed_mutex`
        pub mod win32_keyed_mutex {
            use super::*;

            /// `VK_NV_win32_keyed_mutex`
            pub const NAME: &'static CStr = c!("VK_NV_win32_keyed_mutex");
        }

        /// `VK_NV_clip_space_w_scaling`
        pub mod clip_space_w_scaling {
            use super::*;

            /// `VK_NV_clip_space_w_scaling`
            pub const NAME: &'static CStr = c!("VK_NV_clip_space_w_scaling");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkCmdSetViewportWScalingNV: PFN_vkCmdSetViewportWScalingNV,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkCmdSetViewportWScalingNV: get(c!("vkCmdSetViewportWScalingNV")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkCmdSetViewportWScalingNV`
                pub unsafe fn CmdSetViewportWScalingNV(&self, commandBuffer: VkCommandBuffer, firstViewport: uint32_t, viewportCount: uint32_t, pViewportWScalings: *const VkViewportWScalingNV) -> () {
                    unsafe { (self.vkCmdSetViewportWScalingNV.expect("Unable to load vkCmdSetViewportWScalingNV"))(commandBuffer, firstViewport, viewportCount, pViewportWScalings) }
                }
            }
        }

        /// `VK_NV_sample_mask_override_coverage`
        pub mod sample_mask_override_coverage {
            use super::*;

            /// `VK_NV_sample_mask_override_coverage`
            pub const NAME: &'static CStr = c!("VK_NV_sample_mask_override_coverage");
        }

        /// `VK_NV_geometry_shader_passthrough`
        pub mod geometry_shader_passthrough {
            use super::*;

            /// `VK_NV_geometry_shader_passthrough`
            pub const NAME: &'static CStr = c!("VK_NV_geometry_shader_passthrough");
        }

        /// `VK_NV_viewport_array2`
        pub mod viewport_array2 {
            use super::*;

            /// `VK_NV_viewport_array2`
            pub const NAME: &'static CStr = c!("VK_NV_viewport_array2");
        }

        /// `VK_NV_viewport_swizzle`
        pub mod viewport_swizzle {
            use super::*;

            /// `VK_NV_viewport_swizzle`
            pub const NAME: &'static CStr = c!("VK_NV_viewport_swizzle");
        }

        /// `VK_NV_fragment_coverage_to_color`
        pub mod fragment_coverage_to_color {
            use super::*;

            /// `VK_NV_fragment_coverage_to_color`
            pub const NAME: &'static CStr = c!("VK_NV_fragment_coverage_to_color");
        }

        /// `VK_NV_framebuffer_mixed_samples`
        pub mod framebuffer_mixed_samples {
            use super::*;

            /// `VK_NV_framebuffer_mixed_samples`
            pub const NAME: &'static CStr = c!("VK_NV_framebuffer_mixed_samples");
        }

        /// `VK_NV_fill_rectangle`
        pub mod fill_rectangle {
            use super::*;

            /// `VK_NV_fill_rectangle`
            pub const NAME: &'static CStr = c!("VK_NV_fill_rectangle");
        }

        /// `VK_NV_shader_sm_builtins`
        pub mod shader_sm_builtins {
            use super::*;

            /// `VK_NV_shader_sm_builtins`
            pub const NAME: &'static CStr = c!("VK_NV_shader_sm_builtins");
        }

        /// `VK_NV_shading_rate_image`
        pub mod shading_rate_image {
            use super::*;

            /// `VK_NV_shading_rate_image`
            pub const NAME: &'static CStr = c!("VK_NV_shading_rate_image");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkCmdBindShadingRateImageNV: PFN_vkCmdBindShadingRateImageNV,
                pub vkCmdSetCoarseSampleOrderNV: PFN_vkCmdSetCoarseSampleOrderNV,
                pub vkCmdSetViewportShadingRatePaletteNV: PFN_vkCmdSetViewportShadingRatePaletteNV,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkCmdBindShadingRateImageNV: get(c!("vkCmdBindShadingRateImageNV")).map(|a| a.cast()),
                        vkCmdSetCoarseSampleOrderNV: get(c!("vkCmdSetCoarseSampleOrderNV")).map(|a| a.cast()),
                        vkCmdSetViewportShadingRatePaletteNV: get(c!("vkCmdSetViewportShadingRatePaletteNV")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkCmdBindShadingRateImageNV`
                pub unsafe fn CmdBindShadingRateImageNV(&self, commandBuffer: VkCommandBuffer, imageView: VkImageView, imageLayout: VkImageLayout) -> () {
                    unsafe { (self.vkCmdBindShadingRateImageNV.expect("Unable to load vkCmdBindShadingRateImageNV"))(commandBuffer, imageView, imageLayout) }
                }
                /// `vkCmdSetCoarseSampleOrderNV`
                pub unsafe fn CmdSetCoarseSampleOrderNV(&self, commandBuffer: VkCommandBuffer, sampleOrderType: VkCoarseSampleOrderTypeNV, customSampleOrderCount: uint32_t, pCustomSampleOrders: *const VkCoarseSampleOrderCustomNV) -> () {
                    unsafe { (self.vkCmdSetCoarseSampleOrderNV.expect("Unable to load vkCmdSetCoarseSampleOrderNV"))(commandBuffer, sampleOrderType, customSampleOrderCount, pCustomSampleOrders) }
                }
                /// `vkCmdSetViewportShadingRatePaletteNV`
                pub unsafe fn CmdSetViewportShadingRatePaletteNV(&self, commandBuffer: VkCommandBuffer, firstViewport: uint32_t, viewportCount: uint32_t, pShadingRatePalettes: *const VkShadingRatePaletteNV) -> () {
                    unsafe { (self.vkCmdSetViewportShadingRatePaletteNV.expect("Unable to load vkCmdSetViewportShadingRatePaletteNV"))(commandBuffer, firstViewport, viewportCount, pShadingRatePalettes) }
                }
            }
        }

        /// `VK_NV_ray_tracing`
        pub mod ray_tracing {
            use super::*;

            /// `VK_NV_ray_tracing`
            pub const NAME: &'static CStr = c!("VK_NV_ray_tracing");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkBindAccelerationStructureMemoryNV: PFN_vkBindAccelerationStructureMemoryNV,
                pub vkCmdBuildAccelerationStructureNV: PFN_vkCmdBuildAccelerationStructureNV,
                pub vkCmdCopyAccelerationStructureNV: PFN_vkCmdCopyAccelerationStructureNV,
                pub vkCmdTraceRaysNV: PFN_vkCmdTraceRaysNV,
                pub vkCmdWriteAccelerationStructuresPropertiesNV: PFN_vkCmdWriteAccelerationStructuresPropertiesNV,
                pub vkCompileDeferredNV: PFN_vkCompileDeferredNV,
                pub vkCreateAccelerationStructureNV: PFN_vkCreateAccelerationStructureNV,
                pub vkCreateRayTracingPipelinesNV: PFN_vkCreateRayTracingPipelinesNV,
                pub vkDestroyAccelerationStructureNV: PFN_vkDestroyAccelerationStructureNV,
                pub vkGetAccelerationStructureHandleNV: PFN_vkGetAccelerationStructureHandleNV,
                pub vkGetAccelerationStructureMemoryRequirementsNV: PFN_vkGetAccelerationStructureMemoryRequirementsNV,
                pub vkGetRayTracingShaderGroupHandlesNV: PFN_vkGetRayTracingShaderGroupHandlesNV,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkBindAccelerationStructureMemoryNV: get(c!("vkBindAccelerationStructureMemoryNV")).map(|a| a.cast()),
                        vkCmdBuildAccelerationStructureNV: get(c!("vkCmdBuildAccelerationStructureNV")).map(|a| a.cast()),
                        vkCmdCopyAccelerationStructureNV: get(c!("vkCmdCopyAccelerationStructureNV")).map(|a| a.cast()),
                        vkCmdTraceRaysNV: get(c!("vkCmdTraceRaysNV")).map(|a| a.cast()),
                        vkCmdWriteAccelerationStructuresPropertiesNV: get(c!("vkCmdWriteAccelerationStructuresPropertiesNV")).map(|a| a.cast()),
                        vkCompileDeferredNV: get(c!("vkCompileDeferredNV")).map(|a| a.cast()),
                        vkCreateAccelerationStructureNV: get(c!("vkCreateAccelerationStructureNV")).map(|a| a.cast()),
                        vkCreateRayTracingPipelinesNV: get(c!("vkCreateRayTracingPipelinesNV")).map(|a| a.cast()),
                        vkDestroyAccelerationStructureNV: get(c!("vkDestroyAccelerationStructureNV")).map(|a| a.cast()),
                        vkGetAccelerationStructureHandleNV: get(c!("vkGetAccelerationStructureHandleNV")).map(|a| a.cast()),
                        vkGetAccelerationStructureMemoryRequirementsNV: get(c!("vkGetAccelerationStructureMemoryRequirementsNV")).map(|a| a.cast()),
                        vkGetRayTracingShaderGroupHandlesNV: get(c!("vkGetRayTracingShaderGroupHandlesNV")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkBindAccelerationStructureMemoryNV`
                pub unsafe fn BindAccelerationStructureMemoryNV(&self, device: VkDevice, bindInfoCount: uint32_t, pBindInfos: *const VkBindAccelerationStructureMemoryInfoNV) -> VkResult {
                    unsafe { (self.vkBindAccelerationStructureMemoryNV.expect("Unable to load vkBindAccelerationStructureMemoryNV"))(device, bindInfoCount, pBindInfos) }
                }
                /// `vkCmdBuildAccelerationStructureNV`
                pub unsafe fn CmdBuildAccelerationStructureNV(&self, commandBuffer: VkCommandBuffer, pInfo: *const VkAccelerationStructureInfoNV, instanceData: VkBuffer, instanceOffset: VkDeviceSize, update: VkBool32, dst: VkAccelerationStructureNV, src: VkAccelerationStructureNV, scratch: VkBuffer, scratchOffset: VkDeviceSize) -> () {
                    unsafe { (self.vkCmdBuildAccelerationStructureNV.expect("Unable to load vkCmdBuildAccelerationStructureNV"))(commandBuffer, pInfo, instanceData, instanceOffset, update, dst, src, scratch, scratchOffset) }
                }
                /// `vkCmdCopyAccelerationStructureNV`
                pub unsafe fn CmdCopyAccelerationStructureNV(&self, commandBuffer: VkCommandBuffer, dst: VkAccelerationStructureNV, src: VkAccelerationStructureNV, mode: VkCopyAccelerationStructureModeKHR) -> () {
                    unsafe { (self.vkCmdCopyAccelerationStructureNV.expect("Unable to load vkCmdCopyAccelerationStructureNV"))(commandBuffer, dst, src, mode) }
                }
                /// `vkCmdTraceRaysNV`
                pub unsafe fn CmdTraceRaysNV(&self, commandBuffer: VkCommandBuffer, raygenShaderBindingTableBuffer: VkBuffer, raygenShaderBindingOffset: VkDeviceSize, missShaderBindingTableBuffer: VkBuffer, missShaderBindingOffset: VkDeviceSize, missShaderBindingStride: VkDeviceSize, hitShaderBindingTableBuffer: VkBuffer, hitShaderBindingOffset: VkDeviceSize, hitShaderBindingStride: VkDeviceSize, callableShaderBindingTableBuffer: VkBuffer, callableShaderBindingOffset: VkDeviceSize, callableShaderBindingStride: VkDeviceSize, width: uint32_t, height: uint32_t, depth: uint32_t) -> () {
                    unsafe { (self.vkCmdTraceRaysNV.expect("Unable to load vkCmdTraceRaysNV"))(commandBuffer, raygenShaderBindingTableBuffer, raygenShaderBindingOffset, missShaderBindingTableBuffer, missShaderBindingOffset, missShaderBindingStride, hitShaderBindingTableBuffer, hitShaderBindingOffset, hitShaderBindingStride, callableShaderBindingTableBuffer, callableShaderBindingOffset, callableShaderBindingStride, width, height, depth) }
                }
                /// `vkCmdWriteAccelerationStructuresPropertiesNV`
                pub unsafe fn CmdWriteAccelerationStructuresPropertiesNV(&self, commandBuffer: VkCommandBuffer, accelerationStructureCount: uint32_t, pAccelerationStructures: *const VkAccelerationStructureNV, queryType: VkQueryType, queryPool: VkQueryPool, firstQuery: uint32_t) -> () {
                    unsafe { (self.vkCmdWriteAccelerationStructuresPropertiesNV.expect("Unable to load vkCmdWriteAccelerationStructuresPropertiesNV"))(commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery) }
                }
                /// `vkCompileDeferredNV`
                pub unsafe fn CompileDeferredNV(&self, device: VkDevice, pipeline: VkPipeline, shader: uint32_t) -> VkResult {
                    unsafe { (self.vkCompileDeferredNV.expect("Unable to load vkCompileDeferredNV"))(device, pipeline, shader) }
                }
                /// `vkCreateAccelerationStructureNV`
                pub unsafe fn CreateAccelerationStructureNV(&self, device: VkDevice, pCreateInfo: *const VkAccelerationStructureCreateInfoNV, pAllocator: *const VkAllocationCallbacks, pAccelerationStructure: *mut VkAccelerationStructureNV) -> VkResult {
                    unsafe { (self.vkCreateAccelerationStructureNV.expect("Unable to load vkCreateAccelerationStructureNV"))(device, pCreateInfo, pAllocator, pAccelerationStructure) }
                }
                /// `vkCreateRayTracingPipelinesNV`
                pub unsafe fn CreateRayTracingPipelinesNV(&self, device: VkDevice, pipelineCache: VkPipelineCache, createInfoCount: uint32_t, pCreateInfos: *const VkRayTracingPipelineCreateInfoNV, pAllocator: *const VkAllocationCallbacks, pPipelines: *mut VkPipeline) -> VkResult {
                    unsafe { (self.vkCreateRayTracingPipelinesNV.expect("Unable to load vkCreateRayTracingPipelinesNV"))(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines) }
                }
                /// `vkDestroyAccelerationStructureNV`
                pub unsafe fn DestroyAccelerationStructureNV(&self, device: VkDevice, accelerationStructure: VkAccelerationStructureNV, pAllocator: *const VkAllocationCallbacks) -> () {
                    unsafe { (self.vkDestroyAccelerationStructureNV.expect("Unable to load vkDestroyAccelerationStructureNV"))(device, accelerationStructure, pAllocator) }
                }
                /// `vkGetAccelerationStructureHandleNV`
                pub unsafe fn GetAccelerationStructureHandleNV(&self, device: VkDevice, accelerationStructure: VkAccelerationStructureNV, dataSize: size_t, pData: *mut void) -> VkResult {
                    unsafe { (self.vkGetAccelerationStructureHandleNV.expect("Unable to load vkGetAccelerationStructureHandleNV"))(device, accelerationStructure, dataSize, pData) }
                }
                /// `vkGetAccelerationStructureMemoryRequirementsNV`
                pub unsafe fn GetAccelerationStructureMemoryRequirementsNV(&self, device: VkDevice, pInfo: *const VkAccelerationStructureMemoryRequirementsInfoNV, pMemoryRequirements: *mut VkMemoryRequirements2KHR) -> () {
                    unsafe { (self.vkGetAccelerationStructureMemoryRequirementsNV.expect("Unable to load vkGetAccelerationStructureMemoryRequirementsNV"))(device, pInfo, pMemoryRequirements) }
                }
                /// `vkGetRayTracingShaderGroupHandlesNV`
                pub unsafe fn GetRayTracingShaderGroupHandlesNV(&self, device: VkDevice, pipeline: VkPipeline, firstGroup: uint32_t, groupCount: uint32_t, dataSize: size_t, pData: *mut void) -> VkResult {
                    unsafe { (self.vkGetRayTracingShaderGroupHandlesNV.expect("Unable to load vkGetRayTracingShaderGroupHandlesNV"))(device, pipeline, firstGroup, groupCount, dataSize, pData) }
                }
            }
        }

        /// `VK_NV_representative_fragment_test`
        pub mod representative_fragment_test {
            use super::*;

            /// `VK_NV_representative_fragment_test`
            pub const NAME: &'static CStr = c!("VK_NV_representative_fragment_test");
        }

        /// `VK_NV_shader_subgroup_partitioned`
        pub mod shader_subgroup_partitioned {
            use super::*;

            /// `VK_NV_shader_subgroup_partitioned`
            pub const NAME: &'static CStr = c!("VK_NV_shader_subgroup_partitioned");
        }

        /// `VK_NV_compute_shader_derivatives`
        pub mod compute_shader_derivatives {
            use super::*;

            /// `VK_NV_compute_shader_derivatives`
            pub const NAME: &'static CStr = c!("VK_NV_compute_shader_derivatives");
        }

        /// `VK_NV_mesh_shader`
        pub mod mesh_shader {
            use super::*;

            /// `VK_NV_mesh_shader`
            pub const NAME: &'static CStr = c!("VK_NV_mesh_shader");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkCmdDrawMeshTasksIndirectCountNV: PFN_vkCmdDrawMeshTasksIndirectCountNV,
                pub vkCmdDrawMeshTasksIndirectNV: PFN_vkCmdDrawMeshTasksIndirectNV,
                pub vkCmdDrawMeshTasksNV: PFN_vkCmdDrawMeshTasksNV,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkCmdDrawMeshTasksIndirectCountNV: get(c!("vkCmdDrawMeshTasksIndirectCountNV")).map(|a| a.cast()),
                        vkCmdDrawMeshTasksIndirectNV: get(c!("vkCmdDrawMeshTasksIndirectNV")).map(|a| a.cast()),
                        vkCmdDrawMeshTasksNV: get(c!("vkCmdDrawMeshTasksNV")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkCmdDrawMeshTasksIndirectCountNV`
                pub unsafe fn CmdDrawMeshTasksIndirectCountNV(&self, commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, countBuffer: VkBuffer, countBufferOffset: VkDeviceSize, maxDrawCount: uint32_t, stride: uint32_t) -> () {
                    unsafe { (self.vkCmdDrawMeshTasksIndirectCountNV.expect("Unable to load vkCmdDrawMeshTasksIndirectCountNV"))(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride) }
                }
                /// `vkCmdDrawMeshTasksIndirectNV`
                pub unsafe fn CmdDrawMeshTasksIndirectNV(&self, commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, drawCount: uint32_t, stride: uint32_t) -> () {
                    unsafe { (self.vkCmdDrawMeshTasksIndirectNV.expect("Unable to load vkCmdDrawMeshTasksIndirectNV"))(commandBuffer, buffer, offset, drawCount, stride) }
                }
                /// `vkCmdDrawMeshTasksNV`
                pub unsafe fn CmdDrawMeshTasksNV(&self, commandBuffer: VkCommandBuffer, taskCount: uint32_t, firstTask: uint32_t) -> () {
                    unsafe { (self.vkCmdDrawMeshTasksNV.expect("Unable to load vkCmdDrawMeshTasksNV"))(commandBuffer, taskCount, firstTask) }
                }
            }
        }

        /// `VK_NV_fragment_shader_barycentric`
        pub mod fragment_shader_barycentric {
            use super::*;

            /// `VK_NV_fragment_shader_barycentric`
            pub const NAME: &'static CStr = c!("VK_NV_fragment_shader_barycentric");
        }

        /// `VK_NV_shader_image_footprint`
        pub mod shader_image_footprint {
            use super::*;

            /// `VK_NV_shader_image_footprint`
            pub const NAME: &'static CStr = c!("VK_NV_shader_image_footprint");
        }

        /// `VK_NV_scissor_exclusive`
        pub mod scissor_exclusive {
            use super::*;

            /// `VK_NV_scissor_exclusive`
            pub const NAME: &'static CStr = c!("VK_NV_scissor_exclusive");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkCmdSetExclusiveScissorEnableNV: PFN_vkCmdSetExclusiveScissorEnableNV,
                pub vkCmdSetExclusiveScissorNV: PFN_vkCmdSetExclusiveScissorNV,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkCmdSetExclusiveScissorEnableNV: get(c!("vkCmdSetExclusiveScissorEnableNV")).map(|a| a.cast()),
                        vkCmdSetExclusiveScissorNV: get(c!("vkCmdSetExclusiveScissorNV")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkCmdSetExclusiveScissorEnableNV`
                pub unsafe fn CmdSetExclusiveScissorEnableNV(&self, commandBuffer: VkCommandBuffer, firstExclusiveScissor: uint32_t, exclusiveScissorCount: uint32_t, pExclusiveScissorEnables: *const VkBool32) -> () {
                    unsafe { (self.vkCmdSetExclusiveScissorEnableNV.expect("Unable to load vkCmdSetExclusiveScissorEnableNV"))(commandBuffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissorEnables) }
                }
                /// `vkCmdSetExclusiveScissorNV`
                pub unsafe fn CmdSetExclusiveScissorNV(&self, commandBuffer: VkCommandBuffer, firstExclusiveScissor: uint32_t, exclusiveScissorCount: uint32_t, pExclusiveScissors: *const VkRect2D) -> () {
                    unsafe { (self.vkCmdSetExclusiveScissorNV.expect("Unable to load vkCmdSetExclusiveScissorNV"))(commandBuffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissors) }
                }
            }
        }

        /// `VK_NV_device_diagnostic_checkpoints`
        pub mod device_diagnostic_checkpoints {
            use super::*;

            /// `VK_NV_device_diagnostic_checkpoints`
            pub const NAME: &'static CStr = c!("VK_NV_device_diagnostic_checkpoints");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkCmdSetCheckpointNV: PFN_vkCmdSetCheckpointNV,
                pub vkGetQueueCheckpointData2NV: PFN_vkGetQueueCheckpointData2NV,
                pub vkGetQueueCheckpointDataNV: PFN_vkGetQueueCheckpointDataNV,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkCmdSetCheckpointNV: get(c!("vkCmdSetCheckpointNV")).map(|a| a.cast()),
                        vkGetQueueCheckpointData2NV: get(c!("vkGetQueueCheckpointData2NV")).map(|a| a.cast()),
                        vkGetQueueCheckpointDataNV: get(c!("vkGetQueueCheckpointDataNV")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkCmdSetCheckpointNV`
                pub unsafe fn CmdSetCheckpointNV(&self, commandBuffer: VkCommandBuffer, pCheckpointMarker: *const void) -> () {
                    unsafe { (self.vkCmdSetCheckpointNV.expect("Unable to load vkCmdSetCheckpointNV"))(commandBuffer, pCheckpointMarker) }
                }
                /// `vkGetQueueCheckpointData2NV`
                pub unsafe fn GetQueueCheckpointData2NV(&self, queue: VkQueue, pCheckpointDataCount: *mut uint32_t, pCheckpointData: *mut VkCheckpointData2NV) -> () {
                    unsafe { (self.vkGetQueueCheckpointData2NV.expect("Unable to load vkGetQueueCheckpointData2NV"))(queue, pCheckpointDataCount, pCheckpointData) }
                }
                /// `vkGetQueueCheckpointDataNV`
                pub unsafe fn GetQueueCheckpointDataNV(&self, queue: VkQueue, pCheckpointDataCount: *mut uint32_t, pCheckpointData: *mut VkCheckpointDataNV) -> () {
                    unsafe { (self.vkGetQueueCheckpointDataNV.expect("Unable to load vkGetQueueCheckpointDataNV"))(queue, pCheckpointDataCount, pCheckpointData) }
                }
            }
        }

        /// `VK_NV_dedicated_allocation_image_aliasing`
        pub mod dedicated_allocation_image_aliasing {
            use super::*;

            /// `VK_NV_dedicated_allocation_image_aliasing`
            pub const NAME: &'static CStr = c!("VK_NV_dedicated_allocation_image_aliasing");
        }

        /// `VK_NV_cooperative_matrix`
        pub mod cooperative_matrix {
            use super::*;

            /// `VK_NV_cooperative_matrix`
            pub const NAME: &'static CStr = c!("VK_NV_cooperative_matrix");

            /// InstanceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct InstanceCommands {
                pub vkGetPhysicalDeviceCooperativeMatrixPropertiesNV: PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV,
            }

            impl InstanceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkGetPhysicalDeviceCooperativeMatrixPropertiesNV: get(c!("vkGetPhysicalDeviceCooperativeMatrixPropertiesNV")).map(|a| a.cast()),
                    } }
                }
            }

            impl InstanceCommands {
                /// `vkGetPhysicalDeviceCooperativeMatrixPropertiesNV`
                pub unsafe fn GetPhysicalDeviceCooperativeMatrixPropertiesNV(&self, physicalDevice: VkPhysicalDevice, pPropertyCount: *mut uint32_t, pProperties: *mut VkCooperativeMatrixPropertiesNV) -> VkResult {
                    unsafe { (self.vkGetPhysicalDeviceCooperativeMatrixPropertiesNV.expect("Unable to load vkGetPhysicalDeviceCooperativeMatrixPropertiesNV"))(physicalDevice, pPropertyCount, pProperties) }
                }
            }
        }

        /// `VK_NV_coverage_reduction_mode`
        pub mod coverage_reduction_mode {
            use super::*;

            /// `VK_NV_coverage_reduction_mode`
            pub const NAME: &'static CStr = c!("VK_NV_coverage_reduction_mode");

            /// InstanceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct InstanceCommands {
                pub vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV: PFN_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV,
            }

            impl InstanceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV: get(c!("vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV")).map(|a| a.cast()),
                    } }
                }
            }

            impl InstanceCommands {
                /// `vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV`
                pub unsafe fn GetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(&self, physicalDevice: VkPhysicalDevice, pCombinationCount: *mut uint32_t, pCombinations: *mut VkFramebufferMixedSamplesCombinationNV) -> VkResult {
                    unsafe { (self.vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV.expect("Unable to load vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV"))(physicalDevice, pCombinationCount, pCombinations) }
                }
            }
        }

        /// `VK_NV_device_generated_commands`
        pub mod device_generated_commands {
            use super::*;

            /// `VK_NV_device_generated_commands`
            pub const NAME: &'static CStr = c!("VK_NV_device_generated_commands");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkCmdBindPipelineShaderGroupNV: PFN_vkCmdBindPipelineShaderGroupNV,
                pub vkCmdExecuteGeneratedCommandsNV: PFN_vkCmdExecuteGeneratedCommandsNV,
                pub vkCmdPreprocessGeneratedCommandsNV: PFN_vkCmdPreprocessGeneratedCommandsNV,
                pub vkCreateIndirectCommandsLayoutNV: PFN_vkCreateIndirectCommandsLayoutNV,
                pub vkDestroyIndirectCommandsLayoutNV: PFN_vkDestroyIndirectCommandsLayoutNV,
                pub vkGetGeneratedCommandsMemoryRequirementsNV: PFN_vkGetGeneratedCommandsMemoryRequirementsNV,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkCmdBindPipelineShaderGroupNV: get(c!("vkCmdBindPipelineShaderGroupNV")).map(|a| a.cast()),
                        vkCmdExecuteGeneratedCommandsNV: get(c!("vkCmdExecuteGeneratedCommandsNV")).map(|a| a.cast()),
                        vkCmdPreprocessGeneratedCommandsNV: get(c!("vkCmdPreprocessGeneratedCommandsNV")).map(|a| a.cast()),
                        vkCreateIndirectCommandsLayoutNV: get(c!("vkCreateIndirectCommandsLayoutNV")).map(|a| a.cast()),
                        vkDestroyIndirectCommandsLayoutNV: get(c!("vkDestroyIndirectCommandsLayoutNV")).map(|a| a.cast()),
                        vkGetGeneratedCommandsMemoryRequirementsNV: get(c!("vkGetGeneratedCommandsMemoryRequirementsNV")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkCmdBindPipelineShaderGroupNV`
                pub unsafe fn CmdBindPipelineShaderGroupNV(&self, commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, pipeline: VkPipeline, groupIndex: uint32_t) -> () {
                    unsafe { (self.vkCmdBindPipelineShaderGroupNV.expect("Unable to load vkCmdBindPipelineShaderGroupNV"))(commandBuffer, pipelineBindPoint, pipeline, groupIndex) }
                }
                /// `vkCmdExecuteGeneratedCommandsNV`
                pub unsafe fn CmdExecuteGeneratedCommandsNV(&self, commandBuffer: VkCommandBuffer, isPreprocessed: VkBool32, pGeneratedCommandsInfo: *const VkGeneratedCommandsInfoNV) -> () {
                    unsafe { (self.vkCmdExecuteGeneratedCommandsNV.expect("Unable to load vkCmdExecuteGeneratedCommandsNV"))(commandBuffer, isPreprocessed, pGeneratedCommandsInfo) }
                }
                /// `vkCmdPreprocessGeneratedCommandsNV`
                pub unsafe fn CmdPreprocessGeneratedCommandsNV(&self, commandBuffer: VkCommandBuffer, pGeneratedCommandsInfo: *const VkGeneratedCommandsInfoNV) -> () {
                    unsafe { (self.vkCmdPreprocessGeneratedCommandsNV.expect("Unable to load vkCmdPreprocessGeneratedCommandsNV"))(commandBuffer, pGeneratedCommandsInfo) }
                }
                /// `vkCreateIndirectCommandsLayoutNV`
                pub unsafe fn CreateIndirectCommandsLayoutNV(&self, device: VkDevice, pCreateInfo: *const VkIndirectCommandsLayoutCreateInfoNV, pAllocator: *const VkAllocationCallbacks, pIndirectCommandsLayout: *mut VkIndirectCommandsLayoutNV) -> VkResult {
                    unsafe { (self.vkCreateIndirectCommandsLayoutNV.expect("Unable to load vkCreateIndirectCommandsLayoutNV"))(device, pCreateInfo, pAllocator, pIndirectCommandsLayout) }
                }
                /// `vkDestroyIndirectCommandsLayoutNV`
                pub unsafe fn DestroyIndirectCommandsLayoutNV(&self, device: VkDevice, indirectCommandsLayout: VkIndirectCommandsLayoutNV, pAllocator: *const VkAllocationCallbacks) -> () {
                    unsafe { (self.vkDestroyIndirectCommandsLayoutNV.expect("Unable to load vkDestroyIndirectCommandsLayoutNV"))(device, indirectCommandsLayout, pAllocator) }
                }
                /// `vkGetGeneratedCommandsMemoryRequirementsNV`
                pub unsafe fn GetGeneratedCommandsMemoryRequirementsNV(&self, device: VkDevice, pInfo: *const VkGeneratedCommandsMemoryRequirementsInfoNV, pMemoryRequirements: *mut VkMemoryRequirements2) -> () {
                    unsafe { (self.vkGetGeneratedCommandsMemoryRequirementsNV.expect("Unable to load vkGetGeneratedCommandsMemoryRequirementsNV"))(device, pInfo, pMemoryRequirements) }
                }
            }
        }

        /// `VK_NV_inherited_viewport_scissor`
        pub mod inherited_viewport_scissor {
            use super::*;

            /// `VK_NV_inherited_viewport_scissor`
            pub const NAME: &'static CStr = c!("VK_NV_inherited_viewport_scissor");
        }

        /// `VK_NV_present_barrier`
        pub mod present_barrier {
            use super::*;

            /// `VK_NV_present_barrier`
            pub const NAME: &'static CStr = c!("VK_NV_present_barrier");
        }

        /// `VK_NV_device_diagnostics_config`
        pub mod device_diagnostics_config {
            use super::*;

            /// `VK_NV_device_diagnostics_config`
            pub const NAME: &'static CStr = c!("VK_NV_device_diagnostics_config");
        }

        /// `VK_NV_cuda_kernel_launch`
        pub mod cuda_kernel_launch {
            use super::*;

            /// `VK_NV_cuda_kernel_launch`
            pub const NAME: &'static CStr = c!("VK_NV_cuda_kernel_launch");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkCmdCudaLaunchKernelNV: PFN_vkCmdCudaLaunchKernelNV,
                pub vkCreateCudaFunctionNV: PFN_vkCreateCudaFunctionNV,
                pub vkCreateCudaModuleNV: PFN_vkCreateCudaModuleNV,
                pub vkDestroyCudaFunctionNV: PFN_vkDestroyCudaFunctionNV,
                pub vkDestroyCudaModuleNV: PFN_vkDestroyCudaModuleNV,
                pub vkGetCudaModuleCacheNV: PFN_vkGetCudaModuleCacheNV,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkCmdCudaLaunchKernelNV: get(c!("vkCmdCudaLaunchKernelNV")).map(|a| a.cast()),
                        vkCreateCudaFunctionNV: get(c!("vkCreateCudaFunctionNV")).map(|a| a.cast()),
                        vkCreateCudaModuleNV: get(c!("vkCreateCudaModuleNV")).map(|a| a.cast()),
                        vkDestroyCudaFunctionNV: get(c!("vkDestroyCudaFunctionNV")).map(|a| a.cast()),
                        vkDestroyCudaModuleNV: get(c!("vkDestroyCudaModuleNV")).map(|a| a.cast()),
                        vkGetCudaModuleCacheNV: get(c!("vkGetCudaModuleCacheNV")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkCmdCudaLaunchKernelNV`
                pub unsafe fn CmdCudaLaunchKernelNV(&self, commandBuffer: VkCommandBuffer, pLaunchInfo: *const VkCudaLaunchInfoNV) -> () {
                    unsafe { (self.vkCmdCudaLaunchKernelNV.expect("Unable to load vkCmdCudaLaunchKernelNV"))(commandBuffer, pLaunchInfo) }
                }
                /// `vkCreateCudaFunctionNV`
                pub unsafe fn CreateCudaFunctionNV(&self, device: VkDevice, pCreateInfo: *const VkCudaFunctionCreateInfoNV, pAllocator: *const VkAllocationCallbacks, pFunction: *mut VkCudaFunctionNV) -> VkResult {
                    unsafe { (self.vkCreateCudaFunctionNV.expect("Unable to load vkCreateCudaFunctionNV"))(device, pCreateInfo, pAllocator, pFunction) }
                }
                /// `vkCreateCudaModuleNV`
                pub unsafe fn CreateCudaModuleNV(&self, device: VkDevice, pCreateInfo: *const VkCudaModuleCreateInfoNV, pAllocator: *const VkAllocationCallbacks, pModule: *mut VkCudaModuleNV) -> VkResult {
                    unsafe { (self.vkCreateCudaModuleNV.expect("Unable to load vkCreateCudaModuleNV"))(device, pCreateInfo, pAllocator, pModule) }
                }
                /// `vkDestroyCudaFunctionNV`
                pub unsafe fn DestroyCudaFunctionNV(&self, device: VkDevice, function: VkCudaFunctionNV, pAllocator: *const VkAllocationCallbacks) -> () {
                    unsafe { (self.vkDestroyCudaFunctionNV.expect("Unable to load vkDestroyCudaFunctionNV"))(device, function, pAllocator) }
                }
                /// `vkDestroyCudaModuleNV`
                pub unsafe fn DestroyCudaModuleNV(&self, device: VkDevice, module: VkCudaModuleNV, pAllocator: *const VkAllocationCallbacks) -> () {
                    unsafe { (self.vkDestroyCudaModuleNV.expect("Unable to load vkDestroyCudaModuleNV"))(device, module, pAllocator) }
                }
                /// `vkGetCudaModuleCacheNV`
                pub unsafe fn GetCudaModuleCacheNV(&self, device: VkDevice, module: VkCudaModuleNV, pCacheSize: *mut size_t, pCacheData: *mut void) -> VkResult {
                    unsafe { (self.vkGetCudaModuleCacheNV.expect("Unable to load vkGetCudaModuleCacheNV"))(device, module, pCacheSize, pCacheData) }
                }
            }
        }

        /// `VK_NV_low_latency`
        pub mod low_latency {
            use super::*;

            /// `VK_NV_low_latency`
            pub const NAME: &'static CStr = c!("VK_NV_low_latency");
        }

        /// `VK_NV_fragment_shading_rate_enums`
        pub mod fragment_shading_rate_enums {
            use super::*;

            /// `VK_NV_fragment_shading_rate_enums`
            pub const NAME: &'static CStr = c!("VK_NV_fragment_shading_rate_enums");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkCmdSetFragmentShadingRateEnumNV: PFN_vkCmdSetFragmentShadingRateEnumNV,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkCmdSetFragmentShadingRateEnumNV: get(c!("vkCmdSetFragmentShadingRateEnumNV")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkCmdSetFragmentShadingRateEnumNV`
                pub unsafe fn CmdSetFragmentShadingRateEnumNV(&self, commandBuffer: VkCommandBuffer, shadingRate: VkFragmentShadingRateNV, combinerOps: *const VkFragmentShadingRateCombinerOpKHR) -> () {
                    unsafe { (self.vkCmdSetFragmentShadingRateEnumNV.expect("Unable to load vkCmdSetFragmentShadingRateEnumNV"))(commandBuffer, shadingRate, combinerOps) }
                }
            }
        }

        /// `VK_NV_ray_tracing_motion_blur`
        pub mod ray_tracing_motion_blur {
            use super::*;

            /// `VK_NV_ray_tracing_motion_blur`
            pub const NAME: &'static CStr = c!("VK_NV_ray_tracing_motion_blur");
        }

        /// `VK_NV_acquire_winrt_display`
        pub mod acquire_winrt_display {
            use super::*;

            /// `VK_NV_acquire_winrt_display`
            pub const NAME: &'static CStr = c!("VK_NV_acquire_winrt_display");

            /// InstanceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct InstanceCommands {
                pub vkAcquireWinrtDisplayNV: PFN_vkAcquireWinrtDisplayNV,
                pub vkGetWinrtDisplayNV: PFN_vkGetWinrtDisplayNV,
            }

            impl InstanceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkAcquireWinrtDisplayNV: get(c!("vkAcquireWinrtDisplayNV")).map(|a| a.cast()),
                        vkGetWinrtDisplayNV: get(c!("vkGetWinrtDisplayNV")).map(|a| a.cast()),
                    } }
                }
            }

            impl InstanceCommands {
                /// `vkAcquireWinrtDisplayNV`
                pub unsafe fn AcquireWinrtDisplayNV(&self, physicalDevice: VkPhysicalDevice, display: VkDisplayKHR) -> VkResult {
                    unsafe { (self.vkAcquireWinrtDisplayNV.expect("Unable to load vkAcquireWinrtDisplayNV"))(physicalDevice, display) }
                }
                /// `vkGetWinrtDisplayNV`
                pub unsafe fn GetWinrtDisplayNV(&self, physicalDevice: VkPhysicalDevice, deviceRelativeId: uint32_t, pDisplay: *mut VkDisplayKHR) -> VkResult {
                    unsafe { (self.vkGetWinrtDisplayNV.expect("Unable to load vkGetWinrtDisplayNV"))(physicalDevice, deviceRelativeId, pDisplay) }
                }
            }
        }

        /// `VK_NV_external_memory_rdma`
        pub mod external_memory_rdma {
            use super::*;

            /// `VK_NV_external_memory_rdma`
            pub const NAME: &'static CStr = c!("VK_NV_external_memory_rdma");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkGetMemoryRemoteAddressNV: PFN_vkGetMemoryRemoteAddressNV,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkGetMemoryRemoteAddressNV: get(c!("vkGetMemoryRemoteAddressNV")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkGetMemoryRemoteAddressNV`
                pub unsafe fn GetMemoryRemoteAddressNV(&self, device: VkDevice, pMemoryGetRemoteAddressInfo: *const VkMemoryGetRemoteAddressInfoNV, pAddress: *mut VkRemoteAddressNV) -> VkResult {
                    unsafe { (self.vkGetMemoryRemoteAddressNV.expect("Unable to load vkGetMemoryRemoteAddressNV"))(device, pMemoryGetRemoteAddressInfo, pAddress) }
                }
            }
        }

        /// `VK_NV_external_sci_sync`
        pub mod external_sci_sync {
            use super::*;

            /// `VK_NV_external_sci_sync`
            pub const NAME: &'static CStr = c!("VK_NV_external_sci_sync");

            /// InstanceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct InstanceCommands {
                pub vkGetPhysicalDeviceSciSyncAttributesNV: PFN_vkGetPhysicalDeviceSciSyncAttributesNV,
            }

            impl InstanceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkGetPhysicalDeviceSciSyncAttributesNV: get(c!("vkGetPhysicalDeviceSciSyncAttributesNV")).map(|a| a.cast()),
                    } }
                }
            }

            impl InstanceCommands {
                /// `vkGetPhysicalDeviceSciSyncAttributesNV`
                pub unsafe fn GetPhysicalDeviceSciSyncAttributesNV(&self, physicalDevice: VkPhysicalDevice, pSciSyncAttributesInfo: *const VkSciSyncAttributesInfoNV, pAttributes: NvSciSyncAttrList) -> VkResult {
                    unsafe { (self.vkGetPhysicalDeviceSciSyncAttributesNV.expect("Unable to load vkGetPhysicalDeviceSciSyncAttributesNV"))(physicalDevice, pSciSyncAttributesInfo, pAttributes) }
                }
            }

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkGetFenceSciSyncFenceNV: PFN_vkGetFenceSciSyncFenceNV,
                pub vkGetFenceSciSyncObjNV: PFN_vkGetFenceSciSyncObjNV,
                pub vkGetSemaphoreSciSyncObjNV: PFN_vkGetSemaphoreSciSyncObjNV,
                pub vkImportFenceSciSyncFenceNV: PFN_vkImportFenceSciSyncFenceNV,
                pub vkImportFenceSciSyncObjNV: PFN_vkImportFenceSciSyncObjNV,
                pub vkImportSemaphoreSciSyncObjNV: PFN_vkImportSemaphoreSciSyncObjNV,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkGetFenceSciSyncFenceNV: get(c!("vkGetFenceSciSyncFenceNV")).map(|a| a.cast()),
                        vkGetFenceSciSyncObjNV: get(c!("vkGetFenceSciSyncObjNV")).map(|a| a.cast()),
                        vkGetSemaphoreSciSyncObjNV: get(c!("vkGetSemaphoreSciSyncObjNV")).map(|a| a.cast()),
                        vkImportFenceSciSyncFenceNV: get(c!("vkImportFenceSciSyncFenceNV")).map(|a| a.cast()),
                        vkImportFenceSciSyncObjNV: get(c!("vkImportFenceSciSyncObjNV")).map(|a| a.cast()),
                        vkImportSemaphoreSciSyncObjNV: get(c!("vkImportSemaphoreSciSyncObjNV")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkGetFenceSciSyncFenceNV`
                pub unsafe fn GetFenceSciSyncFenceNV(&self, device: VkDevice, pGetSciSyncHandleInfo: *const VkFenceGetSciSyncInfoNV, pHandle: *mut void) -> VkResult {
                    unsafe { (self.vkGetFenceSciSyncFenceNV.expect("Unable to load vkGetFenceSciSyncFenceNV"))(device, pGetSciSyncHandleInfo, pHandle) }
                }
                /// `vkGetFenceSciSyncObjNV`
                pub unsafe fn GetFenceSciSyncObjNV(&self, device: VkDevice, pGetSciSyncHandleInfo: *const VkFenceGetSciSyncInfoNV, pHandle: *mut void) -> VkResult {
                    unsafe { (self.vkGetFenceSciSyncObjNV.expect("Unable to load vkGetFenceSciSyncObjNV"))(device, pGetSciSyncHandleInfo, pHandle) }
                }
                /// `vkGetSemaphoreSciSyncObjNV`
                pub unsafe fn GetSemaphoreSciSyncObjNV(&self, device: VkDevice, pGetSciSyncInfo: *const VkSemaphoreGetSciSyncInfoNV, pHandle: *mut void) -> VkResult {
                    unsafe { (self.vkGetSemaphoreSciSyncObjNV.expect("Unable to load vkGetSemaphoreSciSyncObjNV"))(device, pGetSciSyncInfo, pHandle) }
                }
                /// `vkImportFenceSciSyncFenceNV`
                pub unsafe fn ImportFenceSciSyncFenceNV(&self, device: VkDevice, pImportFenceSciSyncInfo: *const VkImportFenceSciSyncInfoNV) -> VkResult {
                    unsafe { (self.vkImportFenceSciSyncFenceNV.expect("Unable to load vkImportFenceSciSyncFenceNV"))(device, pImportFenceSciSyncInfo) }
                }
                /// `vkImportFenceSciSyncObjNV`
                pub unsafe fn ImportFenceSciSyncObjNV(&self, device: VkDevice, pImportFenceSciSyncInfo: *const VkImportFenceSciSyncInfoNV) -> VkResult {
                    unsafe { (self.vkImportFenceSciSyncObjNV.expect("Unable to load vkImportFenceSciSyncObjNV"))(device, pImportFenceSciSyncInfo) }
                }
                /// `vkImportSemaphoreSciSyncObjNV`
                pub unsafe fn ImportSemaphoreSciSyncObjNV(&self, device: VkDevice, pImportSemaphoreSciSyncInfo: *const VkImportSemaphoreSciSyncInfoNV) -> VkResult {
                    unsafe { (self.vkImportSemaphoreSciSyncObjNV.expect("Unable to load vkImportSemaphoreSciSyncObjNV"))(device, pImportSemaphoreSciSyncInfo) }
                }
            }
        }

        /// `VK_NV_external_memory_sci_buf`
        pub mod external_memory_sci_buf {
            use super::*;

            /// `VK_NV_external_memory_sci_buf`
            pub const NAME: &'static CStr = c!("VK_NV_external_memory_sci_buf");

            /// InstanceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct InstanceCommands {
                pub vkGetPhysicalDeviceExternalMemorySciBufPropertiesNV: PFN_vkGetPhysicalDeviceExternalMemorySciBufPropertiesNV,
                pub vkGetPhysicalDeviceSciBufAttributesNV: PFN_vkGetPhysicalDeviceSciBufAttributesNV,
            }

            impl InstanceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkGetPhysicalDeviceExternalMemorySciBufPropertiesNV: get(c!("vkGetPhysicalDeviceExternalMemorySciBufPropertiesNV")).map(|a| a.cast()),
                        vkGetPhysicalDeviceSciBufAttributesNV: get(c!("vkGetPhysicalDeviceSciBufAttributesNV")).map(|a| a.cast()),
                    } }
                }
            }

            impl InstanceCommands {
                /// `vkGetPhysicalDeviceExternalMemorySciBufPropertiesNV`
                pub unsafe fn GetPhysicalDeviceExternalMemorySciBufPropertiesNV(&self, physicalDevice: VkPhysicalDevice, handleType: VkExternalMemoryHandleTypeFlags, handle: NvSciBufObj, pMemorySciBufProperties: *mut VkMemorySciBufPropertiesNV) -> VkResult {
                    unsafe { (self.vkGetPhysicalDeviceExternalMemorySciBufPropertiesNV.expect("Unable to load vkGetPhysicalDeviceExternalMemorySciBufPropertiesNV"))(physicalDevice, handleType, handle, pMemorySciBufProperties) }
                }
                /// `vkGetPhysicalDeviceSciBufAttributesNV`
                pub unsafe fn GetPhysicalDeviceSciBufAttributesNV(&self, physicalDevice: VkPhysicalDevice, pAttributes: NvSciBufAttrList) -> VkResult {
                    unsafe { (self.vkGetPhysicalDeviceSciBufAttributesNV.expect("Unable to load vkGetPhysicalDeviceSciBufAttributesNV"))(physicalDevice, pAttributes) }
                }
            }

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkGetMemorySciBufNV: PFN_vkGetMemorySciBufNV,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkGetMemorySciBufNV: get(c!("vkGetMemorySciBufNV")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkGetMemorySciBufNV`
                pub unsafe fn GetMemorySciBufNV(&self, device: VkDevice, pGetSciBufInfo: *const VkMemoryGetSciBufInfoNV, pHandle: *mut NvSciBufObj) -> VkResult {
                    unsafe { (self.vkGetMemorySciBufNV.expect("Unable to load vkGetMemorySciBufNV"))(device, pGetSciBufInfo, pHandle) }
                }
            }
        }

        /// `VK_NV_displacement_micromap`
        pub mod displacement_micromap {
            use super::*;

            /// `VK_NV_displacement_micromap`
            pub const NAME: &'static CStr = c!("VK_NV_displacement_micromap");
        }

        /// `VK_NV_copy_memory_indirect`
        pub mod copy_memory_indirect {
            use super::*;

            /// `VK_NV_copy_memory_indirect`
            pub const NAME: &'static CStr = c!("VK_NV_copy_memory_indirect");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkCmdCopyMemoryIndirectNV: PFN_vkCmdCopyMemoryIndirectNV,
                pub vkCmdCopyMemoryToImageIndirectNV: PFN_vkCmdCopyMemoryToImageIndirectNV,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkCmdCopyMemoryIndirectNV: get(c!("vkCmdCopyMemoryIndirectNV")).map(|a| a.cast()),
                        vkCmdCopyMemoryToImageIndirectNV: get(c!("vkCmdCopyMemoryToImageIndirectNV")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkCmdCopyMemoryIndirectNV`
                pub unsafe fn CmdCopyMemoryIndirectNV(&self, commandBuffer: VkCommandBuffer, copyBufferAddress: VkDeviceAddress, copyCount: uint32_t, stride: uint32_t) -> () {
                    unsafe { (self.vkCmdCopyMemoryIndirectNV.expect("Unable to load vkCmdCopyMemoryIndirectNV"))(commandBuffer, copyBufferAddress, copyCount, stride) }
                }
                /// `vkCmdCopyMemoryToImageIndirectNV`
                pub unsafe fn CmdCopyMemoryToImageIndirectNV(&self, commandBuffer: VkCommandBuffer, copyBufferAddress: VkDeviceAddress, copyCount: uint32_t, stride: uint32_t, dstImage: VkImage, dstImageLayout: VkImageLayout, pImageSubresources: *const VkImageSubresourceLayers) -> () {
                    unsafe { (self.vkCmdCopyMemoryToImageIndirectNV.expect("Unable to load vkCmdCopyMemoryToImageIndirectNV"))(commandBuffer, copyBufferAddress, copyCount, stride, dstImage, dstImageLayout, pImageSubresources) }
                }
            }
        }

        /// `VK_NV_memory_decompression`
        pub mod memory_decompression {
            use super::*;

            /// `VK_NV_memory_decompression`
            pub const NAME: &'static CStr = c!("VK_NV_memory_decompression");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkCmdDecompressMemoryIndirectCountNV: PFN_vkCmdDecompressMemoryIndirectCountNV,
                pub vkCmdDecompressMemoryNV: PFN_vkCmdDecompressMemoryNV,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkCmdDecompressMemoryIndirectCountNV: get(c!("vkCmdDecompressMemoryIndirectCountNV")).map(|a| a.cast()),
                        vkCmdDecompressMemoryNV: get(c!("vkCmdDecompressMemoryNV")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkCmdDecompressMemoryIndirectCountNV`
                pub unsafe fn CmdDecompressMemoryIndirectCountNV(&self, commandBuffer: VkCommandBuffer, indirectCommandsAddress: VkDeviceAddress, indirectCommandsCountAddress: VkDeviceAddress, stride: uint32_t) -> () {
                    unsafe { (self.vkCmdDecompressMemoryIndirectCountNV.expect("Unable to load vkCmdDecompressMemoryIndirectCountNV"))(commandBuffer, indirectCommandsAddress, indirectCommandsCountAddress, stride) }
                }
                /// `vkCmdDecompressMemoryNV`
                pub unsafe fn CmdDecompressMemoryNV(&self, commandBuffer: VkCommandBuffer, decompressRegionCount: uint32_t, pDecompressMemoryRegions: *const VkDecompressMemoryRegionNV) -> () {
                    unsafe { (self.vkCmdDecompressMemoryNV.expect("Unable to load vkCmdDecompressMemoryNV"))(commandBuffer, decompressRegionCount, pDecompressMemoryRegions) }
                }
            }
        }

        /// `VK_NV_device_generated_commands_compute`
        pub mod device_generated_commands_compute {
            use super::*;

            /// `VK_NV_device_generated_commands_compute`
            pub const NAME: &'static CStr = c!("VK_NV_device_generated_commands_compute");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkCmdUpdatePipelineIndirectBufferNV: PFN_vkCmdUpdatePipelineIndirectBufferNV,
                pub vkGetPipelineIndirectDeviceAddressNV: PFN_vkGetPipelineIndirectDeviceAddressNV,
                pub vkGetPipelineIndirectMemoryRequirementsNV: PFN_vkGetPipelineIndirectMemoryRequirementsNV,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkCmdUpdatePipelineIndirectBufferNV: get(c!("vkCmdUpdatePipelineIndirectBufferNV")).map(|a| a.cast()),
                        vkGetPipelineIndirectDeviceAddressNV: get(c!("vkGetPipelineIndirectDeviceAddressNV")).map(|a| a.cast()),
                        vkGetPipelineIndirectMemoryRequirementsNV: get(c!("vkGetPipelineIndirectMemoryRequirementsNV")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkCmdUpdatePipelineIndirectBufferNV`
                pub unsafe fn CmdUpdatePipelineIndirectBufferNV(&self, commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, pipeline: VkPipeline) -> () {
                    unsafe { (self.vkCmdUpdatePipelineIndirectBufferNV.expect("Unable to load vkCmdUpdatePipelineIndirectBufferNV"))(commandBuffer, pipelineBindPoint, pipeline) }
                }
                /// `vkGetPipelineIndirectDeviceAddressNV`
                pub unsafe fn GetPipelineIndirectDeviceAddressNV(&self, device: VkDevice, pInfo: *const VkPipelineIndirectDeviceAddressInfoNV) -> VkDeviceAddress {
                    unsafe { (self.vkGetPipelineIndirectDeviceAddressNV.expect("Unable to load vkGetPipelineIndirectDeviceAddressNV"))(device, pInfo) }
                }
                /// `vkGetPipelineIndirectMemoryRequirementsNV`
                pub unsafe fn GetPipelineIndirectMemoryRequirementsNV(&self, device: VkDevice, pCreateInfo: *const VkComputePipelineCreateInfo, pMemoryRequirements: *mut VkMemoryRequirements2) -> () {
                    unsafe { (self.vkGetPipelineIndirectMemoryRequirementsNV.expect("Unable to load vkGetPipelineIndirectMemoryRequirementsNV"))(device, pCreateInfo, pMemoryRequirements) }
                }
            }
        }

        /// `VK_NV_ray_tracing_linear_swept_spheres`
        pub mod ray_tracing_linear_swept_spheres {
            use super::*;

            /// `VK_NV_ray_tracing_linear_swept_spheres`
            pub const NAME: &'static CStr = c!("VK_NV_ray_tracing_linear_swept_spheres");
        }

        /// `VK_NV_linear_color_attachment`
        pub mod linear_color_attachment {
            use super::*;

            /// `VK_NV_linear_color_attachment`
            pub const NAME: &'static CStr = c!("VK_NV_linear_color_attachment");
        }

        /// `VK_NV_optical_flow`
        pub mod optical_flow {
            use super::*;

            /// `VK_NV_optical_flow`
            pub const NAME: &'static CStr = c!("VK_NV_optical_flow");

            /// InstanceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct InstanceCommands {
                pub vkGetPhysicalDeviceOpticalFlowImageFormatsNV: PFN_vkGetPhysicalDeviceOpticalFlowImageFormatsNV,
            }

            impl InstanceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkGetPhysicalDeviceOpticalFlowImageFormatsNV: get(c!("vkGetPhysicalDeviceOpticalFlowImageFormatsNV")).map(|a| a.cast()),
                    } }
                }
            }

            impl InstanceCommands {
                /// `vkGetPhysicalDeviceOpticalFlowImageFormatsNV`
                pub unsafe fn GetPhysicalDeviceOpticalFlowImageFormatsNV(&self, physicalDevice: VkPhysicalDevice, pOpticalFlowImageFormatInfo: *const VkOpticalFlowImageFormatInfoNV, pFormatCount: *mut uint32_t, pImageFormatProperties: *mut VkOpticalFlowImageFormatPropertiesNV) -> VkResult {
                    unsafe { (self.vkGetPhysicalDeviceOpticalFlowImageFormatsNV.expect("Unable to load vkGetPhysicalDeviceOpticalFlowImageFormatsNV"))(physicalDevice, pOpticalFlowImageFormatInfo, pFormatCount, pImageFormatProperties) }
                }
            }

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkBindOpticalFlowSessionImageNV: PFN_vkBindOpticalFlowSessionImageNV,
                pub vkCmdOpticalFlowExecuteNV: PFN_vkCmdOpticalFlowExecuteNV,
                pub vkCreateOpticalFlowSessionNV: PFN_vkCreateOpticalFlowSessionNV,
                pub vkDestroyOpticalFlowSessionNV: PFN_vkDestroyOpticalFlowSessionNV,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkBindOpticalFlowSessionImageNV: get(c!("vkBindOpticalFlowSessionImageNV")).map(|a| a.cast()),
                        vkCmdOpticalFlowExecuteNV: get(c!("vkCmdOpticalFlowExecuteNV")).map(|a| a.cast()),
                        vkCreateOpticalFlowSessionNV: get(c!("vkCreateOpticalFlowSessionNV")).map(|a| a.cast()),
                        vkDestroyOpticalFlowSessionNV: get(c!("vkDestroyOpticalFlowSessionNV")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkBindOpticalFlowSessionImageNV`
                pub unsafe fn BindOpticalFlowSessionImageNV(&self, device: VkDevice, session: VkOpticalFlowSessionNV, bindingPoint: VkOpticalFlowSessionBindingPointNV, view: VkImageView, layout: VkImageLayout) -> VkResult {
                    unsafe { (self.vkBindOpticalFlowSessionImageNV.expect("Unable to load vkBindOpticalFlowSessionImageNV"))(device, session, bindingPoint, view, layout) }
                }
                /// `vkCmdOpticalFlowExecuteNV`
                pub unsafe fn CmdOpticalFlowExecuteNV(&self, commandBuffer: VkCommandBuffer, session: VkOpticalFlowSessionNV, pExecuteInfo: *const VkOpticalFlowExecuteInfoNV) -> () {
                    unsafe { (self.vkCmdOpticalFlowExecuteNV.expect("Unable to load vkCmdOpticalFlowExecuteNV"))(commandBuffer, session, pExecuteInfo) }
                }
                /// `vkCreateOpticalFlowSessionNV`
                pub unsafe fn CreateOpticalFlowSessionNV(&self, device: VkDevice, pCreateInfo: *const VkOpticalFlowSessionCreateInfoNV, pAllocator: *const VkAllocationCallbacks, pSession: *mut VkOpticalFlowSessionNV) -> VkResult {
                    unsafe { (self.vkCreateOpticalFlowSessionNV.expect("Unable to load vkCreateOpticalFlowSessionNV"))(device, pCreateInfo, pAllocator, pSession) }
                }
                /// `vkDestroyOpticalFlowSessionNV`
                pub unsafe fn DestroyOpticalFlowSessionNV(&self, device: VkDevice, session: VkOpticalFlowSessionNV, pAllocator: *const VkAllocationCallbacks) -> () {
                    unsafe { (self.vkDestroyOpticalFlowSessionNV.expect("Unable to load vkDestroyOpticalFlowSessionNV"))(device, session, pAllocator) }
                }
            }
        }

        /// `VK_NV_external_sci_sync2`
        pub mod external_sci_sync2 {
            use super::*;

            /// `VK_NV_external_sci_sync2`
            pub const NAME: &'static CStr = c!("VK_NV_external_sci_sync2");

            /// InstanceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct InstanceCommands {
                pub vkGetPhysicalDeviceSciSyncAttributesNV: PFN_vkGetPhysicalDeviceSciSyncAttributesNV,
            }

            impl InstanceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkGetPhysicalDeviceSciSyncAttributesNV: get(c!("vkGetPhysicalDeviceSciSyncAttributesNV")).map(|a| a.cast()),
                    } }
                }
            }

            impl InstanceCommands {
                /// `vkGetPhysicalDeviceSciSyncAttributesNV`
                pub unsafe fn GetPhysicalDeviceSciSyncAttributesNV(&self, physicalDevice: VkPhysicalDevice, pSciSyncAttributesInfo: *const VkSciSyncAttributesInfoNV, pAttributes: NvSciSyncAttrList) -> VkResult {
                    unsafe { (self.vkGetPhysicalDeviceSciSyncAttributesNV.expect("Unable to load vkGetPhysicalDeviceSciSyncAttributesNV"))(physicalDevice, pSciSyncAttributesInfo, pAttributes) }
                }
            }

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkCreateSemaphoreSciSyncPoolNV: PFN_vkCreateSemaphoreSciSyncPoolNV,
                pub vkDestroySemaphoreSciSyncPoolNV: PFN_vkDestroySemaphoreSciSyncPoolNV,
                pub vkGetFenceSciSyncFenceNV: PFN_vkGetFenceSciSyncFenceNV,
                pub vkGetFenceSciSyncObjNV: PFN_vkGetFenceSciSyncObjNV,
                pub vkImportFenceSciSyncFenceNV: PFN_vkImportFenceSciSyncFenceNV,
                pub vkImportFenceSciSyncObjNV: PFN_vkImportFenceSciSyncObjNV,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkCreateSemaphoreSciSyncPoolNV: get(c!("vkCreateSemaphoreSciSyncPoolNV")).map(|a| a.cast()),
                        vkDestroySemaphoreSciSyncPoolNV: get(c!("vkDestroySemaphoreSciSyncPoolNV")).map(|a| a.cast()),
                        vkGetFenceSciSyncFenceNV: get(c!("vkGetFenceSciSyncFenceNV")).map(|a| a.cast()),
                        vkGetFenceSciSyncObjNV: get(c!("vkGetFenceSciSyncObjNV")).map(|a| a.cast()),
                        vkImportFenceSciSyncFenceNV: get(c!("vkImportFenceSciSyncFenceNV")).map(|a| a.cast()),
                        vkImportFenceSciSyncObjNV: get(c!("vkImportFenceSciSyncObjNV")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkCreateSemaphoreSciSyncPoolNV`
                pub unsafe fn CreateSemaphoreSciSyncPoolNV(&self, device: VkDevice, pCreateInfo: *const VkSemaphoreSciSyncPoolCreateInfoNV, pAllocator: *const VkAllocationCallbacks, pSemaphorePool: *mut VkSemaphoreSciSyncPoolNV) -> VkResult {
                    unsafe { (self.vkCreateSemaphoreSciSyncPoolNV.expect("Unable to load vkCreateSemaphoreSciSyncPoolNV"))(device, pCreateInfo, pAllocator, pSemaphorePool) }
                }
                /// `vkDestroySemaphoreSciSyncPoolNV`
                pub unsafe fn DestroySemaphoreSciSyncPoolNV(&self, device: VkDevice, semaphorePool: VkSemaphoreSciSyncPoolNV, pAllocator: *const VkAllocationCallbacks) -> () {
                    unsafe { (self.vkDestroySemaphoreSciSyncPoolNV.expect("Unable to load vkDestroySemaphoreSciSyncPoolNV"))(device, semaphorePool, pAllocator) }
                }
                /// `vkGetFenceSciSyncFenceNV`
                pub unsafe fn GetFenceSciSyncFenceNV(&self, device: VkDevice, pGetSciSyncHandleInfo: *const VkFenceGetSciSyncInfoNV, pHandle: *mut void) -> VkResult {
                    unsafe { (self.vkGetFenceSciSyncFenceNV.expect("Unable to load vkGetFenceSciSyncFenceNV"))(device, pGetSciSyncHandleInfo, pHandle) }
                }
                /// `vkGetFenceSciSyncObjNV`
                pub unsafe fn GetFenceSciSyncObjNV(&self, device: VkDevice, pGetSciSyncHandleInfo: *const VkFenceGetSciSyncInfoNV, pHandle: *mut void) -> VkResult {
                    unsafe { (self.vkGetFenceSciSyncObjNV.expect("Unable to load vkGetFenceSciSyncObjNV"))(device, pGetSciSyncHandleInfo, pHandle) }
                }
                /// `vkImportFenceSciSyncFenceNV`
                pub unsafe fn ImportFenceSciSyncFenceNV(&self, device: VkDevice, pImportFenceSciSyncInfo: *const VkImportFenceSciSyncInfoNV) -> VkResult {
                    unsafe { (self.vkImportFenceSciSyncFenceNV.expect("Unable to load vkImportFenceSciSyncFenceNV"))(device, pImportFenceSciSyncInfo) }
                }
                /// `vkImportFenceSciSyncObjNV`
                pub unsafe fn ImportFenceSciSyncObjNV(&self, device: VkDevice, pImportFenceSciSyncInfo: *const VkImportFenceSciSyncInfoNV) -> VkResult {
                    unsafe { (self.vkImportFenceSciSyncObjNV.expect("Unable to load vkImportFenceSciSyncObjNV"))(device, pImportFenceSciSyncInfo) }
                }
            }
        }

        /// `VK_NV_ray_tracing_invocation_reorder`
        pub mod ray_tracing_invocation_reorder {
            use super::*;

            /// `VK_NV_ray_tracing_invocation_reorder`
            pub const NAME: &'static CStr = c!("VK_NV_ray_tracing_invocation_reorder");
        }

        /// `VK_NV_cooperative_vector`
        pub mod cooperative_vector {
            use super::*;

            /// `VK_NV_cooperative_vector`
            pub const NAME: &'static CStr = c!("VK_NV_cooperative_vector");

            /// InstanceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct InstanceCommands {
                pub vkGetPhysicalDeviceCooperativeVectorPropertiesNV: PFN_vkGetPhysicalDeviceCooperativeVectorPropertiesNV,
            }

            impl InstanceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkGetPhysicalDeviceCooperativeVectorPropertiesNV: get(c!("vkGetPhysicalDeviceCooperativeVectorPropertiesNV")).map(|a| a.cast()),
                    } }
                }
            }

            impl InstanceCommands {
                /// `vkGetPhysicalDeviceCooperativeVectorPropertiesNV`
                pub unsafe fn GetPhysicalDeviceCooperativeVectorPropertiesNV(&self, physicalDevice: VkPhysicalDevice, pPropertyCount: *mut uint32_t, pProperties: *mut VkCooperativeVectorPropertiesNV) -> VkResult {
                    unsafe { (self.vkGetPhysicalDeviceCooperativeVectorPropertiesNV.expect("Unable to load vkGetPhysicalDeviceCooperativeVectorPropertiesNV"))(physicalDevice, pPropertyCount, pProperties) }
                }
            }

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkCmdConvertCooperativeVectorMatrixNV: PFN_vkCmdConvertCooperativeVectorMatrixNV,
                pub vkConvertCooperativeVectorMatrixNV: PFN_vkConvertCooperativeVectorMatrixNV,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkCmdConvertCooperativeVectorMatrixNV: get(c!("vkCmdConvertCooperativeVectorMatrixNV")).map(|a| a.cast()),
                        vkConvertCooperativeVectorMatrixNV: get(c!("vkConvertCooperativeVectorMatrixNV")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkCmdConvertCooperativeVectorMatrixNV`
                pub unsafe fn CmdConvertCooperativeVectorMatrixNV(&self, commandBuffer: VkCommandBuffer, infoCount: uint32_t, pInfos: *const VkConvertCooperativeVectorMatrixInfoNV) -> () {
                    unsafe { (self.vkCmdConvertCooperativeVectorMatrixNV.expect("Unable to load vkCmdConvertCooperativeVectorMatrixNV"))(commandBuffer, infoCount, pInfos) }
                }
                /// `vkConvertCooperativeVectorMatrixNV`
                pub unsafe fn ConvertCooperativeVectorMatrixNV(&self, device: VkDevice, pInfo: *const VkConvertCooperativeVectorMatrixInfoNV) -> VkResult {
                    unsafe { (self.vkConvertCooperativeVectorMatrixNV.expect("Unable to load vkConvertCooperativeVectorMatrixNV"))(device, pInfo) }
                }
            }
        }

        /// `VK_NV_extended_sparse_address_space`
        pub mod extended_sparse_address_space {
            use super::*;

            /// `VK_NV_extended_sparse_address_space`
            pub const NAME: &'static CStr = c!("VK_NV_extended_sparse_address_space");
        }

        /// `VK_NV_low_latency2`
        pub mod low_latency2 {
            use super::*;

            /// `VK_NV_low_latency2`
            pub const NAME: &'static CStr = c!("VK_NV_low_latency2");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkGetLatencyTimingsNV: PFN_vkGetLatencyTimingsNV,
                pub vkLatencySleepNV: PFN_vkLatencySleepNV,
                pub vkQueueNotifyOutOfBandNV: PFN_vkQueueNotifyOutOfBandNV,
                pub vkSetLatencyMarkerNV: PFN_vkSetLatencyMarkerNV,
                pub vkSetLatencySleepModeNV: PFN_vkSetLatencySleepModeNV,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkGetLatencyTimingsNV: get(c!("vkGetLatencyTimingsNV")).map(|a| a.cast()),
                        vkLatencySleepNV: get(c!("vkLatencySleepNV")).map(|a| a.cast()),
                        vkQueueNotifyOutOfBandNV: get(c!("vkQueueNotifyOutOfBandNV")).map(|a| a.cast()),
                        vkSetLatencyMarkerNV: get(c!("vkSetLatencyMarkerNV")).map(|a| a.cast()),
                        vkSetLatencySleepModeNV: get(c!("vkSetLatencySleepModeNV")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkGetLatencyTimingsNV`
                pub unsafe fn GetLatencyTimingsNV(&self, device: VkDevice, swapchain: VkSwapchainKHR, pLatencyMarkerInfo: *mut VkGetLatencyMarkerInfoNV) -> () {
                    unsafe { (self.vkGetLatencyTimingsNV.expect("Unable to load vkGetLatencyTimingsNV"))(device, swapchain, pLatencyMarkerInfo) }
                }
                /// `vkLatencySleepNV`
                pub unsafe fn LatencySleepNV(&self, device: VkDevice, swapchain: VkSwapchainKHR, pSleepInfo: *const VkLatencySleepInfoNV) -> VkResult {
                    unsafe { (self.vkLatencySleepNV.expect("Unable to load vkLatencySleepNV"))(device, swapchain, pSleepInfo) }
                }
                /// `vkQueueNotifyOutOfBandNV`
                pub unsafe fn QueueNotifyOutOfBandNV(&self, queue: VkQueue, pQueueTypeInfo: *const VkOutOfBandQueueTypeInfoNV) -> () {
                    unsafe { (self.vkQueueNotifyOutOfBandNV.expect("Unable to load vkQueueNotifyOutOfBandNV"))(queue, pQueueTypeInfo) }
                }
                /// `vkSetLatencyMarkerNV`
                pub unsafe fn SetLatencyMarkerNV(&self, device: VkDevice, swapchain: VkSwapchainKHR, pLatencyMarkerInfo: *const VkSetLatencyMarkerInfoNV) -> () {
                    unsafe { (self.vkSetLatencyMarkerNV.expect("Unable to load vkSetLatencyMarkerNV"))(device, swapchain, pLatencyMarkerInfo) }
                }
                /// `vkSetLatencySleepModeNV`
                pub unsafe fn SetLatencySleepModeNV(&self, device: VkDevice, swapchain: VkSwapchainKHR, pSleepModeInfo: *const VkLatencySleepModeInfoNV) -> VkResult {
                    unsafe { (self.vkSetLatencySleepModeNV.expect("Unable to load vkSetLatencySleepModeNV"))(device, swapchain, pSleepModeInfo) }
                }
            }
        }

        /// `VK_NV_per_stage_descriptor_set`
        pub mod per_stage_descriptor_set {
            use super::*;

            /// `VK_NV_per_stage_descriptor_set`
            pub const NAME: &'static CStr = c!("VK_NV_per_stage_descriptor_set");
        }

        /// `VK_NV_descriptor_pool_overallocation`
        pub mod descriptor_pool_overallocation {
            use super::*;

            /// `VK_NV_descriptor_pool_overallocation`
            pub const NAME: &'static CStr = c!("VK_NV_descriptor_pool_overallocation");
        }

        /// `VK_NV_display_stereo`
        pub mod display_stereo {
            use super::*;

            /// `VK_NV_display_stereo`
            pub const NAME: &'static CStr = c!("VK_NV_display_stereo");
        }

        /// `VK_NV_raw_access_chains`
        pub mod raw_access_chains {
            use super::*;

            /// `VK_NV_raw_access_chains`
            pub const NAME: &'static CStr = c!("VK_NV_raw_access_chains");
        }

        /// `VK_NV_external_compute_queue`
        pub mod external_compute_queue {
            use super::*;

            /// `VK_NV_external_compute_queue`
            pub const NAME: &'static CStr = c!("VK_NV_external_compute_queue");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkCreateExternalComputeQueueNV: PFN_vkCreateExternalComputeQueueNV,
                pub vkDestroyExternalComputeQueueNV: PFN_vkDestroyExternalComputeQueueNV,
                pub vkGetExternalComputeQueueDataNV: PFN_vkGetExternalComputeQueueDataNV,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkCreateExternalComputeQueueNV: get(c!("vkCreateExternalComputeQueueNV")).map(|a| a.cast()),
                        vkDestroyExternalComputeQueueNV: get(c!("vkDestroyExternalComputeQueueNV")).map(|a| a.cast()),
                        vkGetExternalComputeQueueDataNV: get(c!("vkGetExternalComputeQueueDataNV")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkCreateExternalComputeQueueNV`
                pub unsafe fn CreateExternalComputeQueueNV(&self, device: VkDevice, pCreateInfo: *const VkExternalComputeQueueCreateInfoNV, pAllocator: *const VkAllocationCallbacks, pExternalQueue: *mut VkExternalComputeQueueNV) -> VkResult {
                    unsafe { (self.vkCreateExternalComputeQueueNV.expect("Unable to load vkCreateExternalComputeQueueNV"))(device, pCreateInfo, pAllocator, pExternalQueue) }
                }
                /// `vkDestroyExternalComputeQueueNV`
                pub unsafe fn DestroyExternalComputeQueueNV(&self, device: VkDevice, externalQueue: VkExternalComputeQueueNV, pAllocator: *const VkAllocationCallbacks) -> () {
                    unsafe { (self.vkDestroyExternalComputeQueueNV.expect("Unable to load vkDestroyExternalComputeQueueNV"))(device, externalQueue, pAllocator) }
                }
                /// `vkGetExternalComputeQueueDataNV`
                pub unsafe fn GetExternalComputeQueueDataNV(&self, externalQueue: VkExternalComputeQueueNV, params: *mut VkExternalComputeQueueDataParamsNV, pData: *mut void) -> () {
                    unsafe { (self.vkGetExternalComputeQueueDataNV.expect("Unable to load vkGetExternalComputeQueueDataNV"))(externalQueue, params, pData) }
                }
            }
        }

        /// `VK_NV_command_buffer_inheritance`
        pub mod command_buffer_inheritance {
            use super::*;

            /// `VK_NV_command_buffer_inheritance`
            pub const NAME: &'static CStr = c!("VK_NV_command_buffer_inheritance");
        }

        /// `VK_NV_shader_atomic_float16_vector`
        pub mod shader_atomic_float16_vector {
            use super::*;

            /// `VK_NV_shader_atomic_float16_vector`
            pub const NAME: &'static CStr = c!("VK_NV_shader_atomic_float16_vector");
        }

        /// `VK_NV_ray_tracing_validation`
        pub mod ray_tracing_validation {
            use super::*;

            /// `VK_NV_ray_tracing_validation`
            pub const NAME: &'static CStr = c!("VK_NV_ray_tracing_validation");
        }

        /// `VK_NV_cluster_acceleration_structure`
        pub mod cluster_acceleration_structure {
            use super::*;

            /// `VK_NV_cluster_acceleration_structure`
            pub const NAME: &'static CStr = c!("VK_NV_cluster_acceleration_structure");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkCmdBuildClusterAccelerationStructureIndirectNV: PFN_vkCmdBuildClusterAccelerationStructureIndirectNV,
                pub vkGetClusterAccelerationStructureBuildSizesNV: PFN_vkGetClusterAccelerationStructureBuildSizesNV,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkCmdBuildClusterAccelerationStructureIndirectNV: get(c!("vkCmdBuildClusterAccelerationStructureIndirectNV")).map(|a| a.cast()),
                        vkGetClusterAccelerationStructureBuildSizesNV: get(c!("vkGetClusterAccelerationStructureBuildSizesNV")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkCmdBuildClusterAccelerationStructureIndirectNV`
                pub unsafe fn CmdBuildClusterAccelerationStructureIndirectNV(&self, commandBuffer: VkCommandBuffer, pCommandInfos: *const VkClusterAccelerationStructureCommandsInfoNV) -> () {
                    unsafe { (self.vkCmdBuildClusterAccelerationStructureIndirectNV.expect("Unable to load vkCmdBuildClusterAccelerationStructureIndirectNV"))(commandBuffer, pCommandInfos) }
                }
                /// `vkGetClusterAccelerationStructureBuildSizesNV`
                pub unsafe fn GetClusterAccelerationStructureBuildSizesNV(&self, device: VkDevice, pInfo: *const VkClusterAccelerationStructureInputInfoNV, pSizeInfo: *mut VkAccelerationStructureBuildSizesInfoKHR) -> () {
                    unsafe { (self.vkGetClusterAccelerationStructureBuildSizesNV.expect("Unable to load vkGetClusterAccelerationStructureBuildSizesNV"))(device, pInfo, pSizeInfo) }
                }
            }
        }

        /// `VK_NV_partitioned_acceleration_structure`
        pub mod partitioned_acceleration_structure {
            use super::*;

            /// `VK_NV_partitioned_acceleration_structure`
            pub const NAME: &'static CStr = c!("VK_NV_partitioned_acceleration_structure");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkCmdBuildPartitionedAccelerationStructuresNV: PFN_vkCmdBuildPartitionedAccelerationStructuresNV,
                pub vkGetPartitionedAccelerationStructuresBuildSizesNV: PFN_vkGetPartitionedAccelerationStructuresBuildSizesNV,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkCmdBuildPartitionedAccelerationStructuresNV: get(c!("vkCmdBuildPartitionedAccelerationStructuresNV")).map(|a| a.cast()),
                        vkGetPartitionedAccelerationStructuresBuildSizesNV: get(c!("vkGetPartitionedAccelerationStructuresBuildSizesNV")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkCmdBuildPartitionedAccelerationStructuresNV`
                pub unsafe fn CmdBuildPartitionedAccelerationStructuresNV(&self, commandBuffer: VkCommandBuffer, pBuildInfo: *const VkBuildPartitionedAccelerationStructureInfoNV) -> () {
                    unsafe { (self.vkCmdBuildPartitionedAccelerationStructuresNV.expect("Unable to load vkCmdBuildPartitionedAccelerationStructuresNV"))(commandBuffer, pBuildInfo) }
                }
                /// `vkGetPartitionedAccelerationStructuresBuildSizesNV`
                pub unsafe fn GetPartitionedAccelerationStructuresBuildSizesNV(&self, device: VkDevice, pInfo: *const VkPartitionedAccelerationStructureInstancesInputNV, pSizeInfo: *mut VkAccelerationStructureBuildSizesInfoKHR) -> () {
                    unsafe { (self.vkGetPartitionedAccelerationStructuresBuildSizesNV.expect("Unable to load vkGetPartitionedAccelerationStructuresBuildSizesNV"))(device, pInfo, pSizeInfo) }
                }
            }
        }

        /// `VK_NV_push_constant_bank`
        pub mod push_constant_bank {
            use super::*;

            /// `VK_NV_push_constant_bank`
            pub const NAME: &'static CStr = c!("VK_NV_push_constant_bank");
        }

        /// `VK_NV_cooperative_matrix2`
        pub mod cooperative_matrix2 {
            use super::*;

            /// `VK_NV_cooperative_matrix2`
            pub const NAME: &'static CStr = c!("VK_NV_cooperative_matrix2");

            /// InstanceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct InstanceCommands {
                pub vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV: PFN_vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV,
            }

            impl InstanceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV: get(c!("vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV")).map(|a| a.cast()),
                    } }
                }
            }

            impl InstanceCommands {
                /// `vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV`
                pub unsafe fn GetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV(&self, physicalDevice: VkPhysicalDevice, pPropertyCount: *mut uint32_t, pProperties: *mut VkCooperativeMatrixFlexibleDimensionsPropertiesNV) -> VkResult {
                    unsafe { (self.vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV.expect("Unable to load vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV"))(physicalDevice, pPropertyCount, pProperties) }
                }
            }
        }

        /// `VK_NV_present_metering`
        pub mod present_metering {
            use super::*;

            /// `VK_NV_present_metering`
            pub const NAME: &'static CStr = c!("VK_NV_present_metering");
        }

        /// `VK_NV_compute_occupancy_priority`
        pub mod compute_occupancy_priority {
            use super::*;

            /// `VK_NV_compute_occupancy_priority`
            pub const NAME: &'static CStr = c!("VK_NV_compute_occupancy_priority");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkCmdSetComputeOccupancyPriorityNV: PFN_vkCmdSetComputeOccupancyPriorityNV,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkCmdSetComputeOccupancyPriorityNV: get(c!("vkCmdSetComputeOccupancyPriorityNV")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkCmdSetComputeOccupancyPriorityNV`
                pub unsafe fn CmdSetComputeOccupancyPriorityNV(&self, commandBuffer: VkCommandBuffer, pParameters: *const VkComputeOccupancyPriorityParametersNV) -> () {
                    unsafe { (self.vkCmdSetComputeOccupancyPriorityNV.expect("Unable to load vkCmdSetComputeOccupancyPriorityNV"))(commandBuffer, pParameters) }
                }
            }
        }
    }
    /// `NVX` prefix extensions
    pub mod nvx {
        use core::ffi::CStr;
        use crate::loader::*;
        use crate::ffi::*;
        use crate::*;

        /// `VK_NVX_binary_import`
        pub mod binary_import {
            use super::*;

            /// `VK_NVX_binary_import`
            pub const NAME: &'static CStr = c!("VK_NVX_binary_import");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkCmdCuLaunchKernelNVX: PFN_vkCmdCuLaunchKernelNVX,
                pub vkCreateCuFunctionNVX: PFN_vkCreateCuFunctionNVX,
                pub vkCreateCuModuleNVX: PFN_vkCreateCuModuleNVX,
                pub vkDestroyCuFunctionNVX: PFN_vkDestroyCuFunctionNVX,
                pub vkDestroyCuModuleNVX: PFN_vkDestroyCuModuleNVX,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkCmdCuLaunchKernelNVX: get(c!("vkCmdCuLaunchKernelNVX")).map(|a| a.cast()),
                        vkCreateCuFunctionNVX: get(c!("vkCreateCuFunctionNVX")).map(|a| a.cast()),
                        vkCreateCuModuleNVX: get(c!("vkCreateCuModuleNVX")).map(|a| a.cast()),
                        vkDestroyCuFunctionNVX: get(c!("vkDestroyCuFunctionNVX")).map(|a| a.cast()),
                        vkDestroyCuModuleNVX: get(c!("vkDestroyCuModuleNVX")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkCmdCuLaunchKernelNVX`
                pub unsafe fn CmdCuLaunchKernelNVX(&self, commandBuffer: VkCommandBuffer, pLaunchInfo: *const VkCuLaunchInfoNVX) -> () {
                    unsafe { (self.vkCmdCuLaunchKernelNVX.expect("Unable to load vkCmdCuLaunchKernelNVX"))(commandBuffer, pLaunchInfo) }
                }
                /// `vkCreateCuFunctionNVX`
                pub unsafe fn CreateCuFunctionNVX(&self, device: VkDevice, pCreateInfo: *const VkCuFunctionCreateInfoNVX, pAllocator: *const VkAllocationCallbacks, pFunction: *mut VkCuFunctionNVX) -> VkResult {
                    unsafe { (self.vkCreateCuFunctionNVX.expect("Unable to load vkCreateCuFunctionNVX"))(device, pCreateInfo, pAllocator, pFunction) }
                }
                /// `vkCreateCuModuleNVX`
                pub unsafe fn CreateCuModuleNVX(&self, device: VkDevice, pCreateInfo: *const VkCuModuleCreateInfoNVX, pAllocator: *const VkAllocationCallbacks, pModule: *mut VkCuModuleNVX) -> VkResult {
                    unsafe { (self.vkCreateCuModuleNVX.expect("Unable to load vkCreateCuModuleNVX"))(device, pCreateInfo, pAllocator, pModule) }
                }
                /// `vkDestroyCuFunctionNVX`
                pub unsafe fn DestroyCuFunctionNVX(&self, device: VkDevice, function: VkCuFunctionNVX, pAllocator: *const VkAllocationCallbacks) -> () {
                    unsafe { (self.vkDestroyCuFunctionNVX.expect("Unable to load vkDestroyCuFunctionNVX"))(device, function, pAllocator) }
                }
                /// `vkDestroyCuModuleNVX`
                pub unsafe fn DestroyCuModuleNVX(&self, device: VkDevice, module: VkCuModuleNVX, pAllocator: *const VkAllocationCallbacks) -> () {
                    unsafe { (self.vkDestroyCuModuleNVX.expect("Unable to load vkDestroyCuModuleNVX"))(device, module, pAllocator) }
                }
            }
        }

        /// `VK_NVX_image_view_handle`
        pub mod image_view_handle {
            use super::*;

            /// `VK_NVX_image_view_handle`
            pub const NAME: &'static CStr = c!("VK_NVX_image_view_handle");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkGetDeviceCombinedImageSamplerIndexNVX: PFN_vkGetDeviceCombinedImageSamplerIndexNVX,
                pub vkGetImageViewAddressNVX: PFN_vkGetImageViewAddressNVX,
                pub vkGetImageViewHandle64NVX: PFN_vkGetImageViewHandle64NVX,
                pub vkGetImageViewHandleNVX: PFN_vkGetImageViewHandleNVX,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkGetDeviceCombinedImageSamplerIndexNVX: get(c!("vkGetDeviceCombinedImageSamplerIndexNVX")).map(|a| a.cast()),
                        vkGetImageViewAddressNVX: get(c!("vkGetImageViewAddressNVX")).map(|a| a.cast()),
                        vkGetImageViewHandle64NVX: get(c!("vkGetImageViewHandle64NVX")).map(|a| a.cast()),
                        vkGetImageViewHandleNVX: get(c!("vkGetImageViewHandleNVX")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkGetDeviceCombinedImageSamplerIndexNVX`
                pub unsafe fn GetDeviceCombinedImageSamplerIndexNVX(&self, device: VkDevice, imageViewIndex: uint64_t, samplerIndex: uint64_t) -> uint64_t {
                    unsafe { (self.vkGetDeviceCombinedImageSamplerIndexNVX.expect("Unable to load vkGetDeviceCombinedImageSamplerIndexNVX"))(device, imageViewIndex, samplerIndex) }
                }
                /// `vkGetImageViewAddressNVX`
                pub unsafe fn GetImageViewAddressNVX(&self, device: VkDevice, imageView: VkImageView, pProperties: *mut VkImageViewAddressPropertiesNVX) -> VkResult {
                    unsafe { (self.vkGetImageViewAddressNVX.expect("Unable to load vkGetImageViewAddressNVX"))(device, imageView, pProperties) }
                }
                /// `vkGetImageViewHandle64NVX`
                pub unsafe fn GetImageViewHandle64NVX(&self, device: VkDevice, pInfo: *const VkImageViewHandleInfoNVX) -> uint64_t {
                    unsafe { (self.vkGetImageViewHandle64NVX.expect("Unable to load vkGetImageViewHandle64NVX"))(device, pInfo) }
                }
                /// `vkGetImageViewHandleNVX`
                pub unsafe fn GetImageViewHandleNVX(&self, device: VkDevice, pInfo: *const VkImageViewHandleInfoNVX) -> uint32_t {
                    unsafe { (self.vkGetImageViewHandleNVX.expect("Unable to load vkGetImageViewHandleNVX"))(device, pInfo) }
                }
            }
        }

        /// `VK_NVX_multiview_per_view_attributes`
        pub mod multiview_per_view_attributes {
            use super::*;

            /// `VK_NVX_multiview_per_view_attributes`
            pub const NAME: &'static CStr = c!("VK_NVX_multiview_per_view_attributes");
        }
    }
    /// `OHOS` prefix extensions
    pub mod ohos {
        use core::ffi::CStr;
        use crate::loader::*;
        use crate::ffi::*;
        use crate::*;

        /// `VK_OHOS_external_memory`
        pub mod external_memory {
            use super::*;

            /// `VK_OHOS_external_memory`
            pub const NAME: &'static CStr = c!("VK_OHOS_external_memory");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkGetMemoryNativeBufferOHOS: PFN_vkGetMemoryNativeBufferOHOS,
                pub vkGetNativeBufferPropertiesOHOS: PFN_vkGetNativeBufferPropertiesOHOS,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkGetMemoryNativeBufferOHOS: get(c!("vkGetMemoryNativeBufferOHOS")).map(|a| a.cast()),
                        vkGetNativeBufferPropertiesOHOS: get(c!("vkGetNativeBufferPropertiesOHOS")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkGetMemoryNativeBufferOHOS`
                pub unsafe fn GetMemoryNativeBufferOHOS(&self, device: VkDevice, pInfo: *const VkMemoryGetNativeBufferInfoOHOS, pBuffer: *mut *mut OH_NativeBuffer) -> VkResult {
                    unsafe { (self.vkGetMemoryNativeBufferOHOS.expect("Unable to load vkGetMemoryNativeBufferOHOS"))(device, pInfo, pBuffer) }
                }
                /// `vkGetNativeBufferPropertiesOHOS`
                pub unsafe fn GetNativeBufferPropertiesOHOS(&self, device: VkDevice, buffer: *const OH_NativeBuffer, pProperties: *mut VkNativeBufferPropertiesOHOS) -> VkResult {
                    unsafe { (self.vkGetNativeBufferPropertiesOHOS.expect("Unable to load vkGetNativeBufferPropertiesOHOS"))(device, buffer, pProperties) }
                }
            }
        }

        /// `VK_OHOS_surface`
        pub mod surface {
            use super::*;

            /// `VK_OHOS_surface`
            pub const NAME: &'static CStr = c!("VK_OHOS_surface");

            /// InstanceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct InstanceCommands {
                pub vkCreateSurfaceOHOS: PFN_vkCreateSurfaceOHOS,
            }

            impl InstanceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkCreateSurfaceOHOS: get(c!("vkCreateSurfaceOHOS")).map(|a| a.cast()),
                    } }
                }
            }

            impl InstanceCommands {
                /// `vkCreateSurfaceOHOS`
                pub unsafe fn CreateSurfaceOHOS(&self, instance: VkInstance, pCreateInfo: *const VkSurfaceCreateInfoOHOS, pAllocator: *const VkAllocationCallbacks, pSurface: *mut VkSurfaceKHR) -> VkResult {
                    unsafe { (self.vkCreateSurfaceOHOS.expect("Unable to load vkCreateSurfaceOHOS"))(instance, pCreateInfo, pAllocator, pSurface) }
                }
            }
        }
    }
    /// `QCOM` prefix extensions
    pub mod qcom {
        use core::ffi::CStr;
        use crate::loader::*;
        use crate::ffi::*;
        use crate::*;

        /// `VK_QCOM_render_pass_shader_resolve`
        pub mod render_pass_shader_resolve {
            use super::*;

            /// `VK_QCOM_render_pass_shader_resolve`
            pub const NAME: &'static CStr = c!("VK_QCOM_render_pass_shader_resolve");
        }

        /// `VK_QCOM_cooperative_matrix_conversion`
        pub mod cooperative_matrix_conversion {
            use super::*;

            /// `VK_QCOM_cooperative_matrix_conversion`
            pub const NAME: &'static CStr = c!("VK_QCOM_cooperative_matrix_conversion");
        }

        /// `VK_QCOM_render_pass_transform`
        pub mod render_pass_transform {
            use super::*;

            /// `VK_QCOM_render_pass_transform`
            pub const NAME: &'static CStr = c!("VK_QCOM_render_pass_transform");
        }

        /// `VK_QCOM_render_pass_store_ops`
        pub mod render_pass_store_ops {
            use super::*;

            /// `VK_QCOM_render_pass_store_ops`
            pub const NAME: &'static CStr = c!("VK_QCOM_render_pass_store_ops");
        }

        /// `VK_QCOM_tile_shading`
        pub mod tile_shading {
            use super::*;

            /// `VK_QCOM_tile_shading`
            pub const NAME: &'static CStr = c!("VK_QCOM_tile_shading");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkCmdBeginPerTileExecutionQCOM: PFN_vkCmdBeginPerTileExecutionQCOM,
                pub vkCmdDispatchTileQCOM: PFN_vkCmdDispatchTileQCOM,
                pub vkCmdEndPerTileExecutionQCOM: PFN_vkCmdEndPerTileExecutionQCOM,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkCmdBeginPerTileExecutionQCOM: get(c!("vkCmdBeginPerTileExecutionQCOM")).map(|a| a.cast()),
                        vkCmdDispatchTileQCOM: get(c!("vkCmdDispatchTileQCOM")).map(|a| a.cast()),
                        vkCmdEndPerTileExecutionQCOM: get(c!("vkCmdEndPerTileExecutionQCOM")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkCmdBeginPerTileExecutionQCOM`
                pub unsafe fn CmdBeginPerTileExecutionQCOM(&self, commandBuffer: VkCommandBuffer, pPerTileBeginInfo: *const VkPerTileBeginInfoQCOM) -> () {
                    unsafe { (self.vkCmdBeginPerTileExecutionQCOM.expect("Unable to load vkCmdBeginPerTileExecutionQCOM"))(commandBuffer, pPerTileBeginInfo) }
                }
                /// `vkCmdDispatchTileQCOM`
                pub unsafe fn CmdDispatchTileQCOM(&self, commandBuffer: VkCommandBuffer, pDispatchTileInfo: *const VkDispatchTileInfoQCOM) -> () {
                    unsafe { (self.vkCmdDispatchTileQCOM.expect("Unable to load vkCmdDispatchTileQCOM"))(commandBuffer, pDispatchTileInfo) }
                }
                /// `vkCmdEndPerTileExecutionQCOM`
                pub unsafe fn CmdEndPerTileExecutionQCOM(&self, commandBuffer: VkCommandBuffer, pPerTileEndInfo: *const VkPerTileEndInfoQCOM) -> () {
                    unsafe { (self.vkCmdEndPerTileExecutionQCOM.expect("Unable to load vkCmdEndPerTileExecutionQCOM"))(commandBuffer, pPerTileEndInfo) }
                }
            }
        }

        /// `VK_QCOM_rotated_copy_commands`
        pub mod rotated_copy_commands {
            use super::*;

            /// `VK_QCOM_rotated_copy_commands`
            pub const NAME: &'static CStr = c!("VK_QCOM_rotated_copy_commands");
        }

        /// `VK_QCOM_fragment_density_map_offset`
        pub mod fragment_density_map_offset {
            use super::*;

            /// `VK_QCOM_fragment_density_map_offset`
            pub const NAME: &'static CStr = c!("VK_QCOM_fragment_density_map_offset");
        }

        /// `VK_QCOM_image_processing`
        pub mod image_processing {
            use super::*;

            /// `VK_QCOM_image_processing`
            pub const NAME: &'static CStr = c!("VK_QCOM_image_processing");
        }

        /// `VK_QCOM_tile_properties`
        pub mod tile_properties {
            use super::*;

            /// `VK_QCOM_tile_properties`
            pub const NAME: &'static CStr = c!("VK_QCOM_tile_properties");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkGetDynamicRenderingTilePropertiesQCOM: PFN_vkGetDynamicRenderingTilePropertiesQCOM,
                pub vkGetFramebufferTilePropertiesQCOM: PFN_vkGetFramebufferTilePropertiesQCOM,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkGetDynamicRenderingTilePropertiesQCOM: get(c!("vkGetDynamicRenderingTilePropertiesQCOM")).map(|a| a.cast()),
                        vkGetFramebufferTilePropertiesQCOM: get(c!("vkGetFramebufferTilePropertiesQCOM")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkGetDynamicRenderingTilePropertiesQCOM`
                pub unsafe fn GetDynamicRenderingTilePropertiesQCOM(&self, device: VkDevice, pRenderingInfo: *const VkRenderingInfo, pProperties: *mut VkTilePropertiesQCOM) -> VkResult {
                    unsafe { (self.vkGetDynamicRenderingTilePropertiesQCOM.expect("Unable to load vkGetDynamicRenderingTilePropertiesQCOM"))(device, pRenderingInfo, pProperties) }
                }
                /// `vkGetFramebufferTilePropertiesQCOM`
                pub unsafe fn GetFramebufferTilePropertiesQCOM(&self, device: VkDevice, framebuffer: VkFramebuffer, pPropertiesCount: *mut uint32_t, pProperties: *mut VkTilePropertiesQCOM) -> VkResult {
                    unsafe { (self.vkGetFramebufferTilePropertiesQCOM.expect("Unable to load vkGetFramebufferTilePropertiesQCOM"))(device, framebuffer, pPropertiesCount, pProperties) }
                }
            }
        }

        /// `VK_QCOM_multiview_per_view_viewports`
        pub mod multiview_per_view_viewports {
            use super::*;

            /// `VK_QCOM_multiview_per_view_viewports`
            pub const NAME: &'static CStr = c!("VK_QCOM_multiview_per_view_viewports");
        }

        /// `VK_QCOM_multiview_per_view_render_areas`
        pub mod multiview_per_view_render_areas {
            use super::*;

            /// `VK_QCOM_multiview_per_view_render_areas`
            pub const NAME: &'static CStr = c!("VK_QCOM_multiview_per_view_render_areas");
        }

        /// `VK_QCOM_image_processing2`
        pub mod image_processing2 {
            use super::*;

            /// `VK_QCOM_image_processing2`
            pub const NAME: &'static CStr = c!("VK_QCOM_image_processing2");
        }

        /// `VK_QCOM_filter_cubic_weights`
        pub mod filter_cubic_weights {
            use super::*;

            /// `VK_QCOM_filter_cubic_weights`
            pub const NAME: &'static CStr = c!("VK_QCOM_filter_cubic_weights");
        }

        /// `VK_QCOM_ycbcr_degamma`
        pub mod ycbcr_degamma {
            use super::*;

            /// `VK_QCOM_ycbcr_degamma`
            pub const NAME: &'static CStr = c!("VK_QCOM_ycbcr_degamma");
        }

        /// `VK_QCOM_filter_cubic_clamp`
        pub mod filter_cubic_clamp {
            use super::*;

            /// `VK_QCOM_filter_cubic_clamp`
            pub const NAME: &'static CStr = c!("VK_QCOM_filter_cubic_clamp");
        }

        /// `VK_QCOM_tile_memory_heap`
        pub mod tile_memory_heap {
            use super::*;

            /// `VK_QCOM_tile_memory_heap`
            pub const NAME: &'static CStr = c!("VK_QCOM_tile_memory_heap");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkCmdBindTileMemoryQCOM: PFN_vkCmdBindTileMemoryQCOM,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkCmdBindTileMemoryQCOM: get(c!("vkCmdBindTileMemoryQCOM")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkCmdBindTileMemoryQCOM`
                pub unsafe fn CmdBindTileMemoryQCOM(&self, commandBuffer: VkCommandBuffer, pTileMemoryBindInfo: *const VkTileMemoryBindInfoQCOM) -> () {
                    unsafe { (self.vkCmdBindTileMemoryQCOM.expect("Unable to load vkCmdBindTileMemoryQCOM"))(commandBuffer, pTileMemoryBindInfo) }
                }
            }
        }

        /// `VK_QCOM_data_graph_model`
        pub mod data_graph_model {
            use super::*;

            /// `VK_QCOM_data_graph_model`
            pub const NAME: &'static CStr = c!("VK_QCOM_data_graph_model");
        }
    }
    /// `QNX` prefix extensions
    pub mod qnx {
        use core::ffi::CStr;
        use crate::loader::*;
        use crate::ffi::*;
        use crate::*;

        /// `VK_QNX_screen_surface`
        pub mod screen_surface {
            use super::*;

            /// `VK_QNX_screen_surface`
            pub const NAME: &'static CStr = c!("VK_QNX_screen_surface");

            /// InstanceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct InstanceCommands {
                pub vkCreateScreenSurfaceQNX: PFN_vkCreateScreenSurfaceQNX,
                pub vkGetPhysicalDeviceScreenPresentationSupportQNX: PFN_vkGetPhysicalDeviceScreenPresentationSupportQNX,
            }

            impl InstanceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkCreateScreenSurfaceQNX: get(c!("vkCreateScreenSurfaceQNX")).map(|a| a.cast()),
                        vkGetPhysicalDeviceScreenPresentationSupportQNX: get(c!("vkGetPhysicalDeviceScreenPresentationSupportQNX")).map(|a| a.cast()),
                    } }
                }
            }

            impl InstanceCommands {
                /// `vkCreateScreenSurfaceQNX`
                pub unsafe fn CreateScreenSurfaceQNX(&self, instance: VkInstance, pCreateInfo: *const VkScreenSurfaceCreateInfoQNX, pAllocator: *const VkAllocationCallbacks, pSurface: *mut VkSurfaceKHR) -> VkResult {
                    unsafe { (self.vkCreateScreenSurfaceQNX.expect("Unable to load vkCreateScreenSurfaceQNX"))(instance, pCreateInfo, pAllocator, pSurface) }
                }
                /// `vkGetPhysicalDeviceScreenPresentationSupportQNX`
                pub unsafe fn GetPhysicalDeviceScreenPresentationSupportQNX(&self, physicalDevice: VkPhysicalDevice, queueFamilyIndex: uint32_t, window: *mut _screen_window) -> VkBool32 {
                    unsafe { (self.vkGetPhysicalDeviceScreenPresentationSupportQNX.expect("Unable to load vkGetPhysicalDeviceScreenPresentationSupportQNX"))(physicalDevice, queueFamilyIndex, window) }
                }
            }
        }

        /// `VK_QNX_external_memory_screen_buffer`
        pub mod external_memory_screen_buffer {
            use super::*;

            /// `VK_QNX_external_memory_screen_buffer`
            pub const NAME: &'static CStr = c!("VK_QNX_external_memory_screen_buffer");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkGetScreenBufferPropertiesQNX: PFN_vkGetScreenBufferPropertiesQNX,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkGetScreenBufferPropertiesQNX: get(c!("vkGetScreenBufferPropertiesQNX")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkGetScreenBufferPropertiesQNX`
                pub unsafe fn GetScreenBufferPropertiesQNX(&self, device: VkDevice, buffer: *const _screen_buffer, pProperties: *mut VkScreenBufferPropertiesQNX) -> VkResult {
                    unsafe { (self.vkGetScreenBufferPropertiesQNX.expect("Unable to load vkGetScreenBufferPropertiesQNX"))(device, buffer, pProperties) }
                }
            }
        }
    }
    /// `SEC` prefix extensions
    pub mod sec {
        use core::ffi::CStr;
        use crate::loader::*;
        use crate::ffi::*;
        use crate::*;

        /// `VK_SEC_amigo_profiling`
        pub mod amigo_profiling {
            use super::*;

            /// `VK_SEC_amigo_profiling`
            pub const NAME: &'static CStr = c!("VK_SEC_amigo_profiling");
        }

        /// `VK_SEC_pipeline_cache_incremental_mode`
        pub mod pipeline_cache_incremental_mode {
            use super::*;

            /// `VK_SEC_pipeline_cache_incremental_mode`
            pub const NAME: &'static CStr = c!("VK_SEC_pipeline_cache_incremental_mode");
        }

        /// `VK_SEC_ubm_surface`
        pub mod ubm_surface {
            use super::*;

            /// `VK_SEC_ubm_surface`
            pub const NAME: &'static CStr = c!("VK_SEC_ubm_surface");

            /// InstanceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct InstanceCommands {
                pub vkCreateUbmSurfaceSEC: PFN_vkCreateUbmSurfaceSEC,
                pub vkGetPhysicalDeviceUbmPresentationSupportSEC: PFN_vkGetPhysicalDeviceUbmPresentationSupportSEC,
            }

            impl InstanceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkCreateUbmSurfaceSEC: get(c!("vkCreateUbmSurfaceSEC")).map(|a| a.cast()),
                        vkGetPhysicalDeviceUbmPresentationSupportSEC: get(c!("vkGetPhysicalDeviceUbmPresentationSupportSEC")).map(|a| a.cast()),
                    } }
                }
            }

            impl InstanceCommands {
                /// `vkCreateUbmSurfaceSEC`
                pub unsafe fn CreateUbmSurfaceSEC(&self, instance: VkInstance, pCreateInfo: *const VkUbmSurfaceCreateInfoSEC, pAllocator: *const VkAllocationCallbacks, pSurface: *mut VkSurfaceKHR) -> VkResult {
                    unsafe { (self.vkCreateUbmSurfaceSEC.expect("Unable to load vkCreateUbmSurfaceSEC"))(instance, pCreateInfo, pAllocator, pSurface) }
                }
                /// `vkGetPhysicalDeviceUbmPresentationSupportSEC`
                pub unsafe fn GetPhysicalDeviceUbmPresentationSupportSEC(&self, physicalDevice: VkPhysicalDevice, queueFamilyIndex: uint32_t, device: *mut ubm_device) -> VkBool32 {
                    unsafe { (self.vkGetPhysicalDeviceUbmPresentationSupportSEC.expect("Unable to load vkGetPhysicalDeviceUbmPresentationSupportSEC"))(physicalDevice, queueFamilyIndex, device) }
                }
            }
        }
    }
    /// `VALVE` prefix extensions
    pub mod valve {
        use core::ffi::CStr;
        use crate::loader::*;
        use crate::ffi::*;
        use crate::*;

        /// `VK_VALVE_mutable_descriptor_type`
        pub mod mutable_descriptor_type {
            use super::*;

            /// `VK_VALVE_mutable_descriptor_type`
            pub const NAME: &'static CStr = c!("VK_VALVE_mutable_descriptor_type");
        }

        /// `VK_VALVE_video_encode_rgb_conversion`
        pub mod video_encode_rgb_conversion {
            use super::*;

            /// `VK_VALVE_video_encode_rgb_conversion`
            pub const NAME: &'static CStr = c!("VK_VALVE_video_encode_rgb_conversion");
        }

        /// `VK_VALVE_descriptor_set_host_mapping`
        pub mod descriptor_set_host_mapping {
            use super::*;

            /// `VK_VALVE_descriptor_set_host_mapping`
            pub const NAME: &'static CStr = c!("VK_VALVE_descriptor_set_host_mapping");

            /// DeviceCommands
            #[derive(Debug, Clone, Copy)]
            pub struct DeviceCommands {
                pub vkGetDescriptorSetHostMappingVALVE: PFN_vkGetDescriptorSetHostMappingVALVE,
                pub vkGetDescriptorSetLayoutHostMappingInfoVALVE: PFN_vkGetDescriptorSetLayoutHostMappingInfoVALVE,
            }

            impl DeviceCommands {
                pub unsafe fn load(mut get: impl FnMut(&CStr) -> Option<ProcAddr>) -> Self {
                    unsafe { Self {
                        vkGetDescriptorSetHostMappingVALVE: get(c!("vkGetDescriptorSetHostMappingVALVE")).map(|a| a.cast()),
                        vkGetDescriptorSetLayoutHostMappingInfoVALVE: get(c!("vkGetDescriptorSetLayoutHostMappingInfoVALVE")).map(|a| a.cast()),
                    } }
                }
            }

            impl DeviceCommands {
                /// `vkGetDescriptorSetHostMappingVALVE`
                pub unsafe fn GetDescriptorSetHostMappingVALVE(&self, device: VkDevice, descriptorSet: VkDescriptorSet, ppData: *mut *mut void) -> () {
                    unsafe { (self.vkGetDescriptorSetHostMappingVALVE.expect("Unable to load vkGetDescriptorSetHostMappingVALVE"))(device, descriptorSet, ppData) }
                }
                /// `vkGetDescriptorSetLayoutHostMappingInfoVALVE`
                pub unsafe fn GetDescriptorSetLayoutHostMappingInfoVALVE(&self, device: VkDevice, pBindingReference: *const VkDescriptorSetBindingReferenceVALVE, pHostMapping: *mut VkDescriptorSetLayoutHostMappingInfoVALVE) -> () {
                    unsafe { (self.vkGetDescriptorSetLayoutHostMappingInfoVALVE.expect("Unable to load vkGetDescriptorSetLayoutHostMappingInfoVALVE"))(device, pBindingReference, pHostMapping) }
                }
            }
        }

        /// `VK_VALVE_fragment_density_map_layered`
        pub mod fragment_density_map_layered {
            use super::*;

            /// `VK_VALVE_fragment_density_map_layered`
            pub const NAME: &'static CStr = c!("VK_VALVE_fragment_density_map_layered");
        }

        /// `VK_VALVE_shader_mixed_float_dot_product`
        pub mod shader_mixed_float_dot_product {
            use super::*;

            /// `VK_VALVE_shader_mixed_float_dot_product`
            pub const NAME: &'static CStr = c!("VK_VALVE_shader_mixed_float_dot_product");
        }
    }
}

